Merge remote-tracking branch 'origin/master' into worktree/steer-followup-images

.agents/notes/implemented/architecture/2026-07-23-client-plugin-loading-model.i18n.yaml

@@ -2,5 +2,5 @@
 # side as of the last confirmed-consistent state. Both languages carry equal authority;
 # after editing either side, bring the other along and re-record with:
 #   pnpm run verify-translation-pairing --write .agents/notes/implemented/architecture/2026-07-23-client-plugin-loading-model.md
-2026-07-23-client-plugin-loading-model.md: 0fe4e86410f3b313ec5a31099d5a6ed1f828585b
-2026-07-23-client-plugin-loading-model.zh.md: 386b0edb722d8cedd9325c941f9b392b8cdc8ae2
+2026-07-23-client-plugin-loading-model.md: 1d08aa71378e7e135b67428a1afca2499de7cc60
+2026-07-23-client-plugin-loading-model.zh.md: 8aaa5d38f63d115fa89216d2b37682ba65a1d8cc

.agents/notes/implemented/architecture/2026-07-23-client-plugin-loading-model.md

@@ -53,8 +53,8 @@ What happens between `dsh web` starting and the UI appearing? Three stages: the
 **Host side — compose the graph.**
 
 1. The composing app (`apps/cli`) ships the roster as ordinary rows in its `cordis.yml` config tree — client plugin packages are entry rows like every host plugin, including the always-mounted `client-hmr` row. A roster row that fails to import is caught by `assertEntriesLoaded`; a row whose fiber rejects is reported with its original stack by `assertEntriesActivated` ([host boot decision](2026-07-24-web-config-tree-boot-and-transport-layering.md)).
-2. The `dsh-client-modules` node half (the package is dual-face: its browser half is the module table) scans loader entries' package.json `dsh.client` declarations and composes `window.__DSH_BOOT__`: `{ rev, entries: [{ id, url, rev, inject?, immediately?, external? }], batches: [{ phase, url, rev, entries }] }`. The row's three optional fields come from manifests, never hand-copied. Composition orders requested dynamic rows before their consumers, rejects synchronous request cycles, and assigns every row to exactly one initial batch. It refuses declared plugins without built `./client` bundles and groups their package/path rows under one required source-build instruction; malformed declaration fields also fail activation, and the Host audit reports either error from the FAILED fiber.
-3. Scanning is incremental per package — there is no full-rescan code path. Each cordis `internal/plugin` emission marks the fiber's entry name dirty (entry-less fibers drop O(1)); a microtask flush reconciles each dirty name against live loader entries, with package metadata (including the negative "not a client package" verdict) cached per name forever and bundle re-hashing reachable only through `rebuilt(id)`. The activation pass seeds the same dirty set from current entries and flushes synchronously, so first scan and steady state share one implementation. Initial rows receive an opaque process nonce plus sequence without hashing their artifacts; startup combo revisions hash the combined script inputs plus indexed map, and the rows plus batch descriptors hash into `graph.rev`. The graph types are single-sourced in the modules package's `./client` export — the webserver knows nothing about the graph, while modules registers the combo route and contributes structured index-injection rows.
+2. The `dsh-client-modules` node half (the package is dual-face: its browser half is the module table) resolves each live Loader entry through the same `name` and owning-tree `baseUrl` inputs that imported its Host face, then reads the nearest owning package.json `dsh.client` declaration and composes `window.__DSH_BOOT__`: `{ rev, entries: [{ id, url, rev, inject?, immediately?, external? }], batches: [{ phase, url, rev, entries }] }`. The manifest package name is the browser module identity even when an overlay names a relative source or built entry file. Distinct active Loader sources resolving to one package name fail composition; after one source unloads, the surviving source supplies the row without a fiber restart. The row's three optional fields come from manifests, never hand-copied. Composition orders requested dynamic rows before their consumers, rejects synchronous request cycles, and assigns every row to exactly one initial batch. It refuses declared plugins without built `./client` bundles and groups their package/path rows under one required source-build instruction; malformed declaration fields also fail activation, and the Host audit reports either error from the FAILED fiber.
+3. Scanning is incremental per package — there is no full-rescan code path. Each cordis `internal/plugin` emission marks the fiber's entry name dirty (entry-less fibers drop O(1)); a microtask flush reconciles each dirty name against live loader entries, with package metadata (including the negative "not a client package" verdict) cached per entry name and owning-tree base URL for the process lifetime and bundle re-hashing reachable only through `rebuilt(id)`. The activation pass seeds the same dirty set from current entries and flushes synchronously, so first scan and steady state share one implementation. Initial rows receive an opaque process nonce plus sequence without hashing their artifacts; startup combo revisions hash the combined script inputs plus indexed map, and the rows plus batch descriptors hash into `graph.rev`. The graph types are single-sourced in the modules package's `./client` export — the webserver knows nothing about the graph, while modules registers the combo route and contributes structured index-injection rows.
 
 Why is the roster yml rows and not a scan? Because which plugins compose into a deployment is a composition decision, not a package property — a package declaring `dsh.client` in the repo does not mean this deployment mounts it, so discovery-by-scan cannot make that call; the node half scans only what the tree actually mounted.
 

.agents/notes/implemented/architecture/2026-07-23-client-plugin-loading-model.zh.md

@@ -53,8 +53,8 @@ Host 会快照每个已构建插件产物，并把每个调度阶段的有序 ro
 **host 侧——组合这张图。**
 
 1. 负责组合的 app（`apps/cli`）把名册作为普通行放进它的 `cordis.yml` 配置树——client 插件包与每个 host 插件一样是 entry 行，包括无条件挂载的 `client-hmr` 行。名册行 import 失败由 `assertEntriesLoaded` 捕获；fiber reject 的行则由 `assertEntriesActivated` 报告原始 stack（[host boot 决策](2026-07-24-web-config-tree-boot-and-transport-layering.zh.md)）。
-2. `dsh-client-modules` 的 node 半（该包是双面的：浏览器半就是模块表）扫描 loader entry 的 package.json `dsh.client` 声明，组合出 `window.__DSH_BOOT__`：`{ rev, entries: [{ id, url, rev, inject?, immediately?, external? }], batches: [{ phase, url, rev, entries }] }`。Row 的三个可选字段都来自 manifest，永不人肉抄写。组合会把被请求的动态图 row 排到消费者之前、拒绝同步请求环，并把每个 row 恰好分配给一个初始批次。它会拒绝没有已构建 `./client` bundle 的已声明插件，并把它们的 package/path 行归到一条源码构建要求下；畸形声明字段同样会让激活失败，Host 检查会从 FAILED fiber 报告这两类错误。
-3. 扫描是单包增量——不存在全量重扫代码路径。每次 cordis `internal/plugin` 发射把该 fiber 的 entry 名标脏（无 entry 的 fiber O(1) 丢弃）；微任务 flush 把每个脏名对账 live loader entries，包元数据（含「非 client 包」的否定结论）按名永久缓存，bundle 重哈希只经 `rebuilt(id)` 可达。激活趟从当前 entries 灌同一脏集合并同步 flush，初扫与稳态共享一条实现。初始 row 使用不透明的进程 nonce 加序号，不对其产物求哈希；启动 combo revision 对合并脚本输入及 indexed map 求哈希，row 与批次描述再共同哈希进 `graph.rev`。图类型单源在 modules 包的 `./client` 出口——webserver 对图一无所知；modules 会注册 combo 路由并贡献结构化 index 注入行。
+2. `dsh-client-modules` 的 node 半（该包是双面的：浏览器半就是模块表）使用 Host face import 时相同的 `name` 与所属 tree `baseUrl` 解析每个 live Loader entry，再读取最近归属 package.json 的 `dsh.client` 声明并组合出 `window.__DSH_BOOT__`：`{ rev, entries: [{ id, url, rev, inject?, immediately?, external? }], batches: [{ phase, url, rev, entries }] }`。即使 overlay 指向相对的 source 或 built entry 文件，manifest 包名仍是浏览器模块身份。若不同的 active Loader source 解析到同一包名，组合会失败；一个来源卸载后，仍存活的来源无需重启 fiber 即可提供该 row。Row 的三个可选字段都来自 manifest，永不人肉抄写。组合会把被请求的动态图 row 排到消费者之前、拒绝同步请求环，并把每个 row 恰好分配给一个初始批次。它会拒绝没有已构建 `./client` bundle 的已声明插件，并把它们的 package/path 行归到一条源码构建要求下；畸形声明字段同样会让激活失败，Host 检查会从 FAILED fiber 报告这两类错误。
+3. 扫描是单包增量——不存在全量重扫代码路径。每次 cordis `internal/plugin` 发射把该 fiber 的 entry 名标脏（无 entry 的 fiber O(1) 丢弃）；微任务 flush 把每个脏名对账 live loader entries，包元数据（含「非 client 包」的否定结论）按 entry 名与所属 tree base URL 缓存至进程结束，bundle 重哈希只经 `rebuilt(id)` 可达。激活趟从当前 entries 灌同一脏集合并同步 flush，初扫与稳态共享一条实现。初始 row 使用不透明的进程 nonce 加序号，不对其产物求哈希；启动 combo revision 对合并脚本输入及 indexed map 求哈希，row 与批次描述再共同哈希进 `graph.rev`。图类型单源在 modules 包的 `./client` 出口——webserver 对图一无所知；modules 会注册 combo 路由并贡献结构化 index 注入行。
 
 为什么名册是 yml 行而不是扫描？因为哪些插件组合进一次部署是组合决策，不是包属性——一个在仓库中声明了 dsh.client 的包，不代表这次部署要挂载它，扫描发现无从替人做这个决定；node 半只扫描配置树实际挂载了的东西。
 

.agents/notes/implemented/architecture/2026-08-24-cordis-runtime-tree-inspection.i18n.yaml

@@ -2,5 +2,5 @@
 # side as of the last confirmed-consistent state. Both languages carry equal authority;
 # after editing either side, bring the other along and re-record with:
 #   pnpm run verify-translation-pairing --write .agents/notes/implemented/architecture/2026-08-24-cordis-runtime-tree-inspection.md
-2026-08-24-cordis-runtime-tree-inspection.md: 9784018a050bdb27e791a44e1cd342a31cec42c0
-2026-08-24-cordis-runtime-tree-inspection.zh.md: 05b9b0d4387447b7c8df05b7c7e771e96c767bd9
+2026-08-24-cordis-runtime-tree-inspection.md: 2cd63aa41567adc19d52d584874583183aef3cdc
+2026-08-24-cordis-runtime-tree-inspection.zh.md: 88cf2b344d4feef10f3632918539d3cb98750fc9

.agents/notes/implemented/architecture/2026-08-24-cordis-runtime-tree-inspection.md

@@ -42,7 +42,7 @@ The identities are intentionally distinct:
 - `NodeId` is assigned per DevTools connection when a node enters that frontend's document. It remains stable while the corresponding backend node is retained and is discarded when that node leaves the tree, on the rare full-document fallback, or when the connection closes.
 - `RemoteObjectId` is assigned by the selected Runtime session when `DOM.resolveNode` exposes the live object. It remains scoped to that DevTools connection and object group.
 
-`sourceId` identifies one Client runtime instance and remains stable across its automatic transport reconnects; `generation` identifies one WebSocket admission. Disconnect removes the synthetic context from the Console with `Runtime.executionContextDestroyed`. Reconnection announces a fresh CDP execution-context id because the destroyed id and its RemoteObjects cannot be reused, but this does not imply that the browser's underlying JavaScript realm was recreated.
+`sourceId` identifies one browser-tab Client runtime and is retained in that tab's `sessionStorage`, so automatic transport reconnects and page refreshes reuse it. Before opening the transport, a Client with Web Locks claims that id for its page lifetime; a simultaneously live tab copied from the same storage state cannot claim it and persists a fresh id instead. Browsers without Web Locks retain storage-backed refresh identity but cannot arbitrate copied live tabs. `generation` identifies one WebSocket admission and always rotates. Disconnect removes the synthetic context from the Console with `Runtime.executionContextDestroyed`. Reconnection announces a fresh CDP execution-context id because the destroyed id and its RemoteObjects cannot be reused, but this does not imply that the browser's underlying JavaScript realm was recreated.
 
 Standard CDP does not place a `RemoteObjectId` field on `DOM.Node`. `DOM.Node` carries `nodeId` and `backendNodeId`; `DOM.resolveNode` returns the corresponding `Runtime.RemoteObject`, and `DOM.requestNode` performs the reverse mapping. The implementation keeps these three CDP identities correlated without adding non-standard DOM fields.
 

.agents/notes/implemented/architecture/2026-08-24-cordis-runtime-tree-inspection.zh.md

@@ -42,7 +42,7 @@ collector 从 root、注册表中的每个 live Fiber，以及每个 event hook
 - `NodeId` 在节点进入某个 frontend document 时按 DevTools 连接分配；对应 backend node 被保留期间保持稳定，并在节点离开树、少见的整 document fallback 或连接关闭时丢弃。
 - `RemoteObjectId` 在 `DOM.resolveNode` 暴露实时对象时由选定的 Runtime session 分配；它只属于该 DevTools 连接和 object group。
 
-`sourceId` 标识一个 Client runtime instance，并在自动重连 transport 时保持稳定；`generation` 标识一次 WebSocket 接纳。断联通过 `Runtime.executionContextDestroyed` 从 Console 移除 synthetic context。重连会发布新的 CDP execution-context id，因为已销毁的 id 及其 RemoteObject 不能复用；这并不表示浏览器底层 JavaScript realm 被重新创建。
+`sourceId` 标识一个浏览器 tab 的 Client runtime，并保存在该 tab 的 `sessionStorage` 中，因此自动重连 transport 与页面刷新都会复用它。Client 在打开 transport 前会在 Web Locks 可用时独占该 id，直至页面结束；从同一存储状态复制出的另一个同时存活 tab 无法取得该锁，因而会持久化一个新 id。缺少 Web Locks 的浏览器仍保留基于存储的刷新身份，但无法仲裁复制出的 live tab。`generation` 标识一次 WebSocket 接纳且每次都会轮换。断联通过 `Runtime.executionContextDestroyed` 从 Console 移除 synthetic context。重连会发布新的 CDP execution-context id，因为已销毁的 id 及其 RemoteObject 不能复用；这并不表示浏览器底层 JavaScript realm 被重新创建。
 
 标准 CDP 不会在 `DOM.Node` 上放置 `RemoteObjectId` 字段。`DOM.Node` 携带 `nodeId` 与 `backendNodeId`；`DOM.resolveNode` 返回对应的 `Runtime.RemoteObject`，`DOM.requestNode` 执行反向映射。实现会关联这三类 CDP 身份，而不添加非标准 DOM 字段。
 

.agents/notes/implemented/architecture/2026-08-27-inspector-development-mount.i18n.yaml

@@ -2,5 +2,5 @@
 # side as of the last confirmed-consistent state. Both languages carry equal authority;
 # after editing either side, bring the other along and re-record with:
 #   pnpm run verify-translation-pairing --write .agents/notes/implemented/architecture/2026-08-27-inspector-development-mount.md
-2026-08-27-inspector-development-mount.md: 0e5f0af52306ebb553e4fb911696cfc3fae087ee
-2026-08-27-inspector-development-mount.zh.md: 252e52692df2ad983e6da9ee9640c5ae6603f20f
+2026-08-27-inspector-development-mount.md: a8660c664f6fba49369af075bc998171a454a842
+2026-08-27-inspector-development-mount.zh.md: 3dd82cc89e4c172c3ff9a4f8dc4cafd47c9fd847

.agents/notes/implemented/architecture/2026-08-27-inspector-development-mount.md

@@ -10,21 +10,17 @@ English | [中文](2026-08-27-inspector-development-mount.zh.md)
 
 ## Decision
 
-The inspector package owns a development overlay, `packages/experimental/inspector/cordis.patch.yml`, holding a single `insert` of the `experimental-inspector` row. A launch selects it through the generic overlay flag; `pnpm run demo:inspector` is the shorthand for `pnpm dsh web --patch ./packages/experimental/inspector/cordis.patch.yml`.
+The inspector package owns two development overlays. `packages/experimental/inspector/cordis.source.patch.yml` inserts `./src/index.ts` for the tsx source launch behind `pnpm run demo:inspector`. `packages/experimental/inspector/cordis.patch.yml` inserts `./lib/index.js` for `node apps/cli/lib/bin.js web --patch ./packages/experimental/inspector/cordis.patch.yml` after `pnpm run build`.
 
-The overlay contributes only the row; the row's module resolves from the profile plane at entry import:
-
-- A source launch (`pnpm dsh`, tsx) resolves the workspace package through the tsconfig `paths` facade and needs no installation.
-- A built launch (`node apps/cli/lib/bin.js`) needs the package importable from the profile first: `dsh plugin --profile web add link:<absolute package path>`, once per profile. `link:` keeps dependency resolution inside the real package directory; `file:` re-installs the package's `workspace:^` dependencies in the profile and fails with `ERR_PNPM_WORKSPACE_PKG_NOT_FOUND`.
-
-A launch whose profile cannot import the package fails loud at entry import (`Cannot find package '@deepseek-ai/dsh-experimental-inspector' imported from <profile dir>`); nothing is skipped silently.
+Each relative entry resolves from its overlay file's directory through the Loader's normal owning-tree `baseUrl`. The source launch therefore reaches TypeScript directly, while the built launch reaches the package artifact; neither path reads or modifies profile-installed plugin state. A missing source or built entry fails loud during Loader import rather than skipping the Inspector.
 
 ## Consequences
 
-Published packages carry no trace of the inspector: no manifest entry, no composition row, no launcher flag. Mounting stays a per-launch choice — the same service without the overlay never loads the package — and every layer the launch composes is declared in a config file. The cost is launch-mode asymmetry: a built launch needs the one-time profile `link:` install, and the overlay must be named on every invocation, which `pnpm run demo:inspector` absorbs for the common case.
+Published packages carry no trace of the inspector: no manifest entry, no composition row, no launcher flag. Mounting stays a per-launch choice — the same service without an overlay never loads the package — and every layer the launch composes is declared in a config file. The source shorthand names its overlay automatically; a built launch names the built overlay explicitly and requires current `lib/` artifacts.
 
 ## Alternatives considered
 
 - A `disabled: !!js` row in the shipped web-app patch: the dependency gate and npm publication both force the private package into the published manifest.
 - A `--inspector` launcher flag mounting the package as an extra bundle layer: the launcher owns neither app flags nor plugin package names.
 - An optional `peerDependencies` entry on `dsh-web-app` plus a dynamic `ctx.loader.create` from its glue plugin: it writes a never-published name into a published manifest and mounts a row no config layer declares.
+- One bare-package overlay for both launch modes: source resolution can use the workspace facade, but built resolution would require persistent profile installation state unrelated to the launch command.

.agents/notes/implemented/architecture/2026-08-27-inspector-development-mount.zh.md

@@ -10,21 +10,17 @@ Status: implemented
 
 ## Decision
 
-inspector 包自有一份开发 overlay，`packages/experimental/inspector/cordis.patch.yml`，只含一个 `insert` 的 `experimental-inspector` 行。启动通过通用 overlay flag 选它；`pnpm run demo:inspector` 是 `pnpm dsh web --patch ./packages/experimental/inspector/cordis.patch.yml` 的简写。
+inspector 包自有两份开发 overlay。`packages/experimental/inspector/cordis.source.patch.yml` 为 `pnpm run demo:inspector` 背后的 tsx 源码启动插入 `./src/index.ts`；`packages/experimental/inspector/cordis.patch.yml` 为执行过 `pnpm run build` 后的 `node apps/cli/lib/bin.js web --patch ./packages/experimental/inspector/cordis.patch.yml` 插入 `./lib/index.js`。
 
-overlay 只贡献这一行；行的模块在 entry import 时从 profile 平面解析：
-
-- 源码启动（`pnpm dsh`，tsx）经 tsconfig `paths` 门面解析 workspace 包，无需任何安装。
-- built 启动（`node apps/cli/lib/bin.js`）需先让包可从 profile import：`dsh plugin --profile web add link:<包目录绝对路径>`，每个 profile 一次。`link:` 让依赖解析留在真实包目录内；`file:` 会在 profile 里重装该包的 `workspace:^` 依赖并以 `ERR_PNPM_WORKSPACE_PKG_NOT_FOUND` 失败。
-
-profile 无法 import 该包的启动会在 entry import 处响亮失败（`Cannot find package '@deepseek-ai/dsh-experimental-inspector' imported from <profile dir>`）；不存在静默跳过。
+两个相对 entry 都通过 Loader 常规的所属 tree `baseUrl` 从各自 overlay 文件目录解析。源码启动因此直接读取 TypeScript，built 启动读取包产物；两条路径都不读取或修改 profile 已安装插件状态。源码或 built entry 缺失时，Loader import 会响亮失败，不会跳过 Inspector。
 
 ## Consequences
 
-已发布的包不携带 inspector 的任何痕迹：没有 manifest 条目、没有组合行、没有 launcher flag。挂载保持按次启动选择——不带 overlay 的同一服务永远不会加载该包——且启动组合的每一层都由 config 文件声明。代价是启动方式不对称：built 启动需要一次性 profile `link:` 安装，且每次调用都要点名 overlay，常见场景由 `pnpm run demo:inspector` 吸收。
+已发布的包不携带 inspector 的任何痕迹：没有 manifest 条目、没有组合行、没有 launcher flag。挂载保持按次启动选择——不带 overlay 的同一服务永远不会加载该包——且启动组合的每一层都由 config 文件声明。源码快捷命令会自动指定对应 overlay；built 启动需显式指定 built overlay，并要求 `lib/` 产物为当前版本。
 
 ## Alternatives considered
 
 - 随货 web-app patch 里放 `disabled: !!js` 行：依赖门禁与 npm 发布都会把 private 包逼进已发布 manifest。
 - `--inspector` launcher flag 把包挂成额外 bundle 层：launcher 既不拥有 app flag 也不拥有插件包名。
 - `dsh-web-app` 上加 optional `peerDependencies` 并由其 glue 插件动态 `ctx.loader.create`：向已发布 manifest 写入永不发布的名字，且挂载的行不在任何 config 层声明。
+- 两种启动模式共用一份 bare-package overlay：源码解析可以使用 workspace 门面，但 built 解析会依赖与本次启动命令无关的持久 profile 安装状态。

.agents/notes/implemented/process/2026-08-27-explicit-workspace-path-aliases.i18n.yaml

@@ -0,0 +1,6 @@
+# Bilingual-pair consistency record (docs/i18n/README.md): the git blob hash of each
+# side as of the last confirmed-consistent state. Both languages carry equal authority;
+# after editing either side, bring the other along and re-record with:
+#   pnpm run verify-translation-pairing --write .agents/notes/implemented/process/2026-08-27-explicit-workspace-path-aliases.md
+2026-08-27-explicit-workspace-path-aliases.md: 51d2dee7911d323637121f509e160ef92c352568
+2026-08-27-explicit-workspace-path-aliases.zh.md: 702d3d7a8cf91c8c307b1708fc30faad6cab009a

.agents/notes/implemented/process/2026-08-27-explicit-workspace-path-aliases.md

@@ -0,0 +1,61 @@
+# Agent Note: Explicit workspace path aliases replace per-group wildcards
+
+Status: implemented
+
+English | [中文](2026-08-27-explicit-workspace-path-aliases.zh.md)
+
+## Problem
+
+`tsconfig.base.json` is the resolution facade for the whole repository: every package project extends it, both aggregates read it, and every Vitest config points `vite-tsconfig-paths` at it. Two of its aliases carried one candidate per package *group* rather than one per package — `@deepseek-ai/dsh-*` listed 49 candidate globs and `@deepseek-ai/dsh-*/invariant` listed 45.
+
+TypeScript and tsx try those candidates in order and take the first that exists, so a specifier whose package sits late in the list pays for every earlier miss. Under the `dsh` source launch each miss is an `ERR_MODULE_NOT_FOUND` that Node decorates with `decorateErrorWithCommonJSHints`, which runs a full CommonJS resolution walk per failure. A profile of a source-launch boot attributed 934.6 ms — 35% of the boot — to that decoration path alone, from 60,942 failed resolutions.
+
+The cost fell hardest on the most-imported packages. `packages/util/*` sat at position 44 of 49 and holds the leaf utilities nearly every plugin imports, so `dsh-timeout` paid roughly 9 ms per resolution against 0.05 ms for a specifier with an explicit alias.
+
+## Decision
+
+`scripts/gen-tsconfig-paths.ts` writes one explicit alias per workspace package into a marked region at the end of `paths`, and both group wildcards are deleted. `pnpm run gen-tsconfig-paths` rewrites the region; `pnpm run verify-tsconfig-paths` reports drift instead, and runs in the `ci-static` lane beside the other generated-artifact checks.
+
+The generator emits an alias only for a package whose declared name is exactly `@deepseek-ai/dsh-<directory>`, because that is the only shape a wildcard could ever have resolved: it substituted the specifier's suffix into `packages/<group>/<suffix>/src`. Packages named after something other than their directory — `@deepseek-ai/dsh-typert-protocol` at `packages/typert/protocol`, the `dsh-client-*` and `dsh-host-*` families — already carry hand-written aliases and are left alone. A specifier claimed by two package directories throws rather than picking one, because an explicit map cannot express the group-order tiebreak the wildcard used; no such collision exists today.
+
+Deleting the wildcards removed the fallback that used to resolve a package nobody had aliased, so the generator also asserts coverage: every workspace package carrying a `src` directory must be mapped by a generated or hand-written alias, and `--check` names any that is not. Without it a package whose name does not match its directory could be added, skipped by the generator, and left resolving through the workspace symlink to built `lib/` output — the same artifact-plane leak the explicit aliases exist to close.
+
+The region is written by text surgery between marker comments rather than by re-serializing the file. `tsconfig.base.json` is JSONC and its hand-written aliases carry comments that explain non-obvious mappings; re-serializing would drop them.
+
+This partly supersedes the [package-inventory discovery proposal](../../proposed/process/2026-06-20-discover-package-inventory.md), which records the collapse into one wildcard as current: the wildcard is gone, while that proposal's remaining subject — the aggregate configs' explicit `references` arrays — is untouched here.
+
+Four wildcards remain, each with a single candidate: `dsh-host-*/invariant`, `dsh-client-*/invariant`, `dsh-client-*/client`, and the five `dsh-host-<name>/*` subpath maps. One candidate costs one probe, so expanding them would trade file size for nothing.
+
+## Resolution differences this change makes
+
+Every `@deepseek-ai/dsh-*` specifier appearing in repository sources — 1,023 distinct — resolves to the same target as before, with eleven exceptions that now resolve where they previously did not. All eleven previously reached built `lib/` output through the workspace symlink rather than source.
+
+Seven are `/invariant` subpaths: `dsh-invariants/invariant`, `dsh-lsp/invariant`, `dsh-lsp-stdio/invariant`, `dsh-tool-lsp/invariant`, `dsh-terminal/invariant`, `dsh-terminal-bash/invariant`, and `dsh-tool-terminal/invariant`.
+
+The deleted `dsh-*/invariant` wildcard omitted the `lsp`, `terminal`, `client`, and `host` groups. The `client` and `host` omissions are deliberate and documented — those families have dedicated wildcards because their package names prefix the group directory. The `lsp` and `terminal` omissions have no such reason, and `packages/runtime-diagnostics/invariants` appeared in neither list. Those seven specifiers therefore resolved through the workspace symlink and the package's `./invariant` export to built `lib/types/*.d.ts` instead of to source, which contradicts the rule that static gates resolve workspace imports through `paths` to `src` and pass on a clean tree. Making the aliases uniform resolves them to source like every sibling.
+
+The other four are whole packages the coverage assertion surfaced: `dsh-client-ui-directory-picker-browse`, `dsh-client-ui-directory-picker-native`, `dsh-experimental-agent-team-profile`, and `dsh-experimental-agent-team-web-profile`. Each is named `dsh-<group>-<directory>`, which no wildcard could ever substitute, and each sits beside siblings that do carry hand-written aliases — they were simply missing. They now carry one too.
+
+## Testing
+
+`scripts/gen-tsconfig-paths.spec.ts` pins that the collector maps a package to its own directory, skips packages carrying hand-written aliases, and returns a sorted list; that the renderer yields to a hand-written specifier and closes the region without a trailing comma; that the region writer replaces only the marked span and refuses a config without markers; and that neither group wildcard survives in the committed config. Two further cases pin the coverage assertion: it names an unmapped package, and it reports none against the committed config.
+
+The gate's rejection path is exercised directly: deleting one generated alias makes `verify-tsconfig-paths` exit non-zero, and restoring it makes the check pass.
+
+The CLI entry guard uses the repository's established comparison, `import.meta.filename === resolve(process.argv[1])`, rather than concatenating a `file://` URL. The concatenated form fails whenever `import.meta.url` percent-encodes something `process.argv[1]` does not — a repository path containing a space, or any Windows drive path — and the failure is silent: the script exits 0 having done nothing, which would make the gate a no-op exactly where it is needed. Running a copy from a directory whose name contains a space reproduces that: the concatenated guard evaluates false, the established one true.
+
+## Alternatives considered
+
+**Reordering the wildcard's candidate globs so the hottest groups come first.** This needs no generator and no new gate, and recovers perhaps half the cost by moving `util`, `core`, `llm`, and `session` to the front. It was rejected because the win decays as packages are added, the ordering has no invariant a reader could check, and every group after the first still pays. It also leaves the worst property intact: adding a package group silently slows every boot.
+
+**Moving `paths` into a generated `tsconfig.paths.json` that the base config extends.** This keeps the generated content out of the hand-written file entirely and produces a cleaner diff. It was rejected for this change because several consumers read `tsconfig.base.json` directly rather than through a resolver that follows `extends` — six Vitest configs plus `project-reference-faces.ts`, `verify-export-jsdoc.ts`, `doc-typecheck.ts`, and `rescope-vendor.ts` — and auditing each is a larger change than the aliasing itself. The marker region achieves the same isolation with no consumer risk.
+
+**Keeping the wildcards as a fallback beneath the explicit aliases.** An explicit alias already wins over a wildcard, so correctness would be unchanged, and a package added without regenerating would keep resolving. It was rejected because the fallback is exactly what makes a stale config invisible: the repository's stance is that misconfiguration fails loud, and the `--check` gate turns a missing alias into a named failure instead of a slow boot nobody attributes.
+
+## Consequences
+
+A source-launch boot of the `headless` profile drops from a 2,157/2,182/2,153 ms baseline to 1,069/1,052/1,055 ms — about 1.1 seconds, or 51%, with the two ranges nowhere near overlapping and `--help` output byte-identical.
+
+The win is confined to the tsx source launch. Vitest resolves through `vite-tsconfig-paths`, which matches in-process and checks file existence without ever constructing a Node module error, so it never paid the decoration cost: an A/B over one package's suite measured 5,934/5,829/5,908 ms against 5,878/5,851/5,905 ms, which is noise. Repository gate scripts import few `@deepseek-ai/dsh-*` packages and likewise show no separable difference. Shipped users run built `lib/` under plain Node and were never affected.
+
+`paths` grows from 188 keys to 523, and adding a package now requires running the generator. The `--check` gate makes that a named failure rather than a silent one, and the generated region keeps the diff of such a change to a single line.

.agents/notes/implemented/process/2026-08-27-explicit-workspace-path-aliases.zh.md

@@ -0,0 +1,61 @@
+# Agent Note: Explicit workspace path aliases replace per-group wildcards
+
+Status: implemented
+
+[English](2026-08-27-explicit-workspace-path-aliases.md) | 中文
+
+## Problem
+
+`tsconfig.base.json` 是整个仓库的解析门面：每个包的 project 都 extends 它，两个聚合配置都读它，每个 Vitest 配置都把 `vite-tsconfig-paths` 指向它。其中两条别名按包**分组**而不是按包各写一条候选——`@deepseek-ai/dsh-*` 列了 49 个候选 glob，`@deepseek-ai/dsh-*/invariant` 列了 45 个。
+
+TypeScript 与 tsx 按顺序逐个尝试这些候选、取第一个存在的，因此一个位于列表靠后位置的包，其说明符要为前面每一次未命中买单。在 `dsh` 源码启动下，每次未命中都是一个 `ERR_MODULE_NOT_FOUND`，而 Node 会用 `decorateErrorWithCommonJSHints` 装饰它——每次失败都跑一遍完整的 CommonJS 解析走查。一次源码启动的 profile 把 **934.6 ms（占启动 35%）**单独归给了这条装饰路径，来源是 60,942 次失败解析。
+
+代价最重的恰好落在被引用最多的包上：`packages/util/*` 排在 49 个候选里的第 44 位，却装着几乎每个插件都要引用的叶子工具，因此 `dsh-timeout` 每次解析约付 9 ms，而一个有显式别名的说明符只要 0.05 ms。
+
+## Decision
+
+`scripts/gen-tsconfig-paths.ts` 在 `paths` 末尾一个带标记的区域里，为每个 workspace 包写入一条显式别名，两条分组通配符随之删除。`pnpm run gen-tsconfig-paths` 重写该区域；`pnpm run verify-tsconfig-paths` 只报告漂移，并与其他生成物检查一起跑在 `ci-static` 车道上。
+
+生成器只为**声明名恰好等于 `@deepseek-ai/dsh-<目录名>`** 的包发别名，因为那是通配符唯一可能解析出的形态：它把说明符的后缀代入 `packages/<group>/<后缀>/src`。名字与目录不一致的包——`packages/typert/protocol` 上的 `@deepseek-ai/dsh-typert-protocol`、以及 `dsh-client-*` 与 `dsh-host-*` 两族——本来就有手写别名，保持不动。若某个说明符被两个包目录同时认领，生成器**抛错**而不是任选其一，因为显式映射无法表达通配符依赖的分组顺序裁决；当前不存在这种冲突。
+
+删除通配符也删掉了「没人写别名的包仍能解析」的兜底，因此生成器同时断言覆盖完备：每个含 `src` 的 workspace 包都必须被生成别名或手写别名映射，`--check` 会点名任何未被覆盖者。没有这条断言，一个名字与目录不一致的新包会被生成器跳过，继续经 workspace 软链解析到构建产物 `lib/`——正是显式别名要消除的产物层泄漏。
+
+该区域用标记注释之间的**定点文本改写**生成，而不是重新序列化整个文件。`tsconfig.base.json` 是 JSONC，其手写别名带有解释非显然映射的注释，重新序列化会把它们丢掉。
+
+本决策**部分取代**了[包清单自动发现提案](../../proposed/process/2026-06-20-discover-package-inventory.zh.md)——该提案把「合并为一个通配符」记为当前实现，而通配符已被删除；该提案剩余的主题（聚合配置里显式的 `references` 数组）不受本次改动影响。
+
+保留四条通配符，每条只有一个候选：`dsh-host-*/invariant`、`dsh-client-*/invariant`、`dsh-client-*/client`，以及五条 `dsh-host-<name>/*` 子路径映射。一个候选只花一次探测，展开它们只会换来文件变大而无收益。
+
+## Resolution differences this change makes
+
+仓库源码中出现的每个 `@deepseek-ai/dsh-*` 说明符——共 1,023 个互不相同——解析目标与改动前完全一致，只有十一个例外：它们现在能解析，而此前不能。这十一个此前都是经 workspace 软链解析到构建产物 `lib/`，而不是源码。
+
+其中七个是 `/invariant` 子路径：`dsh-invariants/invariant`、`dsh-lsp/invariant`、`dsh-lsp-stdio/invariant`、`dsh-tool-lsp/invariant`、`dsh-terminal/invariant`、`dsh-terminal-bash/invariant`、`dsh-tool-terminal/invariant`。
+
+被删除的 `dsh-*/invariant` 通配符遗漏了 `lsp`、`terminal`、`client`、`host` 四个分组。其中 `client` 与 `host` 的遗漏是**刻意且有文档的**——这两族有专用通配符，因为它们的包名以分组目录名为前缀。而 `lsp` 与 `terminal` 的遗漏没有任何这类理由，`packages/runtime-diagnostics/invariants` 则两条列表都不在。于是这七个说明符此前是通过 workspace 软链与包的 `./invariant` 导出解析到构建产物 `lib/types/*.d.ts`，而不是解析到源码——这与「静态门禁通过 `paths` 把 workspace 导入解析到 `src`、并在干净树上通过」的规则相抵触。把别名统一之后，它们与所有同类一样解析到源码。
+
+另外四个是被覆盖断言揪出来的**整包**：`dsh-client-ui-directory-picker-browse`、`dsh-client-ui-directory-picker-native`、`dsh-experimental-agent-team-profile`、`dsh-experimental-agent-team-web-profile`。它们都叫 `dsh-<分组>-<目录>`，任何通配符都代不出这种形态；而它们身旁的同族包都有手写别名——这四个只是漏了。现在补上。
+
+## Testing
+
+`scripts/gen-tsconfig-paths.spec.ts` 钉住：收集器把包映射到它自己的目录、跳过带手写别名的包、返回有序列表；渲染器让位于手写说明符，且区域收尾不带多余逗号；区域写入器只替换标记范围，并在缺少标记时拒绝；以及提交后的配置里两条分组通配符都不复存在。另有两条用例钉住覆盖断言：它会点名未被映射的包，且对提交后的配置报告为空。
+
+门禁的拒绝路径被直接验证过：删掉一条生成的别名会让 `verify-tsconfig-paths` 以非零码退出，恢复后检查通过。
+
+CLI 入口守卫采用仓库既有的比较方式 `import.meta.filename === resolve(process.argv[1])`，而不是拼接 `file://` URL。拼接形式在 `import.meta.url` 做了百分号编码而 `process.argv[1]` 没做时失效——仓库路径含空格、或任何 Windows 盘符路径——且失效是静默的：脚本什么也不做就以 0 退出，恰恰会让这道门在最需要它的环境里形同虚设。把脚本复制到一个名字含空格的目录下运行即可复现：拼接式守卫求值为 false，既有写法为 true。
+
+## Alternatives considered
+
+**给通配符的候选 glob 重新排序，把最热的分组放前面。** 这不需要生成器也不需要新门禁，把 `util`、`core`、`llm`、`session` 挪到前面大约能拿回一半收益。否决理由：收益随着包的增加而衰减，这个顺序没有任何读者可核验的不变量，而且第一个分组之后的每一组仍然要付钱。它还保留了最糟的性质——新增一个包分组会悄悄拖慢所有人的启动。
+
+**把 `paths` 挪进一个生成的 `tsconfig.paths.json`，由 base 配置 `extends`。** 这能把生成内容彻底移出手写文件，diff 也更干净。本次否决的理由是：有若干消费者**直接读** `tsconfig.base.json`，而不是通过会跟随 `extends` 的解析器——六个 Vitest 配置，外加 `project-reference-faces.ts`、`verify-export-jsdoc.ts`、`doc-typecheck.ts`、`rescope-vendor.ts`——逐个审计它们比这次别名改造本身还大。标记区域用零消费者风险达成了同样的隔离。
+
+**在显式别名下方保留通配符作为兜底。** 显式别名本来就优先于通配符，因此正确性不变，而且新增包忘了重新生成也仍能解析。否决理由：兜底恰恰是让陈旧配置隐形的原因——仓库的立场是「misconfiguration fails loud」，而 `--check` 门禁把缺失的别名变成一次具名失败，而不是一次没人归因的慢启动。
+
+## Consequences
+
+`headless` profile 的源码启动从 2,157 / 2,182 / 2,153 ms 的基线降到 1,069 / 1,052 / 1,055 ms——约 **1.1 秒，51%**，两个区间相距极远，且 `--help` 输出逐字节一致。
+
+**收益仅限于 tsx 源码启动这一条路径。** Vitest 走 `vite-tsconfig-paths`，它在进程内做匹配与文件存在性检查，从不构造 Node 模块错误，因此从未付过那笔装饰代价：对某个包的整套用例做 A/B，实测 5,934 / 5,829 / 5,908 ms 对 5,878 / 5,851 / 5,905 ms，属于噪声。仓库的门禁脚本只 import 少数几个 `@deepseek-ai/dsh-*` 包，同样测不出可分离的差异。发布用户在裸 Node 下跑构建好的 `lib/`，本来就不受影响。
+
+`paths` 从 188 个 key 增长到 523 个，新增包时必须运行生成器。`--check` 门禁把这件事变成一次具名失败而非静默失败，而生成区域让这类改动的 diff 只有一行。

.agents/notes/proposed/process/2026-06-20-discover-package-inventory.i18n.yaml

@@ -2,5 +2,5 @@
 # side as of the last confirmed-consistent state. Both languages carry equal authority;
 # after editing either side, bring the other along and re-record with:
 #   pnpm run verify-translation-pairing --write .agents/notes/proposed/process/2026-06-20-discover-package-inventory.md
-2026-06-20-discover-package-inventory.md: 7de865e43f87f0e41fad43b3786b9825509e9d50
-2026-06-20-discover-package-inventory.zh.md: fed3d9dd8740b2dc22434f8af7e1e8c025502f61
+2026-06-20-discover-package-inventory.md: 90ad595312431b942f3aac562e4ce8843fb6cc83
+2026-06-20-discover-package-inventory.zh.md: 4c5312f17ddeab1d6457a1a904f921f44e7d0b9d

.agents/notes/proposed/process/2026-06-20-discover-package-inventory.md

@@ -8,7 +8,7 @@ English | [中文](2026-06-20-discover-package-inventory.zh.md)
 
 Package and gate inventories are repeated across TypeScript project references, package docs, CI prose, and Knip overrides. Most restate package layout, manifest data, or aggregate command contents. Each new package therefore creates avoidable synchronization points.
 
-The [package hierarchy](../../archived/architecture/2026-06-20-package-hierarchy.md) already removed several of these by hand: `scripts/publint-all.ts` now derives its list from the `packages/<group>/<pkg>` layout, and the two `tsconfig` `paths` maps collapsed to one `@deepseek-ai/dsh-*` wildcard. What remains is the inventory that cannot be globbed away — chiefly the aggregate configs' (`tsconfig.host.json`, `tsconfig.client.json`) project `references`, which TypeScript requires as explicit arrays (no wildcard form).
+The [package hierarchy](../../archived/architecture/2026-06-20-package-hierarchy.md) already removed several of these by hand: `scripts/publint-all.ts` now derives its list from the `packages/<group>/<pkg>` layout, and the two `tsconfig` `paths` maps collapsed to one `@deepseek-ai/dsh-*` wildcard — since reverted to one explicit alias per package, generated and gated, because resolving a wildcard's candidates in order dominated source-launch boot ([explicit workspace path aliases](../../implemented/process/2026-08-27-explicit-workspace-path-aliases.md)). What remains is the inventory that cannot be globbed away — chiefly the aggregate configs' (`tsconfig.host.json`, `tsconfig.client.json`) project `references`, which TypeScript requires as explicit arrays (no wildcard form).
 
 Static lists are appropriate when they encode policy; they are needless friction when they duplicate manifest data or layout facts that already exist in `package.json`, workspace globs, or the package hierarchy.
 

.agents/notes/proposed/process/2026-06-20-discover-package-inventory.zh.md

@@ -8,7 +8,7 @@ Status: proposed
 
 包与门禁清单在 TypeScript project references、包文档、CI 描述和 Knip 覆盖项中反复出现。大多数只是重述包布局、manifest（元数据清单）数据或聚合命令内容。因此每新增一个包都会产生本可避免的同步点。
 
-[包层级结构](../../archived/architecture/2026-06-20-package-hierarchy.md)已经手动消除了其中若干：`scripts/publint-all.ts` 现在从 `packages/<group>/<pkg>` 布局推导列表，两份 `tsconfig` 的 `paths` 映射也合并为一个 `@deepseek-ai/dsh-*` 通配符。剩下的是无法用 glob 消除的清单，主要是聚合配置（`tsconfig.host.json`、`tsconfig.client.json`）中的项目引用（`references`）——TypeScript 要求它们是显式数组（没有通配符形式）。
+[包层级结构](../../archived/architecture/2026-06-20-package-hierarchy.md)已经手动消除了其中若干：`scripts/publint-all.ts` 现在从 `packages/<group>/<pkg>` 布局推导列表，两份 `tsconfig` 的 `paths` 映射也合并为一个 `@deepseek-ai/dsh-*` 通配符——该合并此后已被回退为「每包一条、由生成器托管并有门禁把关」的显式别名，因为按顺序试候选的解析开销主导了源码启动时间（[显式 workspace 路径别名](../../implemented/process/2026-08-27-explicit-workspace-path-aliases.zh.md)）。剩下的是无法用 glob 消除的清单，主要是聚合配置（`tsconfig.host.json`、`tsconfig.client.json`）中的项目引用（`references`）——TypeScript 要求它们是显式数组（没有通配符形式）。
 
 当静态列表编码的是策略时，它们是合理的；当它们只是重复 `package.json`、workspace glob 或包层级结构中已有的 manifest 数据或布局事实时，就是不必要的摩擦。
 

docs/subsystems/client-modules.i18n.yaml

@@ -2,5 +2,5 @@
 # side as of the last confirmed-consistent state. Both languages carry equal authority;
 # after editing either side, bring the other along and re-record with:
 #   pnpm run verify-translation-pairing --write docs/subsystems/client-modules.md
-client-modules.md: 6188880fcd682c7c3c105764f212e92395444b61
-client-modules.zh.md: a732758492e1dbc9cbaef8d3effbd3310e4f10a1
+client-modules.md: f58cb6592a009292ffc4f87a207fe4e103fd2365
+client-modules.zh.md: 18c72dfba6f851776100a9b6200e7222d580db7c

docs/subsystems/client-modules.md

@@ -74,11 +74,11 @@ Each initial row's `rev` is an opaque process nonce plus sequence, so graph comp
 
 ## The scan
 
-A package joins the table by declaring `dsh.client` (`platform: 'web'`, optional `inject` edges, optional `immediately`) in its package.json and exporting its built bundle at `exports["./client"]`. Package resolution anchors at the config tree's `ctx.baseUrl` — the cordis.yml directory, whose package declares every composed plugin as a dependency — and construction throws when that anchor is unset.
+A package joins the table by declaring `dsh.client` (`platform: 'web'`, optional `inject` edges, optional `immediately`) in its package.json and exporting its built bundle at `exports["./client"]`. Each live row resolves from its own Loader specifier and owning-tree `baseUrl`, through the same `loader.internal.resolveSync` implementation that imports its Host face when available. The nearest owning package manifest supplies the browser module id, so relative source and built overlays retain the package identity. Distinct active Loader sources resolving to one package name fail composition; after one source unloads, the surviving source supplies the row without a fiber restart.
 
 Scanning is incremental per package; there is no full-rescan code path. Every cordis `internal/plugin` emission (fiber construction or disposal) marks the fiber's entry name dirty, and a microtask flush reconciles each dirty name against the live loader entries. The activation pass seeds the same dirty set with all current entries and flushes synchronously, so first scan and steady state share one implementation — with opposite failure postures. At activation, a malformed declaration or missing bundle among the already-loaded entries aggregates into one loud `AggregateError` listing every broken package: the fiber FAILS and the boot's fail-loud sweep reports it. In steady state, a broken package logs a warning and must not poison the others.
 
-Package metadata — including the negative "not a client package" verdict — is cached per name and never expires: plugin-set changes take effect on restart. A fiber restart reuses its row and rev untouched; bundle content changes reach the graph only through `rebuilt()`.
+Package metadata — including the negative "not a client package" verdict — is cached per Loader specifier and owning-tree base URL until restart. A fiber restart from the same source reuses its row and rev untouched; bundle content changes reach the graph only through `rebuilt()`.
 
 ## The bundle route and index injection
 

docs/subsystems/client-modules.zh.md

@@ -74,11 +74,11 @@ interface WebBootGraph {
 
 ## 扫描
 
-包加入这张表的方式，是在自己的 package.json 中声明 `dsh.client`（`platform: 'web'`、可选的 `inject` 边、可选的 `immediately`），并在 `exports["./client"]` 导出构建好的 bundle。包解析锚定在配置树的 `ctx.baseUrl`——即 cordis.yml 所在目录，该目录的包把每个被组合的插件声明为依赖——这一锚点未设置时，构造即抛错。
+包加入这张表的方式，是在自己的 package.json 中声明 `dsh.client`（`platform: 'web'`、可选的 `inject` 边、可选的 `immediately`），并在 `exports["./client"]` 导出构建好的 bundle。每个 live row 都从自己的 Loader specifier 与所属 tree `baseUrl` 解析；若 `loader.internal.resolveSync` 可用，则使用 Host face import 所用的同一个实现。最近归属的 package manifest 提供浏览器模块 id，因此相对 source 与 built overlay 仍保留包身份。若不同的 active Loader source 解析到同一包名，组合会失败；一个来源卸载后，仍存活的来源无需重启 fiber 即可提供该 row。
 
 扫描是单包增量的；不存在全量重扫代码路径。fiber 构造或 dispose（资源释放）时的每次 cordis `internal/plugin` 发射都把该 fiber 的 entry 名标脏，一次微任务 flush 把每个脏名与实时 loader entry 对账。激活趟以全部当前 entry 灌入同一个脏集合并同步 flush，因此初扫与稳态共享一条实现——但失败姿态相反。激活时，已加载 entry 中的畸形声明或缺失 bundle 会聚合为一个大声的 `AggregateError`，列出每个损坏的包：该 fiber 进入 FAILED，由启动的大声失败 sweep 上报。稳态下，损坏的包只记录一条警告，且不得殃及其他包。
 
-包元数据——包括「非 client 包」这一否定结论——按名缓存且永不过期：插件集合的变更在重启后生效。fiber 重启原样复用其行与 rev；bundle 内容变更只经 `rebuilt()` 到达图。
+包元数据——包括「非 client 包」这一否定结论——按 Loader specifier 与所属 tree base URL 缓存至重启。同一来源的 fiber 重启会原样复用其 row 与 rev；bundle 内容变更只经 `rebuilt()` 到达图。
 
 ## bundle 路由与 index 注入
 

package.json

@@ -112,6 +112,8 @@
     "rescope-vendor": "tsx scripts/rescope-vendor.ts",
     "rescope-vendor:check": "tsx scripts/rescope-vendor.ts --check",
     "verify-client-domain-graph": "tsx scripts/verify-client-domain-graph.ts",
+    "gen-tsconfig-paths": "tsx scripts/gen-tsconfig-paths.ts",
+    "verify-tsconfig-paths": "tsx scripts/gen-tsconfig-paths.ts --check",
     "gen-cordis-catalog": "tsx scripts/gen-cordis-catalog.ts",
     "verify-cordis-catalog": "tsx scripts/gen-cordis-catalog.ts --check",
     "gen-cordis-api": "tsx scripts/gen-cordis-api.ts",
@@ -147,7 +149,7 @@
     "release:publish": "tsx scripts/release/publish.ts",
     "dsh": "node --import tsx/esm apps/cli/src/bin.ts",
     "demo:code-mode": "node scripts/demo-code-mode.mjs",
-    "demo:inspector": "node --import tsx/esm apps/cli/src/bin.ts web --patch ./packages/experimental/inspector/cordis.patch.yml",
+    "demo:inspector": "node --import tsx/esm apps/cli/src/bin.ts web --patch ./packages/experimental/inspector/cordis.source.patch.yml",
     "mock:llm": "node --import tsx packages/test-support/llm-mock-server/src/bin.ts",
     "dev:web": "tsx scripts/dev-web.ts --poll",
     "postinstall": "node scripts/install-lefthook.mjs"

packages/client/modules/README.i18n.yaml

@@ -2,5 +2,5 @@
 # side as of the last confirmed-consistent state. Both languages carry equal authority;
 # after editing either side, bring the other along and re-record with:
 #   pnpm run verify-translation-pairing --write packages/client/modules/README.md
-README.md: 4c81da74e5efbbbcdb35147431fc03252d51c94a
-README.zh.md: 3e476c57606e64a4837ca97f4298faf124849e4c
+README.md: 414d34af202ee4ab24e1b7570697ad63bd8cdbc8
+README.zh.md: e6adc7b7d0265e52d5108e241a8f8a551976536d

packages/client/modules/README.md

@@ -63,7 +63,7 @@ Executing a plugin bundle only registers its factory; every module-body side eff
 
 ### Incremental composition
 
-The node half scans incrementally per package — no full-rescan path. Every `internal/plugin` emission marks the fiber's entry name dirty; a microtask flush reconciles each dirty name against the live loader entries, and the activation pass seeds the same dirty set and flushes synchronously, so first scan and steady state share one implementation. Package metadata is cached per name and never expires; bundle content changes reach the graph only through `rebuilt()` (the HMR hook).
+The node half scans incrementally per package — no full-rescan path. Every `internal/plugin` emission marks the fiber's entry name dirty; a microtask flush reconciles each dirty name against the live loader entries, and the activation pass seeds the same dirty set and flushes synchronously, so first scan and steady state share one implementation. Package metadata is cached per Loader specifier and owning-tree base URL until restart, while the resolved manifest package name identifies the browser module. Distinct active Loader sources resolving to one package name are rejected; removing the conflict promotes the remaining source without requiring its fiber to restart. Bundle content changes reach the graph only through `rebuilt()` (the HMR hook).
 
 The node half snapshots each client bundle and available source map before publication. It groups resources into `/plugins/??...&rev=...` combo URLs, with one bootstrap combo for the modules row and one or more application combos for the other rows; each phase is partitioned before a URL exceeds 3 KiB. Every combo map is Indexed Source Map v3 and uses an authored section when available or an identity section for the packaged bundle. Initial per-plugin revisions use process nonces, so startup does not hash every plugin; HMR hashes only an artifact reported as changed. Advertised responses are immutable, and an unknown combination or revision returns 404.
 

packages/client/modules/README.zh.md

@@ -63,7 +63,7 @@ application combo 脚本在启动时注册插件 factory；模块主体仍保持
 
 ### 增量组合
 
-node 半侧逐包增量扫描——没有全量重扫路径。每次 `internal/plugin` 发出都会把该 fiber 的 entry 名标脏；一个微任务 flush 会把每个脏名与当前 loader 条目对账，激活 pass 播种同一脏集合并同步 flush，因此首次扫描与稳态共用同一实现。包元数据按名缓存且永不过期；bundle 内容变更只能通过 `rebuilt()`（HMR 钩子）进入图。
+node 半侧逐包增量扫描——没有全量重扫路径。每次 `internal/plugin` 发出都会把该 fiber 的 entry 名标脏；一个微任务 flush 会把每个脏名与当前 loader 条目对账，激活 pass 播种同一脏集合并同步 flush，因此首次扫描与稳态共用同一实现。包元数据按 Loader specifier 与所属 tree base URL 缓存至重启，解析出的 manifest 包名作为浏览器模块身份。若不同的 active Loader source 解析到同一包名，组合会失败；移除冲突来源后，剩余来源无需重启 fiber 即可接替。bundle 内容变更只能通过 `rebuilt()`（HMR 钩子）进入图。
 
 node 半侧会在发布前快照每个客户端 bundle 及其现有 source map。它把资源分组到 `/plugins/??...&rev=...` combo URL：modules row 使用一个 bootstrap combo，其余 row 使用一个或多个 application combo；每个阶段都会在 URL 超过 3 KiB 之前分区。每个 combo map 都是 Indexed Source Map v3，并在可用时使用作者提供的 section，否则为已打包 bundle 生成 identity section。初始逐插件 revision 使用进程 nonce，所以启动时不哈希每个插件；HMR 只哈希被报告为已变化的产物。已公告响应不可变；未知组合或 revision 返回 404。
 

packages/client/modules/src/index.ts

@@ -15,21 +15,23 @@
  * against the live loader entries. The activation pass seeds the same dirty
  * set with all current entries and flushes synchronously, so first scan and
  * steady state share one implementation. Package metadata (including the
- * negative "not a client package" verdict) is cached per name and never
- * expires — plugin-set changes take effect on restart; bundle content
- * changes reach the graph only through
+ * negative "not a client package" verdict) is cached per Loader specifier and
+ * owning-tree base URL until restart. The manifest package name identifies
+ * the browser module; distinct active Loader sources for that package are a
+ * composition error. Bundle content changes reach the graph only through
  * {@link ClientModuleRegistry.rebuilt}.
  * @module @deepseek-ai/dsh-client-modules
  */
 
 import { createHash, randomBytes } from 'node:crypto'
-import { readFileSync, statSync } from 'node:fs'
+import { existsSync, readFileSync, statSync } from 'node:fs'
 import type { IncomingMessage, ServerResponse } from 'node:http'
 import { createRequire } from 'node:module'
-import { dirname, join } from 'node:path'
+import { dirname, isAbsolute, join } from 'node:path'
+import { fileURLToPath, pathToFileURL } from 'node:url'
 import { Service } from '@deepseek-ai/cordis'
 import type { Context } from '@deepseek-ai/cordis'
-import type {} from '@deepseek-ai/cordis-plugin-loader'
+import type { Entry } from '@deepseek-ai/cordis-plugin-loader'
 import type { IndexInjection } from '@deepseek-ai/dsh-host-webserver'
 import { optionalStringArray, stripClientSuffix } from './client/manifest.ts'
 import type { WebBootBatch, WebBootBatchPhase, WebBootEntry, WebBootGraph } from './client/manifest.ts'
@@ -80,11 +82,26 @@ export interface ClientArtifactBaseline {
   readonly size: number
 }
 
-/** Resolved package metadata for one `dsh.client` package (cached per name, never expires). */
+/** Resolved metadata cached for one Loader specifier and owning-tree base URL until restart. */
 interface PkgMeta extends WebBootRowFields {
   clientPath: string
 }
 
+interface ResolvedPkgMeta {
+  packageName: string
+  meta: PkgMeta
+}
+
+/** One active Loader source and the browser package manifest it resolves to. */
+interface ClientPackageSource extends ResolvedPkgMeta {
+  /** Loader specifier from the active row. */
+  loaderName: string
+  /** Resolution base of the config tree that owns the row. */
+  baseUrl: string
+  /** Stable cache and contribution key for this source. */
+  sourceKey: string
+}
+
 /** Recovery instruction shared by grouped startup and steady-state bundle diagnostics. */
 const CLIENT_BUNDLE_BUILD_INSTRUCTION = 'run `pnpm run build` before launch'
 
@@ -129,6 +146,10 @@ class ClientPackageCompositionError extends AggregateError {
 /** One composed table row: the wire entry plus the resolved package metadata behind it. */
 interface WebPluginRecord {
   entry: WebBootEntry
+  /** Loader specifier whose active row contributes this browser module. */
+  loaderName: string
+  /** Loader resolution input that selected this package instance. */
+  sourceKey: string
   meta: PkgMeta
   /** Exact build artifact included in the startup batches. */
   bundle: Buffer
@@ -167,6 +188,15 @@ const SOURCE_MAP_TRAILER = /(?:\r?\n)?\/\/# sourceMappingURL=[^\r\n]*(?:\r?\n)?$
 /** Debugger source name appended to page bundles in the WebWorker image. */
 const SOURCE_URL_TRAILER = /(?:\r?\n)?\/\/# sourceURL=([^\r\n]+)(?:\r?\n)?$/
 
+/** Return a bare package-root specifier, excluding package subpaths and path-like entries. */
+function exactPackageSpecifier(specifier: string): string | undefined {
+  if (specifier.startsWith('@')) {
+    const parts = specifier.split('/')
+    return parts.length === 2 && parts.every(Boolean) ? specifier : undefined
+  }
+  return specifier.length > 0 && !specifier.includes('/') ? specifier : undefined
+}
+
 /** Narrow an unknown parsed JSON value to the `dsh.client` declaration, throwing on malformed fields. */
 function parseDshClient(pkgName: string, value: unknown): DshClientDeclaration | undefined {
   if (value === undefined) return undefined
@@ -504,14 +534,13 @@ export class ClientModuleRegistry extends Service {
   static inject = ['webServer', 'loader']
 
   private readonly table = new Map<string, WebPluginRecord>()
-  // Negative verdicts (unresolvable specifier — builtins like cordis:include,
-  // subpath rows — or a package without a web `dsh.client` declaration) are
-  // cached as null and never expire: plugin-set changes take effect on restart.
-  private readonly pkgMeta = new Map<string, PkgMeta | null>()
+  private readonly sources = new Map<string, ClientPackageSource>()
+  // Resolution is entry-local: the same specifier can resolve differently in
+  // separate config trees. Negative verdicts remain stable until restart.
+  private readonly pkgMeta = new Map<string, ResolvedPkgMeta | null>()
   private readonly rebuildListeners = new Set<(id: string, rev: string) => void>()
   private readonly graphListeners = new Set<() => void>()
   private readonly dirty = new Set<string>()
-  private readonly resolvePkgJson: (spec: string) => string
   private readonly initialRevisionNonce = randomBytes(8).toString('hex')
   private nextInitialRevision = 0
   private responses = new Map<string, { body: Buffer; contentType: string }>()
@@ -527,16 +556,6 @@ export class ClientModuleRegistry extends Service {
    */
   constructor(ctx: Context) {
     super(ctx, 'clientModules')
-    // Resolution anchor: the config tree's baseUrl (the cordis.yml directory,
-    // whose package declares every composed plugin as a dependency). The
-    // modules package's own URL would miss sibling packages under pnpm's
-    // isolated node_modules.
-    if (ctx.baseUrl === undefined) {
-      throw new Error('client-modules: ctx.baseUrl is unset — the node half needs the config-tree anchor to resolve plugin packages')
-    }
-    const require = createRequire(ctx.baseUrl)
-    this.resolvePkgJson = spec => require.resolve(`${spec}/package.json`)
-
     // Subscribe before seeding so a fiber arriving mid-activation lands in the
     // same dirty set (Set idempotence makes the overlap harmless). An entry-less
     // fiber is a child plugin or a manual mount — never a loader row; O(1) drop.
@@ -716,31 +735,31 @@ export class ClientModuleRegistry extends Service {
     }
   }
 
-  private resolveMeta(pkgName: string): PkgMeta | null {
-    const cached = this.pkgMeta.get(pkgName)
+  private resolveMeta(loaderName: string, baseUrl: string): ResolvedPkgMeta | null {
+    const sourceKey = this.sourceKey(loaderName, baseUrl)
+    const cached = this.pkgMeta.get(sourceKey)
     if (cached !== undefined) return cached
-    let pkgPath: string
-    try {
-      pkgPath = this.resolvePkgJson(pkgName)
-    } catch {
+    const located = this.locatePkgJson(loaderName, baseUrl)
+    if (located === undefined) {
       // Not a resolvable package root: loader builtins (cordis:include) and
       // subpath entries (…/gateway) land here — permanently not a client row.
-      this.pkgMeta.set(pkgName, null)
+      this.pkgMeta.set(sourceKey, null)
       return null
     }
+    const { packageName, path: pkgPath } = located
     const pkg = JSON.parse(readFileSync(pkgPath, 'utf8')) as Record<string, unknown>
     const dsh = pkg.dsh
     const decl = parseDshClient(
-      pkgName,
+      packageName,
       dsh !== null && typeof dsh === 'object' ? (dsh as Record<string, unknown>).client : undefined,
     )
     if (decl === undefined || decl.platform !== 'web') {
-      this.pkgMeta.set(pkgName, null)
+      this.pkgMeta.set(sourceKey, null)
       return null
     }
-    const clientRel = clientExportOf(pkgName, pkg.exports)
+    const clientRel = clientExportOf(packageName, pkg.exports)
     if (clientRel === undefined) {
-      throw new Error(`client-modules: ${pkgName} declares dsh.client but exports no "./client" bundle`)
+      throw new Error(`client-modules: ${packageName} declares dsh.client but exports no "./client" bundle`)
     }
     const meta: PkgMeta = {
       clientPath: join(dirname(pkgPath), clientRel),
@@ -748,8 +767,87 @@ export class ClientModuleRegistry extends Service {
       external: decl.external ?? [],
       immediately: decl.immediately === true,
     }
-    this.pkgMeta.set(pkgName, meta)
-    return meta
+    const resolved = { packageName, meta }
+    this.pkgMeta.set(sourceKey, resolved)
+    return resolved
+  }
+
+  /**
+   * Locate the manifest of the package the Loader mounts for a row. The row's
+   * module location is authoritative: the specifier resolves through the same
+   * Loader resolution that imported the row's host half — including any
+   * active ESM hooks — and the nearest ancestor manifest declaring the name
+   * owns the module. Tree-anchored `require` resolution remains only for
+   * runtimes without Node internals.
+   * @param loaderName - module specifier of the loader row.
+   * @param baseUrl - resolution base of the tree that owns the row.
+   * @returns the manifest path, or `undefined` when the name resolves to no package root.
+   */
+  private locatePkgJson(loaderName: string, baseUrl: string): { path: string; packageName: string } | undefined {
+    if (loaderName.startsWith('cordis:')) return undefined
+    const pathLike = loaderName.startsWith('.') || loaderName.startsWith('file:') || isAbsolute(loaderName)
+    const expectedPackageName = pathLike ? undefined : exactPackageSpecifier(loaderName)
+    if (!pathLike && expectedPackageName === undefined) return undefined
+    const internal = this.ctx.loader.internal
+    if (internal === undefined || typeof Reflect.get(internal, 'resolveSync') !== 'function') {
+      if (expectedPackageName === undefined) {
+        const moduleUrl = loaderName.startsWith('file:')
+          ? loaderName
+          : isAbsolute(loaderName) ? pathToFileURL(loaderName).href : new URL(loaderName, baseUrl).href
+        return this.nearestPackage(moduleUrl)
+      }
+      try {
+        return {
+          path: createRequire(baseUrl).resolve(`${expectedPackageName}/package.json`),
+          packageName: expectedPackageName,
+        }
+      } catch {
+        // Without Node internals the owning tree is the only resolver; an
+        // unresolvable name is classified exactly as below.
+        return undefined
+      }
+    }
+    let moduleUrl: string
+    try {
+      moduleUrl = internal.version === 'v2'
+        ? internal.resolveSync(baseUrl, { specifier: loaderName, attributes: {} }).url
+        : internal.resolveSync(loaderName, baseUrl, {}).url
+    } catch {
+      // The Loader cannot resolve the name: its row cannot have imported, so
+      // the name is permanently not a client row.
+      return undefined
+    }
+    return this.nearestPackage(moduleUrl, expectedPackageName)
+  }
+
+  private nearestPackage(
+    moduleUrl: string,
+    expectedPackageName?: string,
+  ): { path: string; packageName: string } | undefined {
+    if (!moduleUrl.startsWith('file:')) return undefined
+    let dir = dirname(fileURLToPath(moduleUrl))
+    while (true) {
+      const candidate = join(dir, 'package.json')
+      if (existsSync(candidate)) {
+        try {
+          const name = (JSON.parse(readFileSync(candidate, 'utf8')) as { name?: unknown }).name
+          if (typeof name === 'string' && (expectedPackageName === undefined || name === expectedPackageName)) {
+            return { path: candidate, packageName: name }
+          }
+        } catch {
+          // An unreadable or malformed intermediate manifest cannot own the
+          // module; keep walking toward the declaring package root.
+        }
+      }
+      const parent = dirname(dir)
+      if (parent === dir) break
+      dir = parent
+    }
+    return undefined
+  }
+
+  private sourceKey(loaderName: string, baseUrl: string): string {
+    return `${baseUrl}\0${loaderName}`
   }
 
   /** Capture the bundle stats before reading its bytes. */
@@ -800,26 +898,72 @@ export class ClientModuleRegistry extends Service {
     }
   }
 
-  /** Reconcile one entry name against the live loader entries. @returns whether the table changed. */
-  private processOne(entryName: string): boolean {
-    let qualifies = false
+  /** Reconcile one entry name against the live Loader sources. @returns whether the table changed. */
+  private processOne(entryName: string, onError: (err: Error) => void): boolean {
+    const nextSources = new Map<string, ClientPackageSource>()
     for (const entry of this.ctx.loader.entries()) {
-      if (entry.options.name === entryName && entry.fiber !== undefined && !entry.disabled) {
-        qualifies = true
-        break
+      if (entry.options.name !== entryName || entry.fiber === undefined || entry.disabled) continue
+      const source = this.resolveSource(entry)
+      if (source !== undefined) nextSources.set(source.sourceKey, source)
+    }
+
+    const affectedPackages = new Set<string>()
+    for (const [sourceKey, source] of this.sources) {
+      if (source.loaderName !== entryName) continue
+      affectedPackages.add(source.packageName)
+      if (!nextSources.has(sourceKey)) this.sources.delete(sourceKey)
+    }
+    for (const [sourceKey, source] of nextSources) {
+      affectedPackages.add(source.packageName)
+      this.sources.set(sourceKey, source)
+    }
+    let changed = false
+    for (const packageName of affectedPackages) {
+      try {
+        if (this.reconcilePackage(packageName)) changed = true
+      } catch (error) {
+        onError(error instanceof Error ? error : new Error(String(error)))
       }
     }
-    if (!qualifies) return this.table.delete(entryName)
-    if (this.table.has(entryName)) return false
-    const meta = this.resolveMeta(entryName)
-    if (meta === null) return false
+    return changed
+  }
+
+  private resolveSource(entry: Entry): ClientPackageSource | undefined {
+    const loaderName = entry.options.name
+    const baseUrl = entry.parent.tree.ctx.baseUrl
+    if (baseUrl === undefined) {
+      throw new Error(`client-modules: loader entry ${loaderName} has no resolution base URL`)
+    }
+    const resolved = this.resolveMeta(loaderName, baseUrl)
+    if (resolved === null) return undefined
+    return { ...resolved, loaderName, baseUrl, sourceKey: this.sourceKey(loaderName, baseUrl) }
+  }
+
+  private reconcilePackage(packageName: string): boolean {
+    const sources: ClientPackageSource[] = []
+    for (const source of this.sources.values()) {
+      if (source.packageName === packageName) sources.push(source)
+    }
+    if (sources.length > 1) {
+      const locations = sources
+        .map(source => `${JSON.stringify(source.loaderName)} from ${source.baseUrl}`)
+        .join(', ')
+      throw new Error(
+        `client-modules: package ${packageName} resolves from multiple active Loader sources: ${locations}; remove one entry`,
+      )
+    }
+    const source = sources[0]
+    if (source === undefined) return this.table.delete(packageName)
+    if (this.table.get(packageName)?.sourceKey === source.sourceKey) return false
     // The opaque initial rev rides the row until HMR observes a file change;
-    // a fiber restart reuses the existing row without inspecting bytes.
-    const snapshot = this.initialBundleSnapshot(entryName, meta.clientPath)
+    // a fiber restart from the same source reuses the existing row.
+    const snapshot = this.initialBundleSnapshot(packageName, source.meta.clientPath)
     const rev = this.allocateInitialRevision()
-    this.table.set(entryName, {
-      entry: graphRow(entryName, rev, meta),
-      meta,
+    this.table.set(packageName, {
+      entry: graphRow(packageName, rev, source.meta),
+      loaderName: source.loaderName,
+      sourceKey: source.sourceKey,
+      meta: source.meta,
       bundle: snapshot.bundle,
       baseline: snapshot.baseline,
       ...(snapshot.sourceMap === undefined ? {} : { sourceMap: snapshot.sourceMap }),
@@ -832,7 +976,7 @@ export class ClientModuleRegistry extends Service {
     for (const entryName of [...this.dirty]) {
       this.dirty.delete(entryName)
       try {
-        if (this.processOne(entryName)) changed = true
+        if (this.processOne(entryName, onError)) changed = true
       } catch (error) {
         // Steady state: one broken package must not poison the others; the
         // activation pass aggregates these into a loud throw instead.

packages/client/modules/tests/node-half.client.spec.ts

@@ -7,8 +7,8 @@ import { tmpdir } from 'node:os'
 import { dirname, join } from 'node:path'
 import { pathToFileURL } from 'node:url'
 import { runInNewContext } from 'node:vm'
-import { Context } from '@deepseek-ai/cordis'
-import { afterEach, describe, expect, it } from 'vitest'
+import { Context, type Fiber } from '@deepseek-ai/cordis'
+import { afterEach, describe, expect, it, vi } from 'vitest'
 import { renderIndexInjections, type WebServer, type WebRoute } from '@deepseek-ai/dsh-host-webserver'
 import * as modulesClient from '../src/client/index.ts'
 import { ClientModuleRegistry, bootInjections, orderByModuleGraph } from '../src/index.ts'
@@ -58,13 +58,26 @@ function writeBuiltPackage(packageName: string, client: Record<string, unknown>)
 }
 
 /** Construct the node-half service and capture its plugin-bundle route. */
-function constructWithRoute(packageNames: string[]): { service: ClientModuleRegistry; route: WebRoute } {
+function constructWithRoute(
+  packageNames: string[],
+  options: {
+    contextBaseUrl?: string
+    entryBaseUrl?: string
+    internal?: NonNullable<Context['loader']['internal']>
+  } = {},
+): { context: Context; service: ClientModuleRegistry; route: WebRoute } {
   const ctx = new Context()
-  ctx.baseUrl = pathToFileURL(root!).href + '/'
+  ctx.baseUrl = options.contextBaseUrl ?? pathToFileURL(root!).href + '/'
   ctx.provide('loader', {
+    internal: options.internal,
     *entries() {
       for (const packageName of packageNames) {
-        yield { options: { name: packageName }, fiber: {}, disabled: false }
+        yield {
+          options: { name: packageName },
+          fiber: {},
+          disabled: false,
+          parent: { tree: { ctx: { baseUrl: options.entryBaseUrl ?? ctx.baseUrl } } },
+        }
       }
     },
   })
@@ -80,7 +93,7 @@ function constructWithRoute(packageNames: string[]): { service: ClientModuleRegi
   ctx.provide('webServer', webServer as WebServer)
   const service = new ClientModuleRegistry(ctx)
   if (route === undefined) throw new Error('client bundle route was not registered')
-  return { service, route }
+  return { context: ctx, service, route }
 }
 
 /** Construct the node-half service over the enabled fixture entries. */
@@ -227,6 +240,171 @@ describe('HTML bootstrap facade', () => {
 })
 
 describe('client bundle activation', () => {
+  it.each(['v1', 'v2'] as const)(
+    'resolves %s package metadata from the owning entry tree',
+    (version) => {
+      const packageName = `@fixture/entry-base-${version}`
+      const clientPath = writePackage(packageName)
+      const hostPath = join(dirname(clientPath), 'index.js')
+      mkdirSync(dirname(hostPath), { recursive: true })
+      writeFileSync(hostPath, 'export default {}\n')
+      writeFileSync(clientPath, 'module.exports = {}\n')
+      const contextBaseUrl = pathToFileURL(join(root!, 'profile')).href + '/'
+      const entryBaseUrl = pathToFileURL(join(root!, 'overlay')).href + '/'
+      const calls: unknown[][] = []
+      const resolveSync = (...args: unknown[]) => {
+        calls.push(args)
+        return { format: 'module' as const, url: pathToFileURL(hostPath).href }
+      }
+      const internal = { version, resolveSync }
+
+      const { service } = constructWithRoute([packageName], {
+        contextBaseUrl,
+        entryBaseUrl,
+        internal: internal as NonNullable<Context['loader']['internal']>,
+      })
+
+      expect(calls).toEqual(version === 'v2'
+        ? [[entryBaseUrl, { specifier: packageName, attributes: {} }]]
+        : [[packageName, entryBaseUrl, {}]])
+      expect(service.clientPath(packageName)).toBe(clientPath)
+      expect(service.graph().entries.map(entry => entry.id)).toEqual([packageName])
+    },
+  )
+
+  it('derives the browser module id from a file entry owning manifest', () => {
+    const packageName = '@fixture/file-entry'
+    const clientPath = writePackage(packageName)
+    const hostPath = join(dirname(clientPath), 'index.js')
+    mkdirSync(dirname(hostPath), { recursive: true })
+    writeFileSync(hostPath, 'export default {}\n')
+    writeFileSync(clientPath, 'module.exports = {}\n')
+
+    const service = construct([pathToFileURL(hostPath).href])
+
+    expect(service.clientPath(packageName)).toBe(clientPath)
+    expect(service.graph().entries.map(entry => entry.id)).toEqual([packageName])
+  })
+
+  it.each(['relative', 'absolute'] as const)(
+    'finds the owning manifest through the %s-path fallback without Node loader internals',
+    (kind) => {
+      const packageName = `@fixture/${kind}-fallback-entry`
+      const clientPath = writePackage(packageName)
+      const packageRoot = dirname(dirname(clientPath))
+      const hostPath = join(packageRoot, 'index.js')
+      mkdirSync(dirname(clientPath), { recursive: true })
+      writeFileSync(hostPath, 'export default {}\n')
+      writeFileSync(clientPath, 'module.exports = {}\n')
+      const loaderName = kind === 'relative' ? './index.js' : hostPath
+
+      const { service } = constructWithRoute([loaderName], {
+        entryBaseUrl: pathToFileURL(packageRoot).href + '/',
+      })
+
+      expect(service.clientPath(packageName)).toBe(clientPath)
+      expect(service.graph().entries.map(entry => entry.id)).toEqual([packageName])
+    },
+  )
+
+  it.each(['v1', 'v2', 'worker'] as const)(
+    'derives a file entry package id through the %s Loader resolver',
+    (version) => {
+      const packageName = `@fixture/file-entry-${version}`
+      const clientPath = writePackage(packageName)
+      const hostPath = join(dirname(clientPath), 'index.js')
+      mkdirSync(dirname(hostPath), { recursive: true })
+      writeFileSync(hostPath, 'export default {}\n')
+      writeFileSync(clientPath, 'module.exports = {}\n')
+      const loaderName = pathToFileURL(hostPath).href
+      const entryBaseUrl = pathToFileURL(join(root!, 'overlay')).href + '/'
+      const calls: unknown[][] = []
+      const resolveSync = (...args: unknown[]) => {
+        calls.push(args)
+        return { format: 'module' as const, url: loaderName }
+      }
+      const internal = { version, resolveSync }
+
+      const { service } = constructWithRoute([loaderName], {
+        entryBaseUrl,
+        internal: internal as NonNullable<Context['loader']['internal']>,
+      })
+
+      expect(calls).toEqual(version === 'v2'
+        ? [[entryBaseUrl, { specifier: loaderName, attributes: {} }]]
+        : [[loaderName, entryBaseUrl, {}]])
+      expect(service.graph().entries.map(entry => entry.id)).toEqual([packageName])
+    },
+  )
+
+  it('rejects distinct active Loader sources for one browser package', () => {
+    const packageName = '@fixture/duplicate-source'
+    const clientPath = writePackage(packageName)
+    const hostPath = join(dirname(clientPath), 'index.js')
+    mkdirSync(dirname(hostPath), { recursive: true })
+    writeFileSync(hostPath, 'export default {}\n')
+    writeFileSync(clientPath, 'module.exports = {}\n')
+    const alias = './duplicate-source.js'
+    const internal = {
+      version: 'v2' as const,
+      resolveSync: () => ({ format: 'module' as const, url: pathToFileURL(hostPath).href }),
+    }
+
+    expect(() => constructWithRoute([packageName, alias], {
+      internal: internal as unknown as NonNullable<Context['loader']['internal']>,
+    })).toThrow(
+      `client-modules: package ${packageName} resolves from multiple active Loader sources:`,
+    )
+  })
+
+  it('promotes the remaining Loader source after the selected alias unloads', async () => {
+    const packageName = '@fixture/duplicate-source-recovery'
+    const clientPath = writePackage(packageName)
+    const hostPath = join(dirname(clientPath), 'index.js')
+    mkdirSync(dirname(hostPath), { recursive: true })
+    writeFileSync(hostPath, 'export default {}\n')
+    writeFileSync(clientPath, 'module.exports = {}\n')
+    const alias = './duplicate-source-recovery.js'
+    const entries = [packageName]
+    const internal = {
+      version: 'v2' as const,
+      resolveSync: () => ({ format: 'module' as const, url: pathToFileURL(hostPath).href }),
+    }
+    const { context, service } = constructWithRoute(entries, {
+      internal: internal as unknown as NonNullable<Context['loader']['internal']>,
+    })
+    const firstRevision = service.graph().entries[0]!.rev
+    const warning = vi.spyOn(context.logger, 'warn').mockImplementation(() => undefined)
+
+    entries.push(alias)
+    emitLoaderEntryChange(context, alias)
+    await Promise.resolve()
+    expect(warning).toHaveBeenCalledWith(expect.objectContaining({
+      message: expect.stringContaining(`package ${packageName} resolves from multiple active Loader sources`) as string,
+    }))
+    expect(service.graph().entries[0]!.rev).toBe(firstRevision)
+
+    entries.splice(entries.indexOf(packageName), 1)
+    emitLoaderEntryChange(context, packageName)
+    await Promise.resolve()
+    expect(service.graph().entries.map(entry => entry.id)).toEqual([packageName])
+    expect(service.graph().entries[0]!.rev).not.toBe(firstRevision)
+    expect(service.clientPath(packageName)).toBe(clientPath)
+  })
+
+  it('uses owning-tree package resolution for an import-only Worker module loader', () => {
+    const packageName = '@fixture/worker-loader'
+    writeBuiltPackage(packageName, {})
+    const internal = {
+      version: 'worker',
+      import: async () => ({}),
+    } as unknown as NonNullable<Context['loader']['internal']>
+
+    const { service } = constructWithRoute([packageName], { internal })
+
+    expect(service.graph().entries.map(entry => entry.id)).toEqual([packageName])
+  })
+
   it('allows sibling dsh roles', () => {
     const currentName = '@fixture/current-client-field'
     const clientPath = writePackage(currentName, {
@@ -564,6 +742,12 @@ describe('client bundle activation', () => {
   })
 })
 
+function emitLoaderEntryChange(context: Context, name: string): void {
+  context.emit('internal/plugin', {
+    entry: { options: { name } },
+  } as unknown as Fiber)
+}
+
 describe('shared module declarations', () => {
   it('accepts external requests and carries them onto the graph row', () => {
     const packageName = '@fixture/shared-declared'

packages/experimental/inspector/README.i18n.yaml

@@ -2,5 +2,5 @@
 # side as of the last confirmed-consistent state. Both languages carry equal authority;
 # after editing either side, bring the other along and re-record with:
 #   pnpm run verify-translation-pairing --write packages/experimental/inspector/README.md
-README.md: e10a68eed10c0bc71d26b5eacf9ee3eac4c6818d
-README.zh.md: f6aceb5374730ff9879151980c60e54dad39fd89
+README.md: d6c519723a8b9eab31048fb71f13b17004a6af52
+README.zh.md: 0c2f58032a7c1f1a485f974da60c1d60e335eb51

packages/experimental/inspector/README.md

@@ -106,7 +106,7 @@ Node delivery is depth-limited per DevTools connection: `DOM.getDocument` serves
 
 Sources publish complete snapshots, while the Worker compares stable backend node identities before notifying DevTools. Unchanged snapshots emit no DOM event; additions, removals, and attribute changes use node-level CDP events, inserted-node payloads withhold their subtree, and sibling reordering replaces only that parent's children. Existing `NodeId` values and unaffected Elements expansion remain stable.
 
-When a Client disconnects, its Console execution context and live object ids are destroyed immediately. With disconnected-tree retention enabled, Elements keeps the last tree unchanged while connection state remains in the inspection model rather than becoming an unreviewed DOM attribute. Reconnection keeps the logical source id, creates a new synthetic CDP context id for the new transport generation, and replaces the stale tree after its complete snapshot arrives. The Worker retains at most `maxDisconnectedCordisTrees` such snapshots; zero removes them immediately.
+When a Client disconnects, its Console execution context and live object ids are destroyed immediately. With disconnected-tree retention enabled, Elements keeps the last tree unchanged while connection state remains in the inspection model rather than becoming an unreviewed DOM attribute. Reconnection keeps the logical source id, creates a new synthetic CDP context id for the new transport generation, and replaces the stale tree after its complete snapshot arrives. The Client retains its logical id in `sessionStorage` and claims it through Web Locks for the page lifetime, so refresh reuses the id while a duplicated live tab receives a new one. The Worker retains at most `maxDisconnectedCordisTrees` such snapshots; zero removes them immediately.
 
 <a id="host-fetch-capture"></a>
 ## Host fetch capture
@@ -138,6 +138,7 @@ None; this package neither assembles nor sends a provider request.
 - **Client active debugging is unsupported** — Console events, Runtime evaluation, RemoteObject access, and read-only `lib/client.js` Sources work. Client-script debugger requests return explicit unsupported errors; target-wide pause and resume control the Host only.
 - **Client Sources expose the Inspector bundle only** — other page scripts are not cataloged by this package.
 - **Client evaluation uses page JavaScript** — page Content Security Policy can block dynamic evaluation, and the synthetic context does not provide DevTools command-line helpers or native REPL declaration semantics.
+- **Client identity arbitration requires Web Locks** — browsers without that API retain reconnect and refresh identity through `sessionStorage`, but cannot distinguish two simultaneously live tabs copied from the same storage state.
 - **Fetch interception covers `globalThis.fetch`** — direct Undici APIs and fetch references retained before activation are not observed.
 - **Body cloning has cost** — full capture tees request and response streams up to the configured limits and can increase memory and I/O pressure. The retained-body limit does not include buffering inside the stream tee, including an oversized source chunk or data queued for a slower application reader.
 - **No automatic Worker restart** — an unexpected Worker exit fails the current Inspector instance; lifecycle recovery belongs to a later change.

packages/experimental/inspector/README.zh.md

@@ -106,7 +106,7 @@ Host 与 Client 发布同一种嵌套 `CordisTreeSnapshot` 类型。Context 与
 
 source 仍发布完整 snapshot，Worker 在通知 DevTools 前按稳定的 backend node identity 比较差异。无变化的 snapshot 不发送 DOM event；新增、移除和 attribute 变化使用节点级 CDP event，插入节点的载荷扣留其子树，兄弟节点重排只替换对应 parent 的 children。现有 `NodeId` 与未受影响的 Elements 展开状态保持稳定。
 
-Client 断联时，其 Console execution context 与 live object id 会立即销毁。启用断联树保留后，Elements 会原样保留最后一棵树；连接状态留在 inspection model 中，不会未经设计就成为 DOM attribute。重连会沿用逻辑 source id，为新的 transport generation 创建新的 synthetic CDP context id，并在完整 snapshot 到达后替换旧树。Worker 最多保留 `maxDisconnectedCordisTrees` 棵此类 snapshot；设为零会立即移除。
+Client 断联时，其 Console execution context 与 live object id 会立即销毁。启用断联树保留后，Elements 会原样保留最后一棵树；连接状态留在 inspection model 中，不会未经设计就成为 DOM attribute。重连会沿用逻辑 source id，为新的 transport generation 创建新的 synthetic CDP context id，并在完整 snapshot 到达后替换旧树。Client 把逻辑 id 保存在 `sessionStorage` 中，并通过 Web Locks 在页面存活期间独占该 id，因此刷新会复用 id，而复制出的另一个 live tab 会取得新 id。Worker 最多保留 `maxDisconnectedCordisTrees` 棵此类 snapshot；设为零会立即移除。
 
 <a id="host-fetch-capture"></a>
 ## Host fetch 采集
@@ -138,6 +138,7 @@ CDP target 通过 `Runtime.evaluate` 提供 Host 和已连接 Client realm 中
 - **Client active debugging 不受支持**——Console event、Runtime 求值、RemoteObject 访问和只读 `lib/client.js` Sources 可用。Client script debugger request 返回明确的 unsupported error；target-wide pause 与 resume 只控制 Host。
 - **Client Sources 只暴露 Inspector bundle**——本包不收录页面中的其他 script。
 - **Client 求值使用页面 JavaScript**——页面 Content Security Policy 可能阻止动态求值；synthetic context 不提供 DevTools command-line helper 或原生 REPL 声明语义。
+- **Client 身份仲裁依赖 Web Locks**——缺少该 API 的浏览器仍会通过 `sessionStorage` 保持重连与刷新身份，但无法区分从同一存储状态复制出的两个同时存活 tab。
 - **fetch 拦截范围是 `globalThis.fetch`**——直接调用 Undici API，以及激活前保存的 fetch 引用不会被观察。
 - **body clone 有运行成本**——完整采集会 tee 请求与响应 stream，直至达到配置上限，可能增加内存与 I/O 压力。保留 body 的上限不包含 stream tee 内部的缓冲，包括来源提供的超大 chunk，或为读取较慢的应用分支排队的数据。
 - **不自动重启 Worker**——Worker 意外退出会使当前 Inspector 实例失败；生命周期恢复留待后续改动。

packages/experimental/inspector/cordis.patch.yml

@@ -1,13 +1,8 @@
-# Development overlay for the experimental inspector: mount it per launch with
-#   pnpm run demo:inspector        (pnpm dsh web --patch ./packages/experimental/inspector/cordis.patch.yml)
-# A source launch resolves this workspace package through the tsconfig paths
-# facade and needs no installation. A built launch additionally needs the
-# package importable from the profile:
-#   dsh plugin --profile web add link:<absolute path to this package directory>
-# (`link:`, not `file:` — `file:` re-installs the workspace:^ dependencies
-# inside the profile and fails). The package is private and ships with no
-# published dsh installation; a missing package fails loud at entry import.
+# Built-artifact overlay for the experimental inspector:
+#   node apps/cli/lib/bin.js web --patch ./packages/experimental/inspector/cordis.patch.yml
+# The relative entry is anchored to this file, so the private package does not
+# need to be installed into the selected profile. Run `pnpm run build` first.
 
 - insert:
     - id: experimental-inspector
-      name: '@deepseek-ai/dsh-experimental-inspector'
+      name: './lib/index.js'

packages/experimental/inspector/cordis.source.patch.yml

@@ -0,0 +1,6 @@
+# Source overlay for `pnpm run demo:inspector`. The relative entry is anchored
+# to this file and runs through the CLI's tsx loader without a profile install.
+
+- insert:
+    - id: experimental-inspector
+      name: './src/index.ts'

packages/experimental/inspector/src/client/bridge/controller.ts

@@ -2,12 +2,20 @@
 
 import type { InspectorClientBootstrap } from '../../shared/bridge/messages/control.ts'
 import { ClientInspectorSource } from './transport.ts'
+import { ClientRealmSource } from '../inspection/realm.ts'
 
 /**
  * Start the browser source transport for one validated Host bootstrap.
  * @param bootstrap - Host-injected endpoint and resource limits.
- * @returns The active reconnecting Client source.
+ * @returns The active reconnecting Client source after its tab identity is claimed.
  */
-export function startInspectorClient(bootstrap: InspectorClientBootstrap): ClientInspectorSource {
-  return new ClientInspectorSource(bootstrap)
+export async function startInspectorClient(bootstrap: InspectorClientBootstrap): Promise<ClientInspectorSource> {
+  const label = document.title || 'Client'
+  const realmSource = await ClientRealmSource.claim(label)
+  try {
+    return new ClientInspectorSource(bootstrap, label, undefined, realmSource)
+  } catch (error) {
+    realmSource.close()
+    throw error
+  }
 }

packages/experimental/inspector/src/client/bridge/transport.ts

@@ -50,9 +50,10 @@ export class ClientInspectorSource extends InspectorSourceConnection {
     private readonly bootstrap: InspectorClientBootstrap,
     label = document.title || 'Client',
     private readonly sourceCatalog: ClientSourceCatalog | undefined = discoverInspectorClientSourceCatalog(),
+    realmSource = new ClientRealmSource(label),
   ) {
     super()
-    this.realmSource = new ClientRealmSource(label)
+    this.realmSource = realmSource
     this.lifecycle = new ClientBridgeLifecycle(bootstrap.reconnectBaseMs, bootstrap.reconnectMaxMs)
     this.publisher = new ClientBridgePublisher({
       topics: ['*'],
@@ -107,19 +108,23 @@ export class ClientInspectorSource extends InspectorSourceConnection {
     this.publisher.close()
     const socket = this.socket
     const generation = this.generation
-    if (socket?.readyState === WebSocket.OPEN && generation !== undefined) {
-      const frame: SourceCloseFrame = {
-        v: INSPECTOR_PROTOCOL_VERSION,
-        t: 'source/close',
-        sourceId: this.realmSource.sourceId,
-        generation,
+    try {
+      if (socket?.readyState === WebSocket.OPEN && generation !== undefined) {
+        const frame: SourceCloseFrame = {
+          v: INSPECTOR_PROTOCOL_VERSION,
+          t: 'source/close',
+          sourceId: this.realmSource.sourceId,
+          generation,
+        }
+        socket.send(JSON.stringify(frame))
+        socket.close(1000, 'Client source closed')
+      } else {
+        socket?.close()
       }
-      socket.send(JSON.stringify(frame))
-      socket.close(1000, 'Client source closed')
-    } else {
-      socket?.close()
+    } finally {
+      this.socket = undefined
+      this.realmSource.close()
     }
-    this.socket = undefined
   }
 
   private connect(): void {

packages/experimental/inspector/src/client/inspection/realm.ts

@@ -5,12 +5,42 @@ import { inspectorId } from '../../shared/identity.ts'
 import type { InspectorSourceDescriptor } from '../../shared/bridge/messages/observation.ts'
 import { bridgeCapabilities } from '../cdp/index.ts'
 
+const CLIENT_SOURCE_STORAGE_KEY = 'dsh.experimental-inspector.client-source-id.v0'
+const CLIENT_SOURCE_LOCK_PREFIX = 'dsh.experimental-inspector.client-source:'
+
 /** Owns one browser realm's stable source id across transport reconnects. */
 export class ClientRealmSource {
   /** Logical source id retained across reconnecting transport generations. */
-  readonly sourceId = inspectorId<'InspectorSourceId'>(`client-${randomUUID()}`, 'sourceId')
+  readonly sourceId: InspectorSourceDescriptor['sourceId']
 
-  constructor(private readonly label: string) {}
+  constructor(
+    private readonly label: string,
+    sourceId = sessionClientSourceId(),
+    private releaseClaim?: () => void,
+  ) {
+    this.sourceId = sourceId
+  }
+
+  /**
+   * Claim the tab identity before opening its source transport. Browsers with
+   * Web Locks reject a copied `sessionStorage` identity while its original tab
+   * remains live; a fresh id is persisted and claimed instead.
+   * @param label - Human-readable Client label reported to the Worker.
+   * @returns The claimed realm source.
+   */
+  static async claim(label: string): Promise<ClientRealmSource> {
+    let sourceId = sessionClientSourceId()
+    const locks = browserLockManager()
+    if (locks === undefined) return new ClientRealmSource(label, sourceId)
+    while (true) {
+      const release = await tryClaimSourceId(locks, sourceId)
+      if (release !== undefined) {
+        persistClientSourceId(sourceId)
+        return new ClientRealmSource(label, sourceId, release)
+      }
+      sourceId = generatedClientSourceId()
+    }
+  }
 
   /**
    * Create the descriptor for one newly admitted transport generation.
@@ -27,6 +57,65 @@ export class ClientRealmSource {
       capabilities: bridgeCapabilities(clientOrigin(), hasSources),
     }
   }
+
+  /** Release this page's identity claim. */
+  close(): void {
+    this.releaseClaim?.()
+    this.releaseClaim = undefined
+  }
+}
+
+function sessionClientSourceId(): InspectorSourceDescriptor['sourceId'] {
+  const generated = generatedClientSourceId()
+  try {
+    const stored = sessionStorage.getItem(CLIENT_SOURCE_STORAGE_KEY)
+    if (stored !== null) {
+      try {
+        return inspectorId<'InspectorSourceId'>(stored, 'sourceId')
+      } catch {
+        // Invalid page-owned storage is replaced with a fresh protocol identity below.
+      }
+    }
+    sessionStorage.setItem(CLIENT_SOURCE_STORAGE_KEY, generated)
+  } catch {
+    // Disabled or unavailable session storage limits identity to this page lifetime.
+  }
+  return generated
+}
+
+function generatedClientSourceId(): InspectorSourceDescriptor['sourceId'] {
+  return inspectorId<'InspectorSourceId'>(`client-${randomUUID()}`, 'sourceId')
+}
+
+function persistClientSourceId(sourceId: InspectorSourceDescriptor['sourceId']): void {
+  try {
+    sessionStorage.setItem(CLIENT_SOURCE_STORAGE_KEY, sourceId)
+  } catch {
+    // Disabled or unavailable session storage limits identity to this page lifetime.
+  }
+}
+
+function browserLockManager(): LockManager | undefined {
+  if (typeof navigator === 'undefined') return undefined
+  return navigator.locks
+}
+
+function tryClaimSourceId(
+  locks: LockManager,
+  sourceId: InspectorSourceDescriptor['sourceId'],
+): Promise<(() => void) | undefined> {
+  return new Promise((resolve, reject) => {
+    let release!: () => void
+    const held = new Promise<void>((released) => { release = released })
+    void locks.request(`${CLIENT_SOURCE_LOCK_PREFIX}${sourceId}`, { ifAvailable: true }, async (lock) => {
+      if (lock === null) {
+        resolve(undefined)
+        return
+      }
+      resolve(release)
+      await held
+    }).catch(reject)
+  })
 }
 
 function clientOrigin(): string {

packages/experimental/inspector/src/client/plugin.ts

@@ -38,15 +38,18 @@ export const name = 'experimental-inspector'
 /** This transport root has no Client service dependencies. */
 export const inject: string[] = []
 
-/** Mount the Client source and shared `ctx.inspector` publishing API. */
-export function apply(ctx: Context): void {
+/**
+ * Mount the Client source and shared `ctx.inspector` publishing API.
+ * @param ctx - Client Cordis context whose page identity and lifecycle own the source.
+ */
+export async function apply(ctx: Context): Promise<void> {
   const injected = globalThis.__DSH_INSPECTOR__
   if (injected === undefined) {
     throw new Error('experimental inspector: Host bootstrap is missing')
   }
   const bootstrap = parseInspectorClientBootstrap(injected)
-  ctx.effect(() => {
-    const source = startInspectorClient(bootstrap)
+  await ctx.effect(async () => {
+    const source = await startInspectorClient(bootstrap)
     const disposers: Array<() => unknown> = []
     try {
       disposers.push(publishCordisTree(ctx, source, {
@@ -66,7 +69,10 @@ export function apply(ctx: Context): void {
   }, 'experimental-inspector: Client source')
 }
 
-function disposeInspectorClient(source: ReturnType<typeof startInspectorClient>, disposers: readonly (() => unknown)[]): void {
+function disposeInspectorClient(
+  source: Awaited<ReturnType<typeof startInspectorClient>>,
+  disposers: readonly (() => unknown)[],
+): void {
   const failures: unknown[] = []
   for (const dispose of [...disposers].reverse()) {
     try {

packages/experimental/inspector/tests/client-browser.e2e.ts

@@ -150,8 +150,10 @@ describe.skipIf(!built)('Inspector built Client in Chromium', () => {
     const context = contextEvent.params?.context as Record<string, unknown>
     const contextId = context.id
     const uniqueContextId = context.uniqueId
+    const sourceId = asRecord(context.auxData).sourceId
     expect(contextId).toBeTypeOf('number')
     expect(uniqueContextId).toBeTypeOf('string')
+    expect(sourceId).toBeTypeOf('string')
 
     const evaluated = await cdp.call('Runtime.evaluate', {
       expression: 'globalThis.__inspectorConsoleEvaluation = { answer: 6 * 7 }',
@@ -211,6 +213,26 @@ describe.skipIf(!built)('Inspector built Client in Chromium', () => {
       url: script.params?.url,
       lineNumber: 0,
     })).error?.message).toContain('Client native debugging is unavailable')
+
+    const duplicateContext = cdp.waitForEvent('Runtime.executionContextCreated', (event) => {
+      const candidate = event.params?.context as Record<string, unknown> | undefined
+      return String(candidate?.name).startsWith('Client —') && candidate?.id !== contextId
+    })
+    const popup = await Promise.all([
+      page.waitForEvent('popup'),
+      page.evaluate(() => {
+        if (window.open(location.href, '_blank') === null) throw new Error('duplicate tab was blocked')
+      }),
+    ]).then(([opened]) => opened)
+    await popup.waitForFunction(() => Reflect.get(globalThis, '__INSPECTOR_BROWSER_TEST__') !== undefined)
+    const duplicate = (await duplicateContext).params?.context as Record<string, unknown>
+    expect(asRecord(duplicate.auxData).sourceId).not.toBe(sourceId)
+    await cdp.call('Debugger.disable')
+    await popup.evaluate(async () => {
+      const state = Reflect.get(globalThis, '__INSPECTOR_BROWSER_TEST__') as { dispose?: () => Promise<void> } | undefined
+      await state?.dispose?.()
+    })
+    await popup.close()
   }, 20_000)
 })
 
@@ -231,14 +253,14 @@ globalThis.__DSH_BOOT__ = ${JSON.stringify(boot)};
 globalThis.__ModuleLoader__ = { load(registration) { globalThis.__INSPECTOR_REGISTRATION__ = registration; } };
 </script>
 <script src="/client.js?rev=browser-test"></script>
-<script>
+<script type="module">
 const registration = globalThis.__INSPECTOR_REGISTRATION__;
 const disposers = [];
 const root = {
   __inspectorContext: true,
   registry: new Map(),
   events: { _hooks: {} },
-  effect(callback) { const dispose = callback(); disposers.push(dispose); return dispose; },
+  async effect(callback) { const dispose = await callback(); disposers.push(dispose); return dispose; },
   on() { return () => {}; },
   provide(name, value) { this[name] = value; return () => { delete this[name]; }; },
 };
@@ -248,9 +270,9 @@ const plugin = registration.factory(specifier => {
   if (specifier === '@deepseek-ai/cordis') return cordis;
   throw new Error('Unexpected Client bundle dependency ' + specifier);
 });
-plugin.apply(root);
+await plugin.apply(root);
 globalThis.__INSPECTOR_BROWSER_TEST__ = {
-  dispose() { for (const dispose of disposers.reverse()) dispose(); },
+  async dispose() { for (const dispose of disposers.reverse()) await dispose(); },
 };
 </script>`
 }

packages/experimental/inspector/tests/plugin.client.spec.ts

@@ -3,6 +3,7 @@
 import { Context } from '@deepseek-ai/cordis'
 import { afterEach, describe, expect, it, vi } from 'vitest'
 import { apply } from '../src/client/index.ts'
+import { ClientRealmSource } from '../src/client/inspection/realm.ts'
 import type { InspectorClientBootstrap } from '../src/shared/bridge/messages/control.ts'
 
 class FakeWebSocket extends EventTarget {
@@ -66,9 +67,11 @@ describe('experimental Inspector Client plugin', () => {
   const nativeFetch = globalThis.fetch
 
   afterEach(() => {
+    vi.restoreAllMocks()
     FakeWebSocket.sockets.length = 0
     globalThis.WebSocket = nativeWebSocket
     globalThis.fetch = nativeFetch
+    sessionStorage.clear()
     delete globalThis.__DSH_INSPECTOR__
     Reflect.deleteProperty(globalThis, '__DSH_BOOT__')
   })
@@ -179,6 +182,92 @@ describe('experimental Inspector Client plugin', () => {
     await fiber.dispose()
   })
 
+  it('keeps the logical source id when the Client plugin is recreated after a page refresh', async () => {
+    globalThis.WebSocket = FakeWebSocket as unknown as typeof WebSocket
+    globalThis.__DSH_INSPECTOR__ = bootstrap
+    const firstContext = new Context()
+    const firstFiber = firstContext.plugin({ apply })
+    await firstFiber.await()
+    const firstSocket = FakeWebSocket.sockets[0]!
+    firstSocket.open()
+    const firstOpen = JSON.parse(firstSocket.sent[0]!) as {
+      source: { sourceId: string; generation: string }
+    }
+    await firstFiber.dispose()
+
+    const secondContext = new Context()
+    const secondFiber = secondContext.plugin({ apply })
+    await secondFiber.await()
+    const secondSocket = FakeWebSocket.sockets[1]!
+    secondSocket.open()
+    const secondOpen = JSON.parse(secondSocket.sent[0]!) as {
+      source: { sourceId: string; generation: string }
+    }
+
+    expect(secondOpen.source.sourceId).toBe(firstOpen.source.sourceId)
+    expect(secondOpen.source.generation).not.toBe(firstOpen.source.generation)
+    await secondFiber.dispose()
+  })
+
+  it('rotates a copied session identity while its original page remains live', async () => {
+    const descriptor = Object.getOwnPropertyDescriptor(navigator, 'locks')
+    const held = new Set<string>()
+    const request = async (
+      name: string,
+      _options: LockOptions,
+      callback: (lock: Lock | null) => unknown,
+    ): Promise<unknown> => {
+      const acquired = !held.has(name)
+      if (acquired) held.add(name)
+      try {
+        return await callback(acquired ? { name, mode: 'exclusive' } : null)
+      } finally {
+        if (acquired) held.delete(name)
+      }
+    }
+    Object.defineProperty(navigator, 'locks', {
+      configurable: true,
+      value: { request },
+    })
+    let first: ClientRealmSource | undefined
+    let duplicate: ClientRealmSource | undefined
+    let refreshed: ClientRealmSource | undefined
+    try {
+      first = await ClientRealmSource.claim('first')
+      duplicate = await ClientRealmSource.claim('duplicate')
+      expect(duplicate.sourceId).not.toBe(first.sourceId)
+
+      first.close()
+      await vi.waitFor(() => { expect(held.size).toBe(1) })
+      sessionStorage.setItem('dsh.experimental-inspector.client-source-id.v0', first.sourceId)
+      refreshed = await ClientRealmSource.claim('refreshed')
+      expect(refreshed.sourceId).toBe(first.sourceId)
+    } finally {
+      first?.close()
+      duplicate?.close()
+      refreshed?.close()
+      if (descriptor === undefined) Reflect.deleteProperty(navigator, 'locks')
+      else Object.defineProperty(navigator, 'locks', descriptor)
+    }
+  })
+
+  it('falls back to a page-lifetime source id when session storage is unavailable', async () => {
+    globalThis.WebSocket = FakeWebSocket as unknown as typeof WebSocket
+    globalThis.__DSH_INSPECTOR__ = bootstrap
+    vi.spyOn(Storage.prototype, 'getItem').mockImplementation(() => {
+      throw new DOMException('storage disabled', 'SecurityError')
+    })
+    const ctx = new Context()
+    const fiber = ctx.plugin({ apply })
+    await fiber.await()
+    const socket = FakeWebSocket.sockets[0]!
+    socket.open()
+    const open = JSON.parse(socket.sent[0]!) as { source: { sourceId: string } }
+
+    expect(open.source.sourceId).toMatch(/^client-/u)
+    await fiber.dispose()
+  })
+
   it('cancels an outstanding Client Runtime operation without sending a late response', async () => {
     globalThis.WebSocket = FakeWebSocket as unknown as typeof WebSocket
     globalThis.__DSH_INSPECTOR__ = bootstrap

packages/experimental/webworker-runtime/src/module-system/module-loader.ts

@@ -45,6 +45,13 @@ export type Resolution =
   | { readonly kind: 'static'; readonly specifier: string; readonly factory: StaticModuleFactory }
   | { readonly kind: 'file'; readonly path: string }
 
+/** Node-loader-compatible resolution returned through the Cordis internal seam. */
+export interface WorkerInternalResolution {
+  readonly format: 'builtin' | 'commonjs' | 'json'
+  /** File URL for VFS modules; the original bare specifier for builtins. */
+  readonly url: string
+}
+
 interface ModuleRecord {
   readonly module: { exports: unknown }
 }
@@ -121,6 +128,8 @@ export class WorkerModuleLoader {
   readonly internal: {
     readonly version: 'worker'
     import(specifier: string, parentURL?: string, attributes?: unknown): Promise<unknown>
+    resolve(specifier: string, parentURL?: string, attributes?: unknown): Promise<WorkerInternalResolution>
+    resolveSync(specifier: string, parentURL?: string, attributes?: unknown): WorkerInternalResolution
   }
 
   constructor(options: WorkerModuleLoaderOptions) {
@@ -133,12 +142,23 @@ export class WorkerModuleLoader {
       .sort(([left], [right]) => right.length - left.length)
     this.conditions = new Set(options.conditions ?? DEFAULT_CONDITIONS)
     this.als = createAlsRuntime(options.alsCausality)
+    const resolveInternal = (specifier: string, parentURL?: string): WorkerInternalResolution => {
+      const from = parentURL === undefined ? this.root : this.baseDirectoryOf(parentURL)
+      const resolution = this.resolve(specifier, from)
+      if (resolution.kind === 'static') return { format: 'builtin', url: resolution.specifier }
+      return {
+        format: resolution.path.endsWith('.json') ? 'json' : 'commonjs',
+        url: pathToFileUrl(resolution.path),
+      }
+    }
     this.internal = {
       version: 'worker',
       import: async (specifier: string, parentURL?: string): Promise<unknown> => {
         const from = parentURL === undefined ? this.root : this.baseDirectoryOf(parentURL)
         return this.load(this.resolve(specifier, from))
       },
+      resolve: async (specifier: string, parentURL?: string) => resolveInternal(specifier, parentURL),
+      resolveSync: resolveInternal,
     }
   }
 

packages/experimental/webworker-runtime/tests/node/builtins-table.spec.ts

@@ -60,6 +60,23 @@ describe('the replacement table', () => {
 })
 
 describe('module identity through the loader', () => {
+  it('exposes async and synchronous resolution through the Cordis internal seam', async () => {
+    const vfs = new MemoryVfs()
+    vfs.seedDirectory('/dsh/node_modules/example')
+    vfs.writeFileSync('/dsh/node_modules/example/package.json', JSON.stringify({ main: 'index.js' }))
+    vfs.writeFileSync('/dsh/node_modules/example/index.js', 'module.exports = {}\n')
+    const loader = new WorkerModuleLoader({ vfs, root: '/dsh', staticModules: createNodeBuiltins() })
+
+    expect(loader.internal.resolveSync('example', 'file:///dsh/app.js')).toEqual({
+      format: 'commonjs',
+      url: 'file:///dsh/node_modules/example/index.js',
+    })
+    await expect(loader.internal.resolve('node:fs', 'file:///dsh/app.js')).resolves.toEqual({
+      format: 'builtin',
+      url: 'node:fs',
+    })
+  })
+
   it('hands the same instance to two requires of one specifier', () => {
     const require = loaderRequire()
     expect(require('node:events')).toBe(require('node:events'))

packages/host/directory-picker-auto/tests/loader-composition.spec.ts

@@ -138,6 +138,14 @@ function entryNames(ctx: Context): string[] {
   return [...ctx.loader.entries()].map(entry => entry.options.name)
 }
 
+/** The Include tree that backs the booted `cordis.yml` file. */
+function includeTree(ctx: Context): Include {
+  const include = [...ctx.loader.entries()]
+    .find(entry => entry.options.name === 'cordis:include')?.subtree as Include | undefined
+  if (include === undefined) throw new Error('expected the root Include tree')
+  return include
+}
+
 /**
  * Force every signal of an attended host on any platform: no SSH launch, a
  * display, and a PATH holding one executable chooser binary so the real
@@ -188,10 +196,10 @@ describe('real Loader composition', () => {
     // behavior, not the chooser's); await that debounced write so it cannot
     // race the temp-dir removal, and pin that the persisted row is the
     // chooser itself — the resolved backend still never reaches the file.
-    await expect.poll(
-      async () => await readFile(configPath, 'utf8'),
-      { timeout: 15_000 },
-    ).toContain('disabled: true')
+    // stop() drains the Include write queue, so this assertion does not depend
+    // on the debounce timer racing Windows coverage load.
+    await includeTree(ctx).stop()
+    expect(await readFile(configPath, 'utf8')).toContain('disabled: true')
     expect(await readFile(configPath, 'utf8')).not.toContain(NATIVE)
   })
 
@@ -240,8 +248,10 @@ describe('real Loader composition', () => {
     await expect(autoEntry.fiber!.dispose()).resolves.not.toThrow()
     expect(entryNames(ctx)).not.toContain(NATIVE)
     expect(entryNames(ctx)).not.toContain(NATIVE_SURFACE)
-    // Same self-dispose persistence as above: let the write land before teardown.
-    await expect.poll(async () => await readFile(configPath, 'utf8')).toContain('disabled: true')
+    // Same self-dispose persistence as above: drain the Include write queue
+    // deterministically before asserting the persisted row.
+    await includeTree(ctx).stop()
+    expect(await readFile(configPath, 'utf8')).toContain('disabled: true')
     expect(renameControl.injectedFailures).toBe(1)
     expect(renameControl.remainingFailures).toBe(0)
     expect(renameControl.attempts).toBeGreaterThanOrEqual(2)
@@ -251,9 +261,7 @@ describe('real Loader composition', () => {
     stubAttendedHost()
     const { ctx } = await loadComposition('127.0.0.1')
     const autoEntry = [...ctx.loader.entries()].find(entry => entry.options.name === AUTO)!
-    const include = [...ctx.loader.entries()]
-      .find(entry => entry.options.name === 'cordis:include')?.subtree as Include | undefined
-    if (include === undefined) throw new Error('expected the root Include tree')
+    const include = includeTree(ctx)
     renameControl.failureCode = 'EIO'
     renameControl.remainingFailures = 1
 

scripts/gen-tsconfig-paths.spec.ts

@@ -0,0 +1,98 @@
+import { readFileSync } from 'node:fs'
+import { resolve } from 'node:path'
+import { describe, expect, it } from 'vitest'
+import {
+  collectPackageAliases,
+  collectPackageNames,
+  mappedSpecifiers,
+  renderAliases,
+  uncoveredPackages,
+  writeRegion,
+} from './gen-tsconfig-paths.ts'
+
+const root = resolve(import.meta.dirname, '..')
+
+describe('generated tsconfig package aliases', () => {
+  it('maps each package to its own source directory', () => {
+    const aliases = collectPackageAliases()
+    expect(aliases.length).toBeGreaterThan(100)
+    const session = aliases.find(alias => alias.specifier === '@deepseek-ai/dsh-session')
+    expect(session).toEqual({
+      specifier: '@deepseek-ai/dsh-session',
+      source: './packages/core/session/src',
+      hasInvariant: true,
+    })
+    // Sorted, so a package added anywhere lands in a stable spot in the diff.
+    expect([...aliases].sort((a, b) => a.specifier.localeCompare(b.specifier))).toEqual(aliases)
+    // Only packages named after their directory: the rest carry hand-written
+    // aliases, because the removed wildcards could never have resolved them.
+    expect(aliases.some(alias => alias.specifier === '@deepseek-ai/dsh-typert-protocol')).toBe(false)
+  })
+
+  it('yields to a hand-written alias and closes without a trailing comma', () => {
+    const aliases = [
+      { specifier: '@deepseek-ai/dsh-a', source: './packages/g/a/src', hasInvariant: true },
+      { specifier: '@deepseek-ai/dsh-b', source: './packages/g/b/src', hasInvariant: false },
+    ]
+    const body = renderAliases(aliases, new Set(['@deepseek-ai/dsh-a']))
+
+    // The hand-written bare alias is skipped; its /invariant sibling is not.
+    expect(body).toBe([
+      '      "@deepseek-ai/dsh-a/invariant": ["./packages/g/a/src/invariant.ts"]',
+      '      "@deepseek-ai/dsh-b": ["./packages/g/b/src"]',
+    ].join(',\n'))
+    expect(body.endsWith(',')).toBe(false)
+  })
+
+  it('replaces only the marked region', () => {
+    const text = [
+      '{ "before": 1,',
+      '      // BEGIN generated package aliases — pnpm run gen-tsconfig-paths',
+      '      "stale": ["gone"]',
+      '      // END generated package aliases',
+      '  "after": 2 }',
+    ].join('\n')
+
+    const next = writeRegion(text, '      "fresh": ["kept"]')
+
+    expect(next).toContain('{ "before": 1,')
+    expect(next).toContain('  "after": 2 }')
+    expect(next).toContain('"fresh": ["kept"]')
+    expect(next).not.toContain('stale')
+  })
+
+  it('refuses a config without the region markers', () => {
+    expect(() => writeRegion('{}', '')).toThrow('missing the generated-region markers')
+  })
+
+  it('names a package that no alias covers', () => {
+    // Deleting the group wildcards removed the fallback that used to resolve a
+    // package nobody had aliased. A package whose name does not match its
+    // directory is skipped by the generator, so without this check it would
+    // resolve through the workspace symlink to built lib/types instead.
+    expect(uncoveredPackages(
+      ['@deepseek-ai/dsh-a', '@deepseek-ai/dsh-b'],
+      new Set(['@deepseek-ai/dsh-a', '@deepseek-ai/dsh-a/invariant']),
+    )).toEqual(['@deepseek-ai/dsh-b'])
+
+    expect(uncoveredPackages(['@deepseek-ai/dsh-a'], new Set(['@deepseek-ai/dsh-a']))).toEqual([])
+  })
+
+  it('covers every workspace package in the committed config', () => {
+    const config = readFileSync(resolve(root, 'tsconfig.base.json'), 'utf8')
+    // Includes the packages the generator skips because their name does not
+    // match their directory: those carry hand-written aliases.
+    const names = collectPackageNames()
+    expect(names).toContain('@deepseek-ai/dsh-typert-protocol')
+    expect(uncoveredPackages(names, mappedSpecifiers(config))).toEqual([])
+  })
+
+  it('leaves no wildcard that probes every package group', () => {
+    const config = readFileSync(resolve(root, 'tsconfig.base.json'), 'utf8')
+    // These two listed one candidate per group, so resolving a package late in
+    // the list cost a filesystem probe — and under tsx a decorated module
+    // error — for every group before it.
+    expect(config).not.toContain('"@deepseek-ai/dsh-*":')
+    expect(config).not.toContain('"@deepseek-ai/dsh-*/invariant":')
+  })
+})

scripts/gen-tsconfig-paths.ts

@@ -0,0 +1,248 @@
+/**
+ * Expand the workspace path aliases that a wildcard would otherwise resolve by
+ * probing every package group in turn.
+ *
+ * `tsconfig.base.json` is the resolution facade for the whole repository, and
+ * two of its aliases used one key per *group* rather than per package:
+ * `@deepseek-ai/dsh-*` listed 49 candidate globs and `@deepseek-ai/dsh-*\/invariant`
+ * listed 45. TypeScript and tsx try those candidates in order, so a specifier
+ * whose package sits late in the list pays for every earlier miss. Under tsx's
+ * ESM hook each miss is an `ERR_MODULE_NOT_FOUND` that Node decorates with a
+ * full CommonJS resolution walk, which dominated source-launch boot.
+ *
+ * This generator writes one explicit entry per package into a marked region of
+ * `tsconfig.base.json`, leaving every hand-written alias and comment outside
+ * that region untouched. `--check` reports drift instead of writing, so a new
+ * package that needs an alias fails a gate rather than silently resolving
+ * through a fallback that no longer exists.
+ *
+ * @module scripts/gen-tsconfig-paths
+ */
+
+import { readFileSync, writeFileSync, existsSync, readdirSync, statSync } from 'node:fs'
+import { join, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const ROOT = fileURLToPath(new URL('..', import.meta.url))
+const CONFIG = join(ROOT, 'tsconfig.base.json')
+const BEGIN = '      // BEGIN generated package aliases — pnpm run gen-tsconfig-paths'
+const END = '      // END generated package aliases'
+
+/** Package-name prefix the expanded aliases cover. */
+const PREFIX = '@deepseek-ai/dsh-'
+
+/** One workspace package the generated region maps. */
+interface PackageAlias {
+  /** Bare specifier, e.g. `@deepseek-ai/dsh-session`. */
+  readonly specifier: string
+  /** Repository-relative source directory, e.g. `./packages/session/session/src`. */
+  readonly source: string
+  /** Whether the package carries `src/invariant.ts`, which earns a second alias. */
+  readonly hasInvariant: boolean
+}
+
+/**
+ * Read a workspace manifest's declared name.
+ * @param manifest - absolute path to a `package.json`.
+ * @returns The declared name, or undefined when the file is absent or nameless.
+ */
+function packageName(manifest: string): string | undefined {
+  let parsed: unknown
+  try {
+    parsed = JSON.parse(readFileSync(manifest, 'utf8'))
+  } catch (_absentOrUnreadableManifest) {
+    return undefined
+  }
+  if (typeof parsed !== 'object' || parsed === null) return undefined
+  const name: unknown = (parsed as { name?: unknown }).name
+  return typeof name === 'string' ? name : undefined
+}
+
+/** One workspace package directory and the name its manifest declares. */
+interface WorkspacePackage {
+  readonly group: string
+  readonly directory: string
+  readonly packageDir: string
+  readonly name: string
+}
+
+/**
+ * Walk `packages/<group>/<directory>` once, in a stable order.
+ * @returns Every directory whose manifest names a `@deepseek-ai/dsh-` package and that carries `src`.
+ */
+function workspacePackages(): WorkspacePackage[] {
+  const packages = join(ROOT, 'packages')
+  const found: WorkspacePackage[] = []
+  for (const group of readdirSync(packages).sort()) {
+    const groupDir = join(packages, group)
+    if (!statSync(groupDir).isDirectory()) continue
+    for (const directory of readdirSync(groupDir).sort()) {
+      const packageDir = join(groupDir, directory)
+      const name = packageName(join(packageDir, 'package.json'))
+      if (name === undefined || !name.startsWith(PREFIX)) continue
+      if (existsSync(join(packageDir, 'src'))) found.push({ group, directory, packageDir, name })
+    }
+  }
+  return found
+}
+
+/**
+ * Collect every package the removed wildcards could resolve.
+ *
+ * A wildcard substituted the specifier's suffix into `packages/<group>/<suffix>/src`,
+ * so it only ever resolved a package whose declared name is exactly
+ * `@deepseek-ai/dsh-<directory>`. Packages named after something other than
+ * their directory already carry a hand-written alias and are skipped here.
+ *
+ * @returns Aliases sorted by specifier.
+ * @throws When two package directories claim one specifier, which the removed
+ * wildcards resolved by group order and an explicit map cannot express.
+ */
+export function collectPackageAliases(): PackageAlias[] {
+  const bySpecifier = new Map<string, PackageAlias & { directory: string }>()
+  for (const { group, directory, packageDir, name } of workspacePackages()) {
+    if (name !== `${PREFIX}${directory}`) continue
+    const previous = bySpecifier.get(name)
+    if (previous !== undefined) {
+      throw new Error(
+        `gen-tsconfig-paths: ${name} is claimed by packages/${previous.directory} and packages/${group}/${directory}; `
+        + 'an explicit alias cannot express the group-order tiebreak the wildcard used.',
+      )
+    }
+    bySpecifier.set(name, {
+      specifier: name,
+      source: `./packages/${group}/${directory}/src`,
+      hasInvariant: existsSync(join(packageDir, 'src', 'invariant.ts')),
+      directory: `${group}/${directory}`,
+    })
+  }
+  return [...bySpecifier.values()]
+    .map(({ specifier, source, hasInvariant }) => ({ specifier, source, hasInvariant }))
+    .sort((left, right) => left.specifier.localeCompare(right.specifier))
+}
+
+/**
+ * Collect every workspace package the aliases must cover.
+ *
+ * Unlike {@link collectPackageAliases} this keeps packages whose name does not
+ * match their directory. The generator cannot map those — only a hand-written
+ * alias can — but they still have to be mapped by something, because deleting
+ * the group wildcards removed the fallback that used to catch them.
+ *
+ * @returns Declared names of every `@deepseek-ai/dsh-` package carrying a `src` directory.
+ */
+export function collectPackageNames(): string[] {
+  return workspacePackages()
+    .map(({ name }) => name)
+    .sort((left, right) => left.localeCompare(right))
+}
+
+/**
+ * Read the bare package specifiers a config maps, generated region included.
+ * @param text - `tsconfig.base.json` contents.
+ * @returns Specifiers mapped without a subpath.
+ */
+export function mappedSpecifiers(text: string): Set<string> {
+  const keys = new Set<string>()
+  for (const match of text.matchAll(/^\s*"(@deepseek-ai\/dsh-[^"/]+)":/gm)) {
+    const key = match[1]
+    if (key !== undefined) keys.add(key)
+  }
+  return keys
+}
+
+/**
+ * Report packages that no alias maps.
+ *
+ * A package missing from `paths` still resolves — through the workspace symlink
+ * and the package's own `exports` — but to built `lib/` output rather than to
+ * source, which is the artifact-plane leak the explicit aliases exist to avoid.
+ * Naming it here turns that into a gate failure instead of a silent difference.
+ *
+ * @param packages - every workspace package that needs an alias.
+ * @param mapped - bare specifiers the config maps.
+ * @returns Unmapped package names, in the order given.
+ */
+export function uncoveredPackages(
+  packages: readonly string[],
+  mapped: ReadonlySet<string>,
+): string[] {
+  return packages.filter(name => !mapped.has(name))
+}
+
+/**
+ * Render the generated region's alias lines.
+ * @param aliases - packages to map, in emission order.
+ * @param handWritten - specifiers already mapped outside the region; a duplicate key would shadow one silently.
+ * @returns The region body, one JSON member per line.
+ */
+export function renderAliases(aliases: readonly PackageAlias[], handWritten: ReadonlySet<string>): string {
+  const lines: string[] = []
+  for (const alias of aliases) {
+    if (!handWritten.has(alias.specifier)) {
+      lines.push(`      ${JSON.stringify(alias.specifier)}: [${JSON.stringify(alias.source)}]`)
+    }
+    const invariant = `${alias.specifier}/invariant`
+    if (alias.hasInvariant && !handWritten.has(invariant)) {
+      lines.push(`      ${JSON.stringify(invariant)}: [${JSON.stringify(`${alias.source}/invariant.ts`)}]`)
+    }
+  }
+  // The region closes `paths`, so the last member carries no trailing comma.
+  return lines.join(',\n')
+}
+
+/**
+ * Replace the generated region of a config's text.
+ * @param text - current `tsconfig.base.json` contents.
+ * @param body - rendered alias lines.
+ * @returns The updated contents.
+ * @throws When the markers are missing or out of order.
+ */
+export function writeRegion(text: string, body: string): string {
+  const begin = text.indexOf(BEGIN)
+  const end = text.indexOf(END)
+  if (begin < 0 || end < begin) {
+    throw new Error(`gen-tsconfig-paths: ${CONFIG} is missing the generated-region markers.`)
+  }
+  return `${text.slice(0, begin)}${BEGIN}\n${body}\n${END}${text.slice(end + END.length)}`
+}
+
+/**
+ * Parse the config's `paths` keys, ignoring the generated region.
+ * @param text - current `tsconfig.base.json` contents.
+ * @returns Specifiers mapped by hand.
+ */
+function handWrittenSpecifiers(text: string): Set<string> {
+  const begin = text.indexOf(BEGIN)
+  const end = text.indexOf(END)
+  const outside = begin < 0 || end < begin ? text : text.slice(0, begin) + text.slice(end)
+  const keys = new Set<string>()
+  for (const match of outside.matchAll(/^\s*"(@deepseek-ai\/[^"]+)":/gm)) {
+    const key = match[1]
+    if (key !== undefined) keys.add(key)
+  }
+  return keys
+}
+
+if (process.argv[1] && import.meta.filename === resolve(process.argv[1])) {
+  const check = process.argv.includes('--check')
+  const current = readFileSync(CONFIG, 'utf8')
+  const next = writeRegion(current, renderAliases(collectPackageAliases(), handWrittenSpecifiers(current)))
+  const uncovered = uncoveredPackages(collectPackageNames(), mappedSpecifiers(next))
+  if (uncovered.length > 0) {
+    console.error(
+      'gen-tsconfig-paths: no alias maps '
+      + `${uncovered.join(', ')}; add a hand-written entry, because a package named after `
+      + 'something other than its directory cannot be generated.',
+    )
+    process.exitCode = 1
+  } else if (current === next) {
+    console.log('gen-tsconfig-paths: tsconfig.base.json package aliases are current.')
+  } else if (check) {
+    console.error('gen-tsconfig-paths: tsconfig.base.json is stale; run `pnpm run gen-tsconfig-paths`.')
+    process.exitCode = 1
+  } else {
+    writeFileSync(CONFIG, next)
+    console.log('gen-tsconfig-paths: rewrote tsconfig.base.json package aliases.')
+  }
+}

scripts/run-gates.ts

@@ -720,6 +720,7 @@ function docSyncLeafGates(options: {
     pnpmScript('doc-refs', 'verify-doc-refs', { label: 'doc refs', quick: true }),
     pnpmScript('subsystem-pages', 'verify-subsystem-pages', { label: 'subsystem pages' }),
     pnpmScript('package-paths', 'verify-package-paths', { label: 'package paths' }),
+    pnpmScript('tsconfig-paths', 'verify-tsconfig-paths', { label: 'tsconfig paths' }),
     pnpmScript('config-source-ownership', 'verify-config-source-ownership', { label: 'config source ownership' }),
     pnpmScript('package-readme-model-experience', 'verify-package-readme-model-experience', { label: 'package README model experience', quick: true }),
     pnpmScript('agent-note-classification', 'verify-agent-note-classification', { label: 'agent note classification', quick: true }),

tsconfig.base.json

@@ -127,67 +127,15 @@
       "@deepseek-ai/dsh-experimental-webworker-packer/invariant": ["./packages/experimental/webworker-packer/src/invariant.ts"],
       "@deepseek-ai/dsh-experimental-inspector/invariant": ["./packages/experimental/inspector/src/invariant.ts"],
       "@deepseek-ai/dsh-util-crypto/invariant": ["./packages/util/crypto/src/invariant.ts"],
-      "@deepseek-ai/dsh-*/invariant": [
-        "./packages/core/*/src/invariant.ts",
-        "./packages/prompt/*/src/invariant.ts",
-        "./packages/llm/*/src/invariant.ts",
-        "./packages/shell/*/src/invariant.ts",
-        "./packages/subprocess/*/src/invariant.ts",
-        "./packages/e2b/*/src/invariant.ts",
-        "./packages/code-runtime/*/src/invariant.ts",
-        "./packages/fs/*/src/invariant.ts",
-        "./packages/skill/*/src/invariant.ts",
-        "./packages/compaction/*/src/invariant.ts",
-        "./packages/context/*/src/invariant.ts",
-        "./packages/goal/*/src/invariant.ts",
-        "./packages/feedback/*/src/invariant.ts",
-        "./packages/schedule/*/src/invariant.ts",
-        "./packages/guard/*/src/invariant.ts",
-        "./packages/plan/*/src/invariant.ts",
-        "./packages/preset/*/src/invariant.ts",
-        "./packages/subagent/*/src/invariant.ts",
-        "./packages/jobs/*/src/invariant.ts",
-        "./packages/experimental/*/src/invariant.ts",
-        "./packages/workflow/*/src/invariant.ts",
-        "./packages/webhook/*/src/invariant.ts",
-        "./packages/web/*/src/invariant.ts",
-        "./packages/attachment/*/src/invariant.ts",
-        "./packages/spill/*/src/invariant.ts",
-        "./packages/todo/*/src/invariant.ts",
-        "./packages/bundle/*/src/invariant.ts",
-        "./packages/extensions/*/src/invariant.ts",
-        "./packages/sandbox/*/src/invariant.ts",
-        "./packages/hooks/*/src/invariant.ts",
-        "./packages/session/*/src/invariant.ts",
-        "./packages/session-query/*/src/invariant.ts",
-        "./packages/settings/*/src/invariant.ts",
-        "./packages/credentials/*/src/invariant.ts",
-        "./packages/acp/*/src/invariant.ts",
-        "./packages/storage/*/src/invariant.ts",
-        "./packages/workspace/*/src/invariant.ts",
-        "./packages/sdk/*/src/invariant.ts",
-        "./packages/interaction/*/src/invariant.ts",
-        "./packages/boot/*/src/invariant.ts",
-        "./packages/examples/*/src/invariant.ts",
-        "./packages/util/*/src/invariant.ts",
-        "./packages/mcp/*/src/invariant.ts",
-        "./packages/identity/*/src/invariant.ts",
-        "./packages/test-support/*/src/invariant.ts"
-      ],
       // host/client package names prefix the group dir (dsh-client-<dir>), so
-      // the generic dsh-*/invariant list above cannot map them; strip the
-      // group prefix with a dedicated wildcard per group instead.
+      // the generated aliases below — which map a package only when its name is
+      // exactly dsh-<dir> — skip them; strip the group prefix with a dedicated
+      // wildcard per group instead.
       "@deepseek-ai/dsh-host-*/invariant": ["./packages/host/*/src/invariant.ts"],
       "@deepseek-ai/dsh-client-*/invariant": ["./packages/client/*/src/invariant.ts"],
       "@deepseek-ai/dsh-headless/startup": ["./packages/bundle/headless/src/startup.ts"],
       "@deepseek-ai/dsh-web-app/startup": ["./packages/bundle/web-app/src/startup.ts"],
       "@deepseek-ai/dsh-client-*/client": ["./packages/client/*/src/client"],
-       // One wildcard maps every @deepseek-ai/dsh-<name> to its source. Package
-      // dir names are unique across groups, so first-on-disk-wins resolution is
-      // unambiguous; adding a package under an existing group needs no edit
-      // here. The aggregates' project references (tsconfig.host.json /
-      // tsconfig.client.json) stay explicit — TS project references have no
-      // wildcard form.
       "@deepseek-ai/dsh-host-apiproxy": ["./packages/host/apiproxy/src"],
       "@deepseek-ai/dsh-host-directory-picker": ["./packages/host/directory-picker/src"],
       "@deepseek-ai/dsh-host-directory-picker/*": ["./packages/host/directory-picker/src/*"],
@@ -263,69 +211,358 @@
       "@deepseek-ai/dsh-client-ui-settings-plugin-inventory": ["./packages/client/ui-settings-plugin-inventory/src"],
       "@deepseek-ai/dsh-client-locale": ["./packages/client/locale/src"],
       "@deepseek-ai/dsh-client-web": ["./packages/client/web/src"],
+      "@deepseek-ai/dsh-client-ui-directory-picker-browse": ["./packages/client/ui-directory-picker-browse/src"],
+      "@deepseek-ai/dsh-client-ui-directory-picker-native": ["./packages/client/ui-directory-picker-native/src"],
       // sdk/ folders are role-named without their npm-side sdk/jsonrpc prefixes,
-      // so the generic wildcard cannot map these three package names.
+      // so their names do not match their directories and the generated aliases
+      // below cannot map them; these three stay hand-written.
       "@deepseek-ai/dsh-sdk-client": ["./packages/sdk/client/src"],
       "@deepseek-ai/dsh-sdk-protocol": ["./packages/sdk/protocol/src"],
       "@deepseek-ai/dsh-sdk-jsonrpc-server": ["./packages/sdk/server/src"],
       "@deepseek-ai/dsh-experimental-agent-team": ["./packages/experimental/agent-team/src"],
+      "@deepseek-ai/dsh-experimental-agent-team-profile": ["./packages/experimental/agent-team-profile/src"],
+      "@deepseek-ai/dsh-experimental-agent-team-web-profile": ["./packages/experimental/agent-team-web-profile/src"],
       "@deepseek-ai/dsh-experimental-tool-agent-team": ["./packages/experimental/tool-agent-team/src"],
       "@deepseek-ai/dsh-experimental-webworker-runtime": ["./packages/experimental/webworker-runtime/src"],
       "@deepseek-ai/dsh-experimental-webworker-packer": ["./packages/experimental/webworker-packer/src"],
       "@deepseek-ai/dsh-experimental-inspector": ["./packages/experimental/inspector/src"],
       "@deepseek-ai/dsh-experimental-inspector/client": ["./packages/experimental/inspector/src/client/index.ts"],
       "@deepseek-ai/dsh-util-crypto": ["./packages/util/crypto/src"],
-      "@deepseek-ai/dsh-*": [
-        "./packages/core/*/src",
-        "./packages/prompt/*/src",
-        "./packages/llm/*/src",
-        "./packages/shell/*/src",
-        "./packages/terminal/*/src",
-        "./packages/subprocess/*/src",
-        "./packages/e2b/*/src",
-        "./packages/code-runtime/*/src",
-        "./packages/fs/*/src",
-        "./packages/lsp/*/src",
-        "./packages/skill/*/src",
-        "./packages/compaction/*/src",
-        "./packages/context/*/src",
-        "./packages/goal/*/src",
-        "./packages/feedback/*/src",
-        "./packages/schedule/*/src",
-        "./packages/guard/*/src",
-        "./packages/plan/*/src",
-        "./packages/preset/*/src",
-        "./packages/subagent/*/src",
-        "./packages/jobs/*/src",
-        "./packages/experimental/*/src",
-        "./packages/workflow/*/src",
-        "./packages/webhook/*/src",
-        "./packages/web/*/src",
-        "./packages/attachment/*/src",
-        "./packages/spill/*/src",
-        "./packages/todo/*/src",
-        "./packages/bundle/*/src",
-        "./packages/extensions/*/src",
-        "./packages/sandbox/*/src",
-        "./packages/hooks/*/src",
-        "./packages/session/*/src",
-        "./packages/session-query/*/src",
-        "./packages/settings/*/src",
-        "./packages/credentials/*/src",
-        "./packages/acp/*/src",
-        "./packages/storage/*/src",
-        "./packages/workspace/*/src",
-        "./packages/sdk/*/src",
-        "./packages/interaction/*/src",
-        "./packages/boot/*/src",
-        "./packages/examples/*/src",
-        "./packages/util/*/src",
-        "./packages/mcp/*/src",
-        "./packages/identity/*/src",
-        "./packages/test-support/*/src",
-        "./packages/host/*/src",
-        "./packages/client/*/src"
-      ]
+      // BEGIN generated package aliases — pnpm run gen-tsconfig-paths
+      "@deepseek-ai/dsh-acp": ["./packages/acp/acp/src"],
+      "@deepseek-ai/dsh-acp/invariant": ["./packages/acp/acp/src/invariant.ts"],
+      "@deepseek-ai/dsh-acp-app": ["./packages/bundle/acp-app/src"],
+      "@deepseek-ai/dsh-acp-app/invariant": ["./packages/bundle/acp-app/src/invariant.ts"],
+      "@deepseek-ai/dsh-agent": ["./packages/core/agent/src"],
+      "@deepseek-ai/dsh-agent-default-model": ["./packages/core/agent-default-model/src"],
+      "@deepseek-ai/dsh-agent-default-model/invariant": ["./packages/core/agent-default-model/src/invariant.ts"],
+      "@deepseek-ai/dsh-agent-instructions": ["./packages/context/agent-instructions/src"],
+      "@deepseek-ai/dsh-agent-instructions/invariant": ["./packages/context/agent-instructions/src/invariant.ts"],
+      "@deepseek-ai/dsh-agent-loop": ["./packages/core/agent-loop/src"],
+      "@deepseek-ai/dsh-agent-loop-testkit": ["./packages/test-support/agent-loop-testkit/src"],
+      "@deepseek-ai/dsh-agent-loop-testkit/invariant": ["./packages/test-support/agent-loop-testkit/src/invariant.ts"],
+      "@deepseek-ai/dsh-agent-presets": ["./packages/preset/agent-presets/src"],
+      "@deepseek-ai/dsh-agent-presets/invariant": ["./packages/preset/agent-presets/src/invariant.ts"],
+      "@deepseek-ai/dsh-agent-spine-demo": ["./packages/examples/agent-spine-demo/src"],
+      "@deepseek-ai/dsh-agent-spine-demo/invariant": ["./packages/examples/agent-spine-demo/src/invariant.ts"],
+      "@deepseek-ai/dsh-agent-tool-presentation": ["./packages/core/agent-tool-presentation/src"],
+      "@deepseek-ai/dsh-agent-tool-presentation/invariant": ["./packages/core/agent-tool-presentation/src/invariant.ts"],
+      "@deepseek-ai/dsh-anonymous-user-id": ["./packages/identity/anonymous-user-id/src"],
+      "@deepseek-ai/dsh-anonymous-user-id/invariant": ["./packages/identity/anonymous-user-id/src/invariant.ts"],
+      "@deepseek-ai/dsh-app-boot": ["./packages/boot/app-boot/src"],
+      "@deepseek-ai/dsh-app-boot/invariant": ["./packages/boot/app-boot/src/invariant.ts"],
+      "@deepseek-ai/dsh-atomic-write": ["./packages/util/atomic-write/src"],
+      "@deepseek-ai/dsh-atomic-write/invariant": ["./packages/util/atomic-write/src/invariant.ts"],
+      "@deepseek-ai/dsh-attachment": ["./packages/attachment/attachment/src"],
+      "@deepseek-ai/dsh-attachment/invariant": ["./packages/attachment/attachment/src/invariant.ts"],
+      "@deepseek-ai/dsh-attachment-local": ["./packages/attachment/attachment-local/src"],
+      "@deepseek-ai/dsh-attachment-local/invariant": ["./packages/attachment/attachment-local/src/invariant.ts"],
+      "@deepseek-ai/dsh-authorization": ["./packages/credentials/authorization/src"],
+      "@deepseek-ai/dsh-authorization/invariant": ["./packages/credentials/authorization/src/invariant.ts"],
+      "@deepseek-ai/dsh-base": ["./packages/bundle/base/src"],
+      "@deepseek-ai/dsh-base/invariant": ["./packages/bundle/base/src/invariant.ts"],
+      "@deepseek-ai/dsh-bash-local": ["./packages/shell/bash-local/src"],
+      "@deepseek-ai/dsh-bash-local/invariant": ["./packages/shell/bash-local/src/invariant.ts"],
+      "@deepseek-ai/dsh-bash-sandbox": ["./packages/shell/bash-sandbox/src"],
+      "@deepseek-ai/dsh-bash-sandbox/invariant": ["./packages/shell/bash-sandbox/src/invariant.ts"],
+      "@deepseek-ai/dsh-brand": ["./packages/util/brand/src"],
+      "@deepseek-ai/dsh-brand/invariant": ["./packages/util/brand/src/invariant.ts"],
+      "@deepseek-ai/dsh-cmdline": ["./packages/boot/cmdline/src"],
+      "@deepseek-ai/dsh-cmdline/invariant": ["./packages/boot/cmdline/src/invariant.ts"],
+      "@deepseek-ai/dsh-code-runtime": ["./packages/code-runtime/code-runtime/src"],
+      "@deepseek-ai/dsh-code-runtime/invariant": ["./packages/code-runtime/code-runtime/src/invariant.ts"],
+      "@deepseek-ai/dsh-code-runtime-python": ["./packages/code-runtime/code-runtime-python/src"],
+      "@deepseek-ai/dsh-code-runtime-python/invariant": ["./packages/code-runtime/code-runtime-python/src/invariant.ts"],
+      "@deepseek-ai/dsh-code-runtime-worker-thread": ["./packages/code-runtime/code-runtime-worker-thread/src"],
+      "@deepseek-ai/dsh-code-runtime-worker-thread/invariant": ["./packages/code-runtime/code-runtime-worker-thread/src/invariant.ts"],
+      "@deepseek-ai/dsh-command-compact": ["./packages/compaction/command-compact/src"],
+      "@deepseek-ai/dsh-command-compact/invariant": ["./packages/compaction/command-compact/src/invariant.ts"],
+      "@deepseek-ai/dsh-command-feedback": ["./packages/feedback/command-feedback/src"],
+      "@deepseek-ai/dsh-command-feedback/invariant": ["./packages/feedback/command-feedback/src/invariant.ts"],
+      "@deepseek-ai/dsh-command-goal": ["./packages/goal/command-goal/src"],
+      "@deepseek-ai/dsh-command-goal/invariant": ["./packages/goal/command-goal/src/invariant.ts"],
+      "@deepseek-ai/dsh-commands": ["./packages/interaction/commands/src"],
+      "@deepseek-ai/dsh-commands/invariant": ["./packages/interaction/commands/src/invariant.ts"],
+      "@deepseek-ai/dsh-compaction": ["./packages/compaction/compaction/src"],
+      "@deepseek-ai/dsh-compaction/invariant": ["./packages/compaction/compaction/src/invariant.ts"],
+      "@deepseek-ai/dsh-compaction-basic": ["./packages/compaction/compaction-basic/src"],
+      "@deepseek-ai/dsh-compaction-basic/invariant": ["./packages/compaction/compaction-basic/src/invariant.ts"],
+      "@deepseek-ai/dsh-compaction-tool-result-pruner": ["./packages/compaction/compaction-tool-result-pruner/src"],
+      "@deepseek-ai/dsh-compaction-tool-result-pruner/invariant": ["./packages/compaction/compaction-tool-result-pruner/src/invariant.ts"],
+      "@deepseek-ai/dsh-cordis-host-runner/invariant": ["./packages/extensions/cordis-host-runner/src/invariant.ts"],
+      "@deepseek-ai/dsh-credentials": ["./packages/credentials/credentials/src"],
+      "@deepseek-ai/dsh-credentials/invariant": ["./packages/credentials/credentials/src/invariant.ts"],
+      "@deepseek-ai/dsh-credentials-local": ["./packages/credentials/credentials-local/src"],
+      "@deepseek-ai/dsh-credentials-local/invariant": ["./packages/credentials/credentials-local/src/invariant.ts"],
+      "@deepseek-ai/dsh-deepseek-llm-api-extensions": ["./packages/llm/deepseek-llm-api-extensions/src"],
+      "@deepseek-ai/dsh-deepseek-llm-api-extensions/invariant": ["./packages/llm/deepseek-llm-api-extensions/src/invariant.ts"],
+      "@deepseek-ai/dsh-e2b": ["./packages/e2b/e2b/src"],
+      "@deepseek-ai/dsh-e2b/invariant": ["./packages/e2b/e2b/src/invariant.ts"],
+      "@deepseek-ai/dsh-file-reference": ["./packages/context/file-reference/src"],
+      "@deepseek-ai/dsh-file-reference/invariant": ["./packages/context/file-reference/src/invariant.ts"],
+      "@deepseek-ai/dsh-file-reference-local": ["./packages/context/file-reference-local/src"],
+      "@deepseek-ai/dsh-file-reference-local/invariant": ["./packages/context/file-reference-local/src/invariant.ts"],
+      "@deepseek-ai/dsh-fs": ["./packages/fs/fs/src"],
+      "@deepseek-ai/dsh-fs/invariant": ["./packages/fs/fs/src/invariant.ts"],
+      "@deepseek-ai/dsh-fs-e2b": ["./packages/e2b/fs-e2b/src"],
+      "@deepseek-ai/dsh-fs-e2b/invariant": ["./packages/e2b/fs-e2b/src/invariant.ts"],
+      "@deepseek-ai/dsh-fs-local": ["./packages/fs/fs-local/src"],
+      "@deepseek-ai/dsh-fs-local/invariant": ["./packages/fs/fs-local/src/invariant.ts"],
+      "@deepseek-ai/dsh-fs-observation-policy": ["./packages/fs/fs-observation-policy/src"],
+      "@deepseek-ai/dsh-fs-observation-policy/invariant": ["./packages/fs/fs-observation-policy/src/invariant.ts"],
+      "@deepseek-ai/dsh-fs-sandbox": ["./packages/fs/fs-sandbox/src"],
+      "@deepseek-ai/dsh-fs-sandbox/invariant": ["./packages/fs/fs-sandbox/src/invariant.ts"],
+      "@deepseek-ai/dsh-goal": ["./packages/goal/goal/src"],
+      "@deepseek-ai/dsh-goal/invariant": ["./packages/goal/goal/src/invariant.ts"],
+      "@deepseek-ai/dsh-goal-round-driver": ["./packages/goal/goal-round-driver/src"],
+      "@deepseek-ai/dsh-goal-round-driver/invariant": ["./packages/goal/goal-round-driver/src/invariant.ts"],
+      "@deepseek-ai/dsh-headless": ["./packages/bundle/headless/src"],
+      "@deepseek-ai/dsh-headless/invariant": ["./packages/bundle/headless/src/invariant.ts"],
+      "@deepseek-ai/dsh-home-paths": ["./packages/util/home-paths/src"],
+      "@deepseek-ai/dsh-home-paths/invariant": ["./packages/util/home-paths/src/invariant.ts"],
+      "@deepseek-ai/dsh-hook-protocol": ["./packages/hooks/hook-protocol/src"],
+      "@deepseek-ai/dsh-hook-protocol/invariant": ["./packages/hooks/hook-protocol/src/invariant.ts"],
+      "@deepseek-ai/dsh-hooks-claude-code": ["./packages/hooks/hooks-claude-code/src"],
+      "@deepseek-ai/dsh-hooks-claude-code/invariant": ["./packages/hooks/hooks-claude-code/src/invariant.ts"],
+      "@deepseek-ai/dsh-hooks-codex": ["./packages/hooks/hooks-codex/src"],
+      "@deepseek-ai/dsh-hooks-codex/invariant": ["./packages/hooks/hooks-codex/src/invariant.ts"],
+      "@deepseek-ai/dsh-invariants/invariant": ["./packages/runtime-diagnostics/invariants/src/invariant.ts"],
+      "@deepseek-ai/dsh-jobs": ["./packages/jobs/jobs/src"],
+      "@deepseek-ai/dsh-jobs/invariant": ["./packages/jobs/jobs/src/invariant.ts"],
+      "@deepseek-ai/dsh-jobs-local": ["./packages/jobs/jobs-local/src"],
+      "@deepseek-ai/dsh-jobs-local/invariant": ["./packages/jobs/jobs-local/src/invariant.ts"],
+      "@deepseek-ai/dsh-launch-environment": ["./packages/util/launch-environment/src"],
+      "@deepseek-ai/dsh-launch-environment/invariant": ["./packages/util/launch-environment/src/invariant.ts"],
+      "@deepseek-ai/dsh-llm": ["./packages/llm/llm/src"],
+      "@deepseek-ai/dsh-llm/invariant": ["./packages/llm/llm/src/invariant.ts"],
+      "@deepseek-ai/dsh-llm-deepseek": ["./packages/llm/llm-deepseek/src"],
+      "@deepseek-ai/dsh-llm-deepseek/invariant": ["./packages/llm/llm-deepseek/src/invariant.ts"],
+      "@deepseek-ai/dsh-llm-mock-server": ["./packages/test-support/llm-mock-server/src"],
+      "@deepseek-ai/dsh-llm-mock-server/invariant": ["./packages/test-support/llm-mock-server/src/invariant.ts"],
+      "@deepseek-ai/dsh-llm-pi-ai": ["./packages/llm/llm-pi-ai/src"],
+      "@deepseek-ai/dsh-llm-pi-ai/invariant": ["./packages/llm/llm-pi-ai/src/invariant.ts"],
+      "@deepseek-ai/dsh-llm-replay": ["./packages/test-support/llm-replay/src"],
+      "@deepseek-ai/dsh-llm-replay/invariant": ["./packages/test-support/llm-replay/src/invariant.ts"],
+      "@deepseek-ai/dsh-llm-retry": ["./packages/llm/llm-retry/src"],
+      "@deepseek-ai/dsh-llm-retry/invariant": ["./packages/llm/llm-retry/src/invariant.ts"],
+      "@deepseek-ai/dsh-loader-smoke": ["./packages/test-support/loader-smoke/src"],
+      "@deepseek-ai/dsh-loader-smoke/invariant": ["./packages/test-support/loader-smoke/src/invariant.ts"],
+      "@deepseek-ai/dsh-lsp": ["./packages/lsp/lsp/src"],
+      "@deepseek-ai/dsh-lsp/invariant": ["./packages/lsp/lsp/src/invariant.ts"],
+      "@deepseek-ai/dsh-lsp-stdio": ["./packages/lsp/lsp-stdio/src"],
+      "@deepseek-ai/dsh-lsp-stdio/invariant": ["./packages/lsp/lsp-stdio/src/invariant.ts"],
+      "@deepseek-ai/dsh-mcp-client": ["./packages/mcp/mcp-client/src"],
+      "@deepseek-ai/dsh-mcp-client/invariant": ["./packages/mcp/mcp-client/src/invariant.ts"],
+      "@deepseek-ai/dsh-message-feedback": ["./packages/feedback/message-feedback/src"],
+      "@deepseek-ai/dsh-message-feedback/invariant": ["./packages/feedback/message-feedback/src/invariant.ts"],
+      "@deepseek-ai/dsh-native-command": ["./packages/util/native-command/src"],
+      "@deepseek-ai/dsh-native-command/invariant": ["./packages/util/native-command/src/invariant.ts"],
+      "@deepseek-ai/dsh-output-retention": ["./packages/util/output-retention/src"],
+      "@deepseek-ai/dsh-output-retention/invariant": ["./packages/util/output-retention/src/invariant.ts"],
+      "@deepseek-ai/dsh-permission-presets": ["./packages/interaction/permission-presets/src"],
+      "@deepseek-ai/dsh-permission-presets/invariant": ["./packages/interaction/permission-presets/src/invariant.ts"],
+      "@deepseek-ai/dsh-persona": ["./packages/preset/persona/src"],
+      "@deepseek-ai/dsh-persona/invariant": ["./packages/preset/persona/src/invariant.ts"],
+      "@deepseek-ai/dsh-plan-mode": ["./packages/plan/plan-mode/src"],
+      "@deepseek-ai/dsh-plan-mode/invariant": ["./packages/plan/plan-mode/src/invariant.ts"],
+      "@deepseek-ai/dsh-plugin-package-inventory-deepseek": ["./packages/llm/plugin-package-inventory-deepseek/src"],
+      "@deepseek-ai/dsh-plugin-package-inventory-deepseek/invariant": ["./packages/llm/plugin-package-inventory-deepseek/src/invariant.ts"],
+      "@deepseek-ai/dsh-pwsh-local/invariant": ["./packages/shell/pwsh-local/src/invariant.ts"],
+      "@deepseek-ai/dsh-pwsh-sandbox": ["./packages/shell/pwsh-sandbox/src"],
+      "@deepseek-ai/dsh-pwsh-sandbox/invariant": ["./packages/shell/pwsh-sandbox/src/invariant.ts"],
+      "@deepseek-ai/dsh-repeat-tool-reminder": ["./packages/guard/repeat-tool-reminder/src"],
+      "@deepseek-ai/dsh-repeat-tool-reminder/invariant": ["./packages/guard/repeat-tool-reminder/src/invariant.ts"],
+      "@deepseek-ai/dsh-sandbox": ["./packages/sandbox/sandbox/src"],
+      "@deepseek-ai/dsh-sandbox/invariant": ["./packages/sandbox/sandbox/src/invariant.ts"],
+      "@deepseek-ai/dsh-sandbox-local": ["./packages/sandbox/sandbox-local/src"],
+      "@deepseek-ai/dsh-sandbox-local/invariant": ["./packages/sandbox/sandbox-local/src/invariant.ts"],
+      "@deepseek-ai/dsh-sandbox-policy": ["./packages/sandbox/sandbox-policy/src"],
+      "@deepseek-ai/dsh-sandbox-policy/invariant": ["./packages/sandbox/sandbox-policy/src/invariant.ts"],
+      "@deepseek-ai/dsh-sandbox-windows-acl": ["./packages/sandbox/sandbox-windows-acl/src"],
+      "@deepseek-ai/dsh-sandbox-windows-acl/invariant": ["./packages/sandbox/sandbox-windows-acl/src/invariant.ts"],
+      "@deepseek-ai/dsh-schedule": ["./packages/schedule/schedule/src"],
+      "@deepseek-ai/dsh-schedule/invariant": ["./packages/schedule/schedule/src/invariant.ts"],
+      "@deepseek-ai/dsh-scope": ["./packages/core/scope/src"],
+      "@deepseek-ai/dsh-sdk-app": ["./packages/bundle/sdk-app/src"],
+      "@deepseek-ai/dsh-sdk-app/invariant": ["./packages/bundle/sdk-app/src/invariant.ts"],
+      "@deepseek-ai/dsh-sdk-minimal": ["./packages/bundle/sdk-minimal/src"],
+      "@deepseek-ai/dsh-sdk-minimal/invariant": ["./packages/bundle/sdk-minimal/src/invariant.ts"],
+      "@deepseek-ai/dsh-session": ["./packages/core/session/src"],
+      "@deepseek-ai/dsh-session-checkpoint-policy": ["./packages/session/session-checkpoint-policy/src"],
+      "@deepseek-ai/dsh-session-checkpoint-policy/invariant": ["./packages/session/session-checkpoint-policy/src/invariant.ts"],
+      "@deepseek-ai/dsh-session-log-deepseek": ["./packages/session/session-log-deepseek/src"],
+      "@deepseek-ai/dsh-session-log-deepseek/invariant": ["./packages/session/session-log-deepseek/src/invariant.ts"],
+      "@deepseek-ai/dsh-session-log-export": ["./packages/session-query/session-log-export/src"],
+      "@deepseek-ai/dsh-session-log-export/invariant": ["./packages/session-query/session-log-export/src/invariant.ts"],
+      "@deepseek-ai/dsh-session-persistence": ["./packages/session/session-persistence/src"],
+      "@deepseek-ai/dsh-session-persistence/invariant": ["./packages/session/session-persistence/src/invariant.ts"],
+      "@deepseek-ai/dsh-session-persistence-jsonl": ["./packages/session/session-persistence-jsonl/src"],
+      "@deepseek-ai/dsh-session-persistence-jsonl/invariant": ["./packages/session/session-persistence-jsonl/src/invariant.ts"],
+      "@deepseek-ai/dsh-session-persistence-sqlite": ["./packages/session/session-persistence-sqlite/src"],
+      "@deepseek-ai/dsh-session-persistence-sqlite/invariant": ["./packages/session/session-persistence-sqlite/src/invariant.ts"],
+      "@deepseek-ai/dsh-session-projection": ["./packages/session/session-projection/src"],
+      "@deepseek-ai/dsh-session-projection/invariant": ["./packages/session/session-projection/src/invariant.ts"],
+      "@deepseek-ai/dsh-session-projection-cache": ["./packages/session/session-projection-cache/src"],
+      "@deepseek-ai/dsh-session-projection-cache/invariant": ["./packages/session/session-projection-cache/src/invariant.ts"],
+      "@deepseek-ai/dsh-session-query": ["./packages/session-query/session-query/src"],
+      "@deepseek-ai/dsh-session-query/invariant": ["./packages/session-query/session-query/src/invariant.ts"],
+      "@deepseek-ai/dsh-session-query-sqlite": ["./packages/session-query/session-query-sqlite/src"],
+      "@deepseek-ai/dsh-session-query-sqlite/invariant": ["./packages/session-query/session-query-sqlite/src/invariant.ts"],
+      "@deepseek-ai/dsh-session-reference": ["./packages/context/session-reference/src"],
+      "@deepseek-ai/dsh-session-reference/invariant": ["./packages/context/session-reference/src/invariant.ts"],
+      "@deepseek-ai/dsh-session-snapshot": ["./packages/test-support/session-snapshot/src"],
+      "@deepseek-ai/dsh-session-snapshot/invariant": ["./packages/test-support/session-snapshot/src/invariant.ts"],
+      "@deepseek-ai/dsh-session-stats": ["./packages/session/session-stats/src"],
+      "@deepseek-ai/dsh-session-stats/invariant": ["./packages/session/session-stats/src/invariant.ts"],
+      "@deepseek-ai/dsh-session-telemetry": ["./packages/session/session-telemetry/src"],
+      "@deepseek-ai/dsh-session-telemetry/invariant": ["./packages/session/session-telemetry/src/invariant.ts"],
+      "@deepseek-ai/dsh-session-telemetry-otel": ["./packages/session/session-telemetry-otel/src"],
+      "@deepseek-ai/dsh-session-telemetry-otel/invariant": ["./packages/session/session-telemetry-otel/src/invariant.ts"],
+      "@deepseek-ai/dsh-session-title": ["./packages/session/session-title/src"],
+      "@deepseek-ai/dsh-session-title/invariant": ["./packages/session/session-title/src/invariant.ts"],
+      "@deepseek-ai/dsh-session-title-all-prompts-llm": ["./packages/session/session-title-all-prompts-llm/src"],
+      "@deepseek-ai/dsh-session-title-all-prompts-llm/invariant": ["./packages/session/session-title-all-prompts-llm/src/invariant.ts"],
+      "@deepseek-ai/dsh-session-title-first-prompt-llm": ["./packages/session/session-title-first-prompt-llm/src"],
+      "@deepseek-ai/dsh-session-title-first-prompt-llm/invariant": ["./packages/session/session-title-first-prompt-llm/src/invariant.ts"],
+      "@deepseek-ai/dsh-session-title-llm": ["./packages/session/session-title-llm/src"],
+      "@deepseek-ai/dsh-session-title-llm/invariant": ["./packages/session/session-title-llm/src/invariant.ts"],
+      "@deepseek-ai/dsh-settings": ["./packages/settings/settings/src"],
+      "@deepseek-ai/dsh-settings/invariant": ["./packages/settings/settings/src/invariant.ts"],
+      "@deepseek-ai/dsh-settings-file": ["./packages/settings/settings-file/src"],
+      "@deepseek-ai/dsh-settings-file/invariant": ["./packages/settings/settings-file/src/invariant.ts"],
+      "@deepseek-ai/dsh-shell": ["./packages/shell/shell/src"],
+      "@deepseek-ai/dsh-shell/invariant": ["./packages/shell/shell/src/invariant.ts"],
+      "@deepseek-ai/dsh-shell-env/invariant": ["./packages/shell/shell-env/src/invariant.ts"],
+      "@deepseek-ai/dsh-skill": ["./packages/skill/skill/src"],
+      "@deepseek-ai/dsh-skill/invariant": ["./packages/skill/skill/src/invariant.ts"],
+      "@deepseek-ai/dsh-skill-badge": ["./packages/skill/skill-badge/src"],
+      "@deepseek-ai/dsh-skill-badge/invariant": ["./packages/skill/skill-badge/src/invariant.ts"],
+      "@deepseek-ai/dsh-skill-filesystem": ["./packages/skill/skill-filesystem/src"],
+      "@deepseek-ai/dsh-skill-filesystem/invariant": ["./packages/skill/skill-filesystem/src/invariant.ts"],
+      "@deepseek-ai/dsh-spill": ["./packages/spill/spill/src"],
+      "@deepseek-ai/dsh-spill/invariant": ["./packages/spill/spill/src/invariant.ts"],
+      "@deepseek-ai/dsh-spill-local": ["./packages/spill/spill-local/src"],
+      "@deepseek-ai/dsh-spill-local/invariant": ["./packages/spill/spill-local/src/invariant.ts"],
+      "@deepseek-ai/dsh-spill-policy": ["./packages/spill/spill-policy/src"],
+      "@deepseek-ai/dsh-spill-policy/invariant": ["./packages/spill/spill-policy/src/invariant.ts"],
+      "@deepseek-ai/dsh-storage": ["./packages/storage/storage/src"],
+      "@deepseek-ai/dsh-storage/invariant": ["./packages/storage/storage/src/invariant.ts"],
+      "@deepseek-ai/dsh-storage-domain": ["./packages/storage/storage-domain/src"],
+      "@deepseek-ai/dsh-storage-domain/invariant": ["./packages/storage/storage-domain/src/invariant.ts"],
+      "@deepseek-ai/dsh-storage-json": ["./packages/storage/storage-json/src"],
+      "@deepseek-ai/dsh-storage-json/invariant": ["./packages/storage/storage-json/src/invariant.ts"],
+      "@deepseek-ai/dsh-storage-sqlite": ["./packages/storage/storage-sqlite/src"],
+      "@deepseek-ai/dsh-storage-sqlite/invariant": ["./packages/storage/storage-sqlite/src/invariant.ts"],
+      "@deepseek-ai/dsh-subagent": ["./packages/subagent/subagent/src"],
+      "@deepseek-ai/dsh-subagent/invariant": ["./packages/subagent/subagent/src/invariant.ts"],
+      "@deepseek-ai/dsh-subagent-acp": ["./packages/subagent/subagent-acp/src"],
+      "@deepseek-ai/dsh-subagent-acp/invariant": ["./packages/subagent/subagent-acp/src/invariant.ts"],
+      "@deepseek-ai/dsh-subagent-claude-code": ["./packages/subagent/subagent-claude-code/src"],
+      "@deepseek-ai/dsh-subagent-claude-code/invariant": ["./packages/subagent/subagent-claude-code/src/invariant.ts"],
+      "@deepseek-ai/dsh-subagent-codex": ["./packages/subagent/subagent-codex/src"],
+      "@deepseek-ai/dsh-subagent-codex/invariant": ["./packages/subagent/subagent-codex/src/invariant.ts"],
+      "@deepseek-ai/dsh-subagent-dsh-sdk": ["./packages/subagent/subagent-dsh-sdk/src"],
+      "@deepseek-ai/dsh-subagent-dsh-sdk/invariant": ["./packages/subagent/subagent-dsh-sdk/src/invariant.ts"],
+      "@deepseek-ai/dsh-subagent-fork-in-process": ["./packages/subagent/subagent-fork-in-process/src"],
+      "@deepseek-ai/dsh-subagent-fork-in-process/invariant": ["./packages/subagent/subagent-fork-in-process/src/invariant.ts"],
+      "@deepseek-ai/dsh-subagent-in-process-driver": ["./packages/subagent/subagent-in-process-driver/src"],
+      "@deepseek-ai/dsh-subagent-in-process-driver/invariant": ["./packages/subagent/subagent-in-process-driver/src/invariant.ts"],
+      "@deepseek-ai/dsh-subagent-spawn-in-process": ["./packages/subagent/subagent-spawn-in-process/src"],
+      "@deepseek-ai/dsh-subagent-spawn-in-process/invariant": ["./packages/subagent/subagent-spawn-in-process/src/invariant.ts"],
+      "@deepseek-ai/dsh-subprocess": ["./packages/subprocess/subprocess/src"],
+      "@deepseek-ai/dsh-subprocess/invariant": ["./packages/subprocess/subprocess/src/invariant.ts"],
+      "@deepseek-ai/dsh-subprocess-e2b": ["./packages/e2b/subprocess-e2b/src"],
+      "@deepseek-ai/dsh-subprocess-e2b/invariant": ["./packages/e2b/subprocess-e2b/src/invariant.ts"],
+      "@deepseek-ai/dsh-subprocess-local": ["./packages/subprocess/subprocess-local/src"],
+      "@deepseek-ai/dsh-subprocess-local/invariant": ["./packages/subprocess/subprocess-local/src/invariant.ts"],
+      "@deepseek-ai/dsh-system-prompt": ["./packages/core/system-prompt/src"],
+      "@deepseek-ai/dsh-system-prompt/invariant": ["./packages/core/system-prompt/src/invariant.ts"],
+      "@deepseek-ai/dsh-terminal": ["./packages/terminal/terminal/src"],
+      "@deepseek-ai/dsh-terminal/invariant": ["./packages/terminal/terminal/src/invariant.ts"],
+      "@deepseek-ai/dsh-terminal-bash": ["./packages/terminal/terminal-bash/src"],
+      "@deepseek-ai/dsh-terminal-bash/invariant": ["./packages/terminal/terminal-bash/src/invariant.ts"],
+      "@deepseek-ai/dsh-time-context": ["./packages/context/time-context/src"],
+      "@deepseek-ai/dsh-time-context/invariant": ["./packages/context/time-context/src/invariant.ts"],
+      "@deepseek-ai/dsh-timeout": ["./packages/util/timeout/src"],
+      "@deepseek-ai/dsh-timeout/invariant": ["./packages/util/timeout/src/invariant.ts"],
+      "@deepseek-ai/dsh-tmux-context": ["./packages/context/tmux-context/src"],
+      "@deepseek-ai/dsh-tmux-context/invariant": ["./packages/context/tmux-context/src/invariant.ts"],
+      "@deepseek-ai/dsh-token-meter": ["./packages/llm/token-meter/src"],
+      "@deepseek-ai/dsh-token-meter/invariant": ["./packages/llm/token-meter/src/invariant.ts"],
+      "@deepseek-ai/dsh-tool-ask-user": ["./packages/interaction/tool-ask-user/src"],
+      "@deepseek-ai/dsh-tool-ask-user/invariant": ["./packages/interaction/tool-ask-user/src/invariant.ts"],
+      "@deepseek-ai/dsh-tool-bash": ["./packages/shell/tool-bash/src"],
+      "@deepseek-ai/dsh-tool-bash/invariant": ["./packages/shell/tool-bash/src/invariant.ts"],
+      "@deepseek-ai/dsh-tool-bash-persistent": ["./packages/shell/tool-bash-persistent/src"],
+      "@deepseek-ai/dsh-tool-bash-persistent/invariant": ["./packages/shell/tool-bash-persistent/src/invariant.ts"],
+      "@deepseek-ai/dsh-tool-cordis": ["./packages/extensions/tool-cordis/src"],
+      "@deepseek-ai/dsh-tool-cordis/invariant": ["./packages/extensions/tool-cordis/src/invariant.ts"],
+      "@deepseek-ai/dsh-tool-fs": ["./packages/fs/tool-fs/src"],
+      "@deepseek-ai/dsh-tool-fs/invariant": ["./packages/fs/tool-fs/src/invariant.ts"],
+      "@deepseek-ai/dsh-tool-fs-search": ["./packages/fs/tool-fs-search/src"],
+      "@deepseek-ai/dsh-tool-fs-search/invariant": ["./packages/fs/tool-fs-search/src/invariant.ts"],
+      "@deepseek-ai/dsh-tool-goal": ["./packages/goal/tool-goal/src"],
+      "@deepseek-ai/dsh-tool-goal/invariant": ["./packages/goal/tool-goal/src/invariant.ts"],
+      "@deepseek-ai/dsh-tool-jobs": ["./packages/jobs/tool-jobs/src"],
+      "@deepseek-ai/dsh-tool-jobs/invariant": ["./packages/jobs/tool-jobs/src/invariant.ts"],
+      "@deepseek-ai/dsh-tool-lsp": ["./packages/lsp/tool-lsp/src"],
+      "@deepseek-ai/dsh-tool-lsp/invariant": ["./packages/lsp/tool-lsp/src/invariant.ts"],
+      "@deepseek-ai/dsh-tool-pwsh/invariant": ["./packages/shell/tool-pwsh/src/invariant.ts"],
+      "@deepseek-ai/dsh-tool-pwsh-persistent": ["./packages/shell/tool-pwsh-persistent/src"],
+      "@deepseek-ai/dsh-tool-pwsh-persistent/invariant": ["./packages/shell/tool-pwsh-persistent/src/invariant.ts"],
+      "@deepseek-ai/dsh-tool-ralph": ["./packages/workflow/tool-ralph/src"],
+      "@deepseek-ai/dsh-tool-ralph/invariant": ["./packages/workflow/tool-ralph/src/invariant.ts"],
+      "@deepseek-ai/dsh-tool-session-query": ["./packages/session-query/tool-session-query/src"],
+      "@deepseek-ai/dsh-tool-session-query/invariant": ["./packages/session-query/tool-session-query/src/invariant.ts"],
+      "@deepseek-ai/dsh-tool-skill": ["./packages/skill/tool-skill/src"],
+      "@deepseek-ai/dsh-tool-skill/invariant": ["./packages/skill/tool-skill/src/invariant.ts"],
+      "@deepseek-ai/dsh-tool-str-replace-editor": ["./packages/fs/tool-str-replace-editor/src"],
+      "@deepseek-ai/dsh-tool-str-replace-editor/invariant": ["./packages/fs/tool-str-replace-editor/src/invariant.ts"],
+      "@deepseek-ai/dsh-tool-subagent": ["./packages/subagent/tool-subagent/src"],
+      "@deepseek-ai/dsh-tool-subagent/invariant": ["./packages/subagent/tool-subagent/src/invariant.ts"],
+      "@deepseek-ai/dsh-tool-subagent-control": ["./packages/subagent/tool-subagent-control/src"],
+      "@deepseek-ai/dsh-tool-subagent-control/invariant": ["./packages/subagent/tool-subagent-control/src/invariant.ts"],
+      "@deepseek-ai/dsh-tool-subagent-report": ["./packages/subagent/tool-subagent-report/src"],
+      "@deepseek-ai/dsh-tool-subagent-report/invariant": ["./packages/subagent/tool-subagent-report/src/invariant.ts"],
+      "@deepseek-ai/dsh-tool-terminal": ["./packages/terminal/tool-terminal/src"],
+      "@deepseek-ai/dsh-tool-terminal/invariant": ["./packages/terminal/tool-terminal/src/invariant.ts"],
+      "@deepseek-ai/dsh-tool-todo": ["./packages/todo/tool-todo/src"],
+      "@deepseek-ai/dsh-tool-todo/invariant": ["./packages/todo/tool-todo/src/invariant.ts"],
+      "@deepseek-ai/dsh-tool-web": ["./packages/web/tool-web/src"],
+      "@deepseek-ai/dsh-tool-web/invariant": ["./packages/web/tool-web/src/invariant.ts"],
+      "@deepseek-ai/dsh-tool-workflow": ["./packages/workflow/tool-workflow/src"],
+      "@deepseek-ai/dsh-tool-workflow/invariant": ["./packages/workflow/tool-workflow/src/invariant.ts"],
+      "@deepseek-ai/dsh-tools": ["./packages/core/tools/src"],
+      "@deepseek-ai/dsh-tools/invariant": ["./packages/core/tools/src/invariant.ts"],
+      "@deepseek-ai/dsh-user-approval": ["./packages/interaction/user-approval/src"],
+      "@deepseek-ai/dsh-user-approval/invariant": ["./packages/interaction/user-approval/src/invariant.ts"],
+      "@deepseek-ai/dsh-user-questions": ["./packages/interaction/user-questions/src"],
+      "@deepseek-ai/dsh-user-questions/invariant": ["./packages/interaction/user-questions/src/invariant.ts"],
+      "@deepseek-ai/dsh-web": ["./packages/web/web/src"],
+      "@deepseek-ai/dsh-web/invariant": ["./packages/web/web/src/invariant.ts"],
+      "@deepseek-ai/dsh-web-app": ["./packages/bundle/web-app/src"],
+      "@deepseek-ai/dsh-web-app/invariant": ["./packages/bundle/web-app/src/invariant.ts"],
+      "@deepseek-ai/dsh-web-fetch-http": ["./packages/web/web-fetch-http/src"],
+      "@deepseek-ai/dsh-web-fetch-http/invariant": ["./packages/web/web-fetch-http/src/invariant.ts"],
+      "@deepseek-ai/dsh-web-search-deepseek": ["./packages/web/web-search-deepseek/src"],
+      "@deepseek-ai/dsh-web-search-deepseek/invariant": ["./packages/web/web-search-deepseek/src/invariant.ts"],
+      "@deepseek-ai/dsh-web-search-exa": ["./packages/web/web-search-exa/src"],
+      "@deepseek-ai/dsh-web-search-exa/invariant": ["./packages/web/web-search-exa/src/invariant.ts"],
+      "@deepseek-ai/dsh-web-search-perplexity": ["./packages/web/web-search-perplexity/src"],
+      "@deepseek-ai/dsh-web-search-perplexity/invariant": ["./packages/web/web-search-perplexity/src/invariant.ts"],
+      "@deepseek-ai/dsh-webhook": ["./packages/webhook/webhook/src"],
+      "@deepseek-ai/dsh-webhook/invariant": ["./packages/webhook/webhook/src/invariant.ts"],
+      "@deepseek-ai/dsh-webhook-github": ["./packages/webhook/webhook-github/src"],
+      "@deepseek-ai/dsh-webhook-github/invariant": ["./packages/webhook/webhook-github/src/invariant.ts"],
+      "@deepseek-ai/dsh-win32-process": ["./packages/subprocess/win32-process/src"],
+      "@deepseek-ai/dsh-win32-process/invariant": ["./packages/subprocess/win32-process/src/invariant.ts"],
+      "@deepseek-ai/dsh-workflow": ["./packages/workflow/workflow/src"],
+      "@deepseek-ai/dsh-workflow/invariant": ["./packages/workflow/workflow/src/invariant.ts"],
+      "@deepseek-ai/dsh-workflow-worker-thread": ["./packages/workflow/workflow-worker-thread/src"],
+      "@deepseek-ai/dsh-workflow-worker-thread/invariant": ["./packages/workflow/workflow-worker-thread/src/invariant.ts"],
+      "@deepseek-ai/dsh-workspace": ["./packages/workspace/workspace/src"],
+      "@deepseek-ai/dsh-workspace/invariant": ["./packages/workspace/workspace/src/invariant.ts"]
+      // END generated package aliases
     }
   }
 }