Merge remote-tracking branch 'origin/master' into mergebot/pr1667

2026-08-06 11:53:33 +08:00
parent e5810d450e 8711a08247
commit 53293210e6
100 changed files with 1065 additions and 837 deletions
@@ -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/ui-conversation/README.md
-README.md: f2b0d9bde6ec0ba0066a61338ba2da2a333801b7
-README.zh.md: 3cb344938f703f920624cfccf205af320e970786
+README.md: b262c4f89ebcfb8148a0c9a579efe18c2bd4f7a9
+README.zh.md: 5a333e84000893040ec26f7c10dbb32cb3e064b7
@@ -32,9 +32,9 @@ The chat flow projects consecutive model-retry nodes across retry turns into one

 A `grep`/`glob` call declaring the `search` render intent renders its result inline, at the same render sites, through ui-primitives' `SearchBlock` — grep's matches grouped by file (each a collapsible header of `lineNumber: line` rows), glob's flat path list. `contract/search-card-model.ts` is the single derivation from the snapshot's `resultView`; unlike the terminal card it reads no `callView`, since a search has no matches or paths before `execute`, so a running search shows its summary alone. It yields null — the generic path — for any non-search result view, a `card` or `kind` this client version does not compile, and (because those ride the untrusted wire frame) a known kind whose `files`/`paths` is malformed. The keyed `SearchRow`, registered under both `grep` and `glob` since the derived `kind` decides the shape, composes the shared `ToolRow`, feeding the card as ToolRow's `search` body, so it is the row's collapsed-by-default expanded card; the render-site fallback routes it the same way. Both cap at `CHAT_SEARCH_MAX_LINES` (8) against the panel's 16. A capped search drops rows from the card, but the locator to the rest — grep/glob's `Full … stored at …` footer — lives only in the result text, so the derivation surfaces that as a recovery footer below the card when (and only when) the result was truncated; a settled call with no card at all (an errored search, a nested `run_code` sub-dispatch, a legacy generic result) surfaces its flattened result text through ToolRow's Output section so nothing is lost behind a bare summary ([decision](../../../.agents/notes/implemented/feature/2026-07-30-web-search-card.md)).

-Tool rows use the keyed, session-scoped `'conversation.chat.toolview'` slot; its render site dispatches via `entryKey: toolName` with `GenericToolCard` as the call-site fallback. The owner payload is the uniform `ToolRowOwnerProps` (`callId`/`toolName`/`block`/`openFile`), and `ToolRowProps` composes it with the session standard kit. A registrant is a plain plugin: `ctx.slots.register({ name: 'conversation.chat.toolview', key: '<tool>', inject? }, Row)` with `inject: ['slots', 'conversation']` as the load-order seam. Trajectory and waterfall toolview slots share this shape and use their own render sites; RendersCheck rejects a declaration nobody renders.
+Tool rows use the keyed, session-scoped `'conversation.chat.toolview'` slot; its render site dispatches via `entryKey: toolName` with `GenericToolCard` as the call-site fallback. The owner payload is the uniform `ToolRowOwnerProps` (`callId`/`toolName`/`block`/`openFile`), and `ToolRowProps` composes it with the session standard kit. A registrant is a plain plugin with only the slot service edge: `ctx.slots.inject('conversation.chat.toolview', () => ctx.slots.register({ name: 'conversation.chat.toolview', key: '<tool>', inject? }, Row))`. The declaration is the activation and reload dependency; `ConversationService` is required only by registrations that call its actions. Trajectory and waterfall toolview slots share this shape and use their own render sites; RendersCheck rejects a declaration nobody renders.

-The todo surfaces are two registrations over that shape, both plain registrant plugins with `inject: ['slots', 'conversation']`. `TodoRow` takes the `'conversation.chat.toolview'` key `todo_write` and summarizes what the call attempted (`<done>/<total> 已完成 · <active item>` parsed from its args, falling back to the generic summary on malformed or wrongly-shaped model JSON, and keeping the generic dot for non-ok execution states so a cancelled call never reads as a completed update). `TodoDock` takes the `'conversation.input.dock'` list slot at `order: 0` — before Goal and Queue — and is the plan strip: it reads the host-computed `todos` projection via `useProjection` (standing plan: latest `todo/write` with no later `turn/start`) and renders `TodoPanel`, which takes the plain list, hides itself while the list is empty, and starts collapsed as a header of title plus `"<done>/<total> tasks · <n> in progress"` (status glyphs are the figma check / progress / dashed-pending set). The dock adapter owns the selection so the panel stays a pure function of its props; the standing list lives here rather than in the row so the row stays one line. Anything the input-zone composer chain hides (a `conversation.composer` takeover such as ui-question's) hides the whole dock, this strip included.
+The todo surfaces are two registrations over that shape, both using slot declaration injection without a `ConversationService` edge. `TodoRow` takes the `'conversation.chat.toolview'` key `todo_write` and summarizes what the call attempted (`<done>/<total> 已完成 · <active item>` parsed from its args, falling back to the generic summary on malformed or wrongly-shaped model JSON, and keeping the generic dot for non-ok execution states so a cancelled call never reads as a completed update). `TodoDock` takes the `'conversation.input.dock'` list slot at `order: 0` — before Goal and Queue — and is the plan strip: it reads the host-computed `todos` projection via `useProjection` (standing plan: latest `todo/write` with no later `turn/start`) and renders `TodoPanel`, which takes the plain list, hides itself while the list is empty, and starts collapsed as a header of title plus `"<done>/<total> tasks · <n> in progress"` (status glyphs are the figma check / progress / dashed-pending set). The dock adapter owns the selection so the panel stays a pure function of its props; the standing list lives here rather than in the row so the row stays one line. Anything the input-zone composer chain hides (a `conversation.composer` takeover such as ui-question's) hides the whole dock, this strip included.

 `QueueDock` is the terminal input-dock entry at `order: 20`. It hides while empty, renders one pending row directly, and defaults two or more rows to a collapsed `"<n> 条排队消息"` header whose button expands or collapses the complete list. The header exposes `aria-expanded` and `aria-controls`; the expanded list scrolls within a 180px height bound. An active edit or mutation keeps its rows visible, and emptying the queue restores the collapsed default for the next queue. Each visible ordinary-session row remains a single-line preview with its exact-occurrence edit, delete, and strict-steer actions; addressed subagents retain the rows as a read-only projection because their continuation transport does not expose queue mutation. If strict steer loses to a closed window, the original occurrence remains queued for normal delivery; if the driver already claimed it, normal delivery is already underway. Neither converged race displays a failure, while transport and unknown failures do.

@@ -30,11 +30,11 @@ Think 行默认保持折叠，并在不展开思维链的情况下暴露实时

 声明 `search` 渲染意图的 `grep`／`glob` 调用，会在同样的渲染点上通过 ui-primitives 的 `SearchBlock` 内联渲染其结果——grep 的匹配按文件分组（每个是一个可折叠的头，下辖 `lineNumber: line` 行），glob 是扁平路径列表。`contract/search-card-model.ts` 是从快照的 `resultView` 推导的唯一位置；与终端卡片不同，它不读 `callView`，因为搜索在 `execute` 前没有匹配或路径，所以运行中的搜索只显示摘要。对任何非搜索的结果视图、当前客户端版本无法编译的 `card` 或 `kind`、以及（因为这些都与不可信的 wire 帧同行）一个 `files`／`paths` 格式错误的已知 kind，它都返回 null，落回通用路径。键控的 `SearchRow` 因推导出的 `kind` 决定形态而同时注册在 `grep` 与 `glob` 下，组合共享的 `ToolRow`，把卡片作为 ToolRow 的 `search` body 传入，因此它是该行默认折叠的展开卡片；渲染点兜底行以同样方式渲染它。两者上限都是 `CHAT_SEARCH_MAX_LINES`（8），面板为 16。被截断的搜索会从卡片里丢掉一些行，但通往其余部分的定位符——grep/glob 的 `Full … stored at …` 脚注——只存在于结果文本里，因此推导在（且仅在）结果被截断时把它作为恢复脚注画在卡片下方；一个完全没有卡片的已结算调用（出错的搜索、嵌套 `run_code` 子派发、旧日志的 generic 结果）则经 ToolRow 的 Output 区呈现其压平后的结果文本，从而不让任何内容丢失在一个光秃秃的摘要之后（[决策](../../../.agents/notes/implemented/feature/2026-07-30-web-search-card.md)）。

-工具行使用键控、Session scope 的 `'conversation.chat.toolview'` slot；其渲染点通过 `entryKey: toolName` 分发，并以 `GenericToolCard` 作为调用点 fallback。owner 载荷是统一的 `ToolRowOwnerProps`（`callId`／`toolName`／`block`／`openFile`），`ToolRowProps` 将其与 Session 标准工具包组合。注册方只是普通插件：`ctx.slots.register({ name: 'conversation.chat.toolview', key: '<tool>', inject? }, Row)`，以 `inject: ['slots', 'conversation']` 作为加载顺序 seam。Trajectory 与 waterfall（瀑布式事件）工具视图 slot 共享此形状并使用各自的渲染点；RendersCheck 会拒绝没有任何渲染方的声明。
+工具行使用键控、Session scope 的 `'conversation.chat.toolview'` slot；其渲染点通过 `entryKey: toolName` 分发，并以 `GenericToolCard` 作为调用点 fallback。owner 载荷是统一的 `ToolRowOwnerProps`（`callId`／`toolName`／`block`／`openFile`），`ToolRowProps` 将其与 Session 标准工具包组合。注册方是只依赖 slot 服务的普通插件：`ctx.slots.inject('conversation.chat.toolview', () => ctx.slots.register({ name: 'conversation.chat.toolview', key: '<tool>', inject? }, Row))`。声明本身就是激活与重载依赖；只有调用 `ConversationService` 操作的注册项才需要该服务。Trajectory 与 waterfall（瀑布式事件）工具视图 slot 共享此形状并使用各自的渲染点；RendersCheck 会拒绝没有任何渲染方的声明。

 审批经由本包声明的链接管编辑器：`ApprovalPanel` 注册为按选择器路由的 `'conversation.composer'` 配置项（ui-question 模式），在审批等待未决期间取代 InputBar 占据编辑器（琥珀色条、理由标题、来自运行中调用参数的配对命令行、一次性的拒绝／允许）。`contract/slots.ts` 中的 `PendingApproval` 领域面在运行时 `PendingWait` 载体之上拥有 wire 编码——带审计关联的 `ApprovalResponsePayload` 值；广播的 `approval/resolved` 帧使等待落定并恢复编辑器。运行时 manager 会将所有审批或问题等待通过 `SessionSummary.pendingInteraction` 投影出来，未实例化的 Session 也不例外；`ui-workspace` 负责其侧边栏呈现。未决等待完全离开消息流：问题（ui-question）与审批（ApprovalPanel）都经编辑器接管作答，不再保留只读占位卡。编辑器底行的 Access 席位挂载 `PermissionSelect`，由 host 计算的 `permissions` 投影经标准工具包 `useProjection` 供数（key 缺席即隐藏 chip）；chip 打开 Menu 原语下拉，其中 kebab-case 预设名渲染为 Title Case 标签；普通安全预设会立即经输入栏注入的 `command` 回调提交 `/permission <preset>`，而 `danger-full-access` 在界面中显示为 `Full access`，选择后先打开页面内的 Modal 风险确认。用户勾选确认项前启用按钮始终不可用；取消、Escape、关闭按钮与点击遮罩都不会提交命令。

-todo 两个面就是在该形状上的两个注册项，都是普通注册方插件，`inject: ['slots', 'conversation']`。`TodoRow` 占用 `'conversation.chat.toolview'` 的 `todo_write` key，摘要该次调用「试图写入」的内容（从其 args 解析出 `<已完成>/<总数> 已完成 · <进行中条目>`；模型 JSON 残缺或形状不对时回落到通用摘要；非 ok 执行状态保留通用状态点，使被取消的调用绝不读成一次已完成的更新）。`TodoDock` 以 `order: 0` 占用 `'conversation.input.dock'` 列表 slot（位于 Goal 与 Queue 之前），是计划条：它经 `useProjection` 读取 host 计算的 `todos` 投影（站立计划：其后没有更晚 `turn/start` 的最近一次 `todo/write`）并渲染 `TodoPanel`，后者接收纯列表，在列表为空时自我隐藏；列表非空时面板初始折叠，表头显示标题加 `"<已完成>/<总数> tasks · <n> in progress"`（状态图标为 figma 的勾选／进行中／虚线未开始一组）。选取由 dock 适配器负责，因此面板保持为其 props 的纯函数；站立列表放在此处而非行内，行才能保持单行。输入区 composer 链隐藏的一切（例如 ui-question 对 `conversation.composer` 的接管）也会隐藏整个 dock，包括这条计划条。
+todo 两个面就是在该形状上的两个注册项，都使用 slot 声明注入，不依赖 `ConversationService`。`TodoRow` 占用 `'conversation.chat.toolview'` 的 `todo_write` key，摘要该次调用「试图写入」的内容（从其 args 解析出 `<已完成>/<总数> 已完成 · <进行中条目>`；模型 JSON 残缺或形状不对时回落到通用摘要；非 ok 执行状态保留通用状态点，使被取消的调用绝不读成一次已完成的更新）。`TodoDock` 以 `order: 0` 占用 `'conversation.input.dock'` 列表 slot（位于 Goal 与 Queue 之前），是计划条：它经 `useProjection` 读取 host 计算的 `todos` 投影（站立计划：其后没有更晚 `turn/start` 的最近一次 `todo/write`）并渲染 `TodoPanel`，后者接收纯列表，在列表为空时自我隐藏；列表非空时面板初始折叠，表头显示标题加 `"<已完成>/<总数> tasks · <n> in progress"`（状态图标为 figma 的勾选／进行中／虚线未开始一组）。选取由 dock 适配器负责，因此面板保持为其 props 的纯函数；站立列表放在此处而非行内，行才能保持单行。输入区 composer 链隐藏的一切（例如 ui-question 对 `conversation.composer` 的接管）也会隐藏整个 dock，包括这条计划条。

 `QueueDock` 是 `order: 20` 的末端 input-dock 条目。队列为空时隐藏；只有一个待处理项时直接渲染该行；存在两个或更多待处理项时，默认收起为 `"<n> 条排队消息"` 表头，其按钮可展开或收起完整列表。表头暴露 `aria-expanded` 和 `aria-controls`；展开后的列表以 180px 为高度上限，并可滚动。存在进行中的编辑或变更时，列表行会保持可见；队列清空后，下一次出现队列时会恢复默认收起状态。普通会话中的每条可见行仍是单行预览，并提供针对精确单次入队项的编辑、删除和严格 steering（中途引导）操作；已寻址 subagent 则保留只读行，因为其继续执行传输不提供 Queue 变更。如果严格 steering 输给已关闭的窗口，原单次入队项会留在 Queue 中正常投递；如果驱动器已经认领该项，正常投递就已开始。这两种已收敛的竞态都不显示失败，传输和未知错误仍会显示。

@@ -1,6 +1,6 @@
 /** Registers the conversation components, shared store, and service callbacks. */
 import type { Context } from 'cordis'
-import { deferRegistration, resolveSlotLabel, type BoundActions } from '@deepseek-ai/dsh-client-ui-slots'
+import { resolveSlotLabel, type BoundActions } from '@deepseek-ai/dsh-client-ui-slots'
 import type { ISessions, SessionId } from '@deepseek-ai/dsh-client-runtime/client'
 import type {} from '@deepseek-ai/dsh-client-ui-layout/client'
 // Type-only: pulls the locale plugin's Context merge (ctx.locale).
@@ -98,20 +98,16 @@ export function apply(ctx: Context): void {
  const chatStore = createChatStore()
  const submissionPolicy = new ComposerSubmissionPolicy()

-  ctx.effect(() => {
-    const row = deferRegistration(ctx.slots, 'settings.general.item', EnterBehaviorRow, () =>
-      ctx.slots.register({
-        name: 'settings.general.item',
-        id: 'composer-enter',
-        order: 20,
-        locale: NS,
-        inject: (): EnterBehaviorRowInjected => ({
-          hooks: { busyEnter: submissionPolicy.busyEnter },
-          setBusyEnter: (behavior) => { submissionPolicy.setBusyEnter(behavior) },
-        }),
-      }, EnterBehaviorRow))
-    return () => { row.dispose() }
-  }, 'ui-conversation: Enter behavior settings row')
+  ctx.slots.inject('settings.general.item', () => ctx.slots.register({
+    name: 'settings.general.item',
+    id: 'composer-enter',
+    order: 20,
+    locale: NS,
+    inject: (): EnterBehaviorRowInjected => ({
+      hooks: { busyEnter: submissionPolicy.busyEnter },
+      setBusyEnter: (behavior) => { submissionPolicy.setBusyEnter(behavior) },
+    }),
+  }, EnterBehaviorRow))

  // Chat semantic reader positions by session, surviving view switches and
  // width reflow when the tab ring remounts the view. Deliberately not
@@ -338,13 +334,11 @@ export function apply(ctx: Context): void {

  // Class-plugin mount (packages/AGENTS.md service form): the service
  // registers itself as `conversation` and lives on its own child fiber.
-  // Mounted AFTER the chat entry register above — construction guarantee for
-  // toolview registrants using `inject: ['conversation']` as their load-order
-  // seam: the service being present implies the chat entry (and with it the
-  // 'conversation.chat.toolview' declaration) is on the ledger.
+  // Presentation registrants depend directly on their slot declarations;
+  // this service remains only where conversation actions are required.
  ctx.plugin(ConversationService, { input: inputHub })

-  // The bash sample rides that exact seam, in third-party posture
+  // The bash sample rides the same declaration seam, in third-party posture
  // (ToolRow-matching Bash · {description} chrome).
  ctx.plugin(bashToolviewSample)

@@ -213,8 +213,8 @@ export function QueueDock({ useSession, updateQueue, notify, t }: QueueDockProps
 }

 /**
- * The dock entry as a plain registrant plugin. The conversation service is the
- * ordering and action seam; session scopes provide the exact queue owner.
+ * The dock entry as a plain registrant plugin. The conversation service is
+ * the action seam; the slot declaration is its independent lifecycle seam.
 */
 export const queueDockEntry = {
  name: 'conversation-queue-dock',
@@ -224,7 +224,7 @@ export const queueDockEntry = {
   * @param ctx - registrant context (disposal rides ctx.effect inside slots.register).
   */
  apply(ctx: Context): void {
-    ctx.slots.register({
+    ctx.slots.inject('conversation.input.dock', () => ctx.slots.register({
      name: 'conversation.input.dock',
      id: 'queue',
      order: 20,
@@ -239,6 +239,6 @@ export const queueDockEntry = {
          notify: (level, text) => { conversation.input.for(actx).notify(level, text) },
        }
      },
-    }, QueueDock)
+    }, QueueDock))
  },
 }
@@ -137,19 +137,18 @@ export function TodoDock({ useProjection, t }: TodoDockProps) {
 }

 /**
- * The plan strip as a plain registrant plugin (QueueDock posture).
- * `inject: ['conversation']` is the ordering seam: the conversation service
- * mounts after ui-conversation's slot registrations, so the
- * 'conversation.input.dock' declaration is on the ledger by then.
+ * The plan strip as a plain registrant plugin (QueueDock posture), following
+ * the input-dock declaration across independent activation and reload.
 */
 export const todoDockEntry = {
  name: 'conversation-todo-dock',
-  inject: ['slots', 'conversation'],
+  inject: ['slots'],
  /**
   * Register the plan strip before the goal and queue entries (order 0).
   * @param ctx - registrant context (disposal rides ctx.effect inside slots.register).
   */
  apply(ctx: Context): void {
-    ctx.slots.register({ name: 'conversation.input.dock', id: 'todo', order: 0, locale: NS }, TodoDock)
+    ctx.slots.inject('conversation.input.dock', () =>
+      ctx.slots.register({ name: 'conversation.input.dock', id: 'todo', order: 0, locale: NS }, TodoDock))
  },
 }
@@ -83,19 +83,19 @@ export function AskQuestionRow({ toolName, block, inspect, t }: AskQuestionRowPr
 }

 /**
- * The ask-question row as a plain registrant plugin, riding the same
- * load-order seam as todo-toolview: `inject: ['conversation']` guarantees the
- * chat entry (and with it the 'conversation.chat.toolview' declaration) is on
- * the ledger.
+ * The ask-question row as a plain registrant plugin following the chat
+ * toolview declaration across independent activation and reload lifetimes.
 */
 export const askQuestionToolview = {
  name: 'ask-question-toolview',
-  inject: ['slots', 'conversation'],
+  inject: ['slots'],
  /**
   * Register the ask-question row into the chat view's keyed toolview hole.
   * @param ctx - registrant context (disposal rides ctx.effect inside slots.register).
   */
  apply(ctx: Context): void {
-    ctx.slots.register({ name: 'conversation.chat.toolview', key: 'ask_user_question', locale: NS }, AskQuestionRow)
+    ctx.slots.inject('conversation.chat.toolview', () => ctx.slots.register({
+      name: 'conversation.chat.toolview', key: 'ask_user_question', locale: NS,
+    }, AskQuestionRow))
  },
 }
@@ -166,19 +166,18 @@ export function BashRow({ toolName, block, sessionId, useSessions, inspect, t }:
 }

 /**
- * The sample as a plain registrant plugin. `inject` carries the load-order
- * seam: requiring the conversation service guarantees the chat entry (and
- * with it the 'conversation.chat.toolview' declaration) is registered —
- * ui-conversation's apply mounts the service after the chat entry.
+ * The sample as a plain registrant plugin. Slot injection follows the chat
+ * toolview declaration across independent activation and reload lifetimes.
 */
 export const bashToolviewSample = {
  name: 'bash-toolview-sample',
-  inject: ['slots', 'conversation'],
+  inject: ['slots'],
  /**
   * Register the bash row into the chat view's keyed toolview hole.
   * @param ctx - registrant context (disposal rides ctx.effect inside slots.register).
   */
  apply(ctx: Context): void {
-    ctx.slots.register({ name: 'conversation.chat.toolview', key: 'bash', locale: NS }, BashRow)
+    ctx.slots.inject('conversation.chat.toolview', () =>
+      ctx.slots.register({ name: 'conversation.chat.toolview', key: 'bash', locale: NS }, BashRow))
  },
 }
@@ -53,21 +53,21 @@ export function FileMutationRow({ toolName, block, cwd, openFile, inspect, t }:
 }

 /**
- * The file-mutation rows as a plain registrant plugin. `inject` carries the
- * load-order seam: requiring the conversation service guarantees the chat entry
- * (and with it the 'conversation.chat.toolview' declaration) is registered —
- * ui-conversation's apply mounts the service after the chat entry.
+ * The file-mutation rows as a plain registrant plugin following the chat
+ * toolview declaration across independent activation and reload lifetimes.
 */
 export const fileMutationToolview = {
  name: 'file-mutation-toolview',
-  inject: ['slots', 'conversation'],
+  inject: ['slots'],
  /**
   * Register the file-mutation row into the chat view's keyed toolview hole
   * under both mutation tool names.
   * @param ctx - registrant context (disposal rides ctx.effect inside slots.register).
   */
  apply(ctx: Context): void {
-    ctx.slots.register({ name: 'conversation.chat.toolview', key: 'edit', locale: NS }, FileMutationRow)
-    ctx.slots.register({ name: 'conversation.chat.toolview', key: 'write', locale: NS }, FileMutationRow)
+    ctx.slots.inject('conversation.chat.toolview', function* () {
+      yield ctx.slots.register({ name: 'conversation.chat.toolview', key: 'edit', locale: NS }, FileMutationRow)
+      yield ctx.slots.register({ name: 'conversation.chat.toolview', key: 'write', locale: NS }, FileMutationRow)
+    })
  },
 }
@@ -48,19 +48,18 @@ export function ReadRow({ toolName, block, cwd, openFile, inspect, t }: ReadRowP
 }

 /**
- * The read row as a plain registrant plugin. `inject` carries the load-order
- * seam: requiring the conversation service guarantees the chat entry (and with
- * it the 'conversation.chat.toolview' declaration) is registered —
- * ui-conversation's apply mounts the service after the chat entry.
+ * The read row as a plain registrant plugin following the chat toolview
+ * declaration across independent activation and reload lifetimes.
 */
 export const readToolview = {
  name: 'read-toolview',
-  inject: ['slots', 'conversation'],
+  inject: ['slots'],
  /**
   * Register the read row into the chat view's keyed toolview hole.
   * @param ctx - registrant context (disposal rides ctx.effect inside slots.register).
   */
  apply(ctx: Context): void {
-    ctx.slots.register({ name: 'conversation.chat.toolview', key: 'read', locale: NS }, ReadRow)
+    ctx.slots.inject('conversation.chat.toolview', () =>
+      ctx.slots.register({ name: 'conversation.chat.toolview', key: 'read', locale: NS }, ReadRow))
  },
 }
@@ -61,22 +61,22 @@ export function SearchRow({ toolName, block, inspect, t }: SearchRowProps) {
 }

 /**
- * The search toolview as a plain registrant plugin. `inject` carries the
- * load-order seam: requiring the conversation service guarantees the chat entry
- * (and with it the 'conversation.chat.toolview' declaration) is registered.
- * The one component registers under both keys, since `grep` and `glob` are the
- * same visual object discriminated only by the result view's `kind`.
+ * The search toolview follows the chat toolview declaration across activation
+ * and reload. One component registers under both keys because `grep` and
+ * `glob` are the same visual object discriminated by the result view's `kind`.
 */
 export const searchToolview = {
  name: 'search-toolview',
-  inject: ['slots', 'conversation'],
+  inject: ['slots'],
  /**
   * Register the search row into the chat view's keyed toolview hole under both
   * the `grep` and `glob` tool names.
   * @param ctx - registrant context (disposal rides ctx.effect inside slots.register).
   */
  apply(ctx: Context): void {
-    ctx.slots.register({ name: 'conversation.chat.toolview', key: 'grep', locale: NS }, SearchRow)
-    ctx.slots.register({ name: 'conversation.chat.toolview', key: 'glob', locale: NS }, SearchRow)
+    ctx.slots.inject('conversation.chat.toolview', function* () {
+      yield ctx.slots.register({ name: 'conversation.chat.toolview', key: 'grep', locale: NS }, SearchRow)
+      yield ctx.slots.register({ name: 'conversation.chat.toolview', key: 'glob', locale: NS }, SearchRow)
+    })
  },
 }
@@ -71,18 +71,18 @@ export function TodoRow({ toolName, block, inspect, t }: TodoRowProps) {
 }

 /**
- * The todo row as a plain registrant plugin, riding the same load-order seam
- * as the bash sample: `inject: ['conversation']` guarantees the chat entry
- * (and with it the 'conversation.chat.toolview' declaration) is on the ledger.
+ * The todo row as a plain registrant plugin following the chat toolview
+ * declaration across independent activation and reload lifetimes.
 */
 export const todoToolview = {
  name: 'todo-toolview',
-  inject: ['slots', 'conversation'],
+  inject: ['slots'],
  /**
   * Register the todo row into the chat view's keyed toolview hole.
   * @param ctx - registrant context (disposal rides ctx.effect inside slots.register).
   */
  apply(ctx: Context): void {
-    ctx.slots.register({ name: 'conversation.chat.toolview', key: 'todo_write', locale: NS }, TodoRow)
+    ctx.slots.inject('conversation.chat.toolview', () =>
+      ctx.slots.register({ name: 'conversation.chat.toolview', key: 'todo_write', locale: NS }, TodoRow))
  },
 }
@@ -55,20 +55,20 @@ export function WebRow({ toolName, block, inspect, t }: WebRowProps) {
 }

 /**
- * The web rows as a plain registrant plugin, riding the same load-order seam as
- * the bash sample: `inject: ['conversation']` guarantees the chat entry (and
- * with it the 'conversation.chat.toolview' declaration) is on the ledger. One
- * WebRow component registers under both web tool names.
+ * The web rows follow the chat toolview declaration across activation and
+ * reload. One WebRow component registers under both web tool names.
 */
 export const webToolview = {
  name: 'web-toolview',
-  inject: ['slots', 'conversation'],
+  inject: ['slots'],
  /**
   * Register the web row under both web tool names' keyed toolview holes.
   * @param ctx - registrant context (disposal rides ctx.effect inside slots.register).
   */
  apply(ctx: Context): void {
-    ctx.slots.register({ name: 'conversation.chat.toolview', key: 'web_search', locale: NS }, WebRow)
-    ctx.slots.register({ name: 'conversation.chat.toolview', key: 'web_fetch', locale: NS }, WebRow)
+    ctx.slots.inject('conversation.chat.toolview', function* () {
+      yield ctx.slots.register({ name: 'conversation.chat.toolview', key: 'web_search', locale: NS }, WebRow)
+      yield ctx.slots.register({ name: 'conversation.chat.toolview', key: 'web_fetch', locale: NS }, WebRow)
+    })
  },
 }
@@ -124,11 +124,13 @@ describe('AskQuestionRow', () => {
    expect(screen.getByRole('button', { expanded: true })).toBeTruthy()
  })

-  it('askQuestionToolview is a plain registrant riding the conversation load-order seam', () => {
+  it('askQuestionToolview injects the toolview declaration directly', () => {
    expect(askQuestionToolview.name).toBe('ask-question-toolview')
-    expect(askQuestionToolview.inject).toEqual(['slots', 'conversation'])
-    const register = vi.fn()
-    askQuestionToolview.apply({ slots: { register } } as never)
+    expect(askQuestionToolview.inject).toEqual(['slots'])
+    const register = vi.fn(() => () => undefined)
+    const inject = vi.fn((_name: string, callback: () => () => void) => callback())
+    askQuestionToolview.apply({ slots: { inject, register } } as never)
+    expect(inject).toHaveBeenCalledWith('conversation.chat.toolview', expect.any(Function))
    expect(register).toHaveBeenCalledWith(
      { name: 'conversation.chat.toolview', key: 'ask_user_question', locale: 'conversation' },
      AskQuestionRow,
@@ -3,8 +3,8 @@
 // as the first 'conversation.view' ring entry declaring the keyed toolview
 // hole, the slot registrations land against a root entry's children
 // declarations (the AppFrame role), the shared store handle rides all strict
-// session entries, and the bash sample + todo row mount through the
-// load-order seam as keyed entries. Full-chain rendering belongs to the
+// session entries, and the bash sample + todo row mount through declaration
+// injection as keyed entries. Full-chain rendering belongs to the
 // machinery spec (chat-toolview-slot.spec.tsx) and the shell e2e; this spec
 // stops at the assembly surface.

@@ -90,10 +90,9 @@ describe('apply wiring', () => {
    await b.runtime.dispose()
  })

-  it('mounts the bash sample, the read row, the file-mutation rows, the search rows (grep + glob), the web rows, and the product rows as keyed entries through the load-order seam', async () => {
+  it('mounts the tool rows as keyed entries through declaration injection', async () => {
    const b = await bench()
-    // Every registrant plugin's inject: ['slots', 'conversation'] resolved — the
-    // service being present implies the chat entry declared the hole first. The
+    // The actual toolview declaration activates every registrant. The
    // file-mutation registrant claims both write and edit for the diff card; the
    // one search row registers under both grep and glob; the web rows register
    // one component under both web tool names.
@@ -6,9 +6,8 @@
 // entryKey (the bash sample lands through its plugin), unregistered tools
 // fall back to GenericToolCard at the render site, live registration/unload
 // flips rows in place, duplicate keys fail loud, the inject channel feeds
-// (sessionId) => I into row components, and a registrant's
-// inject: ['slots', 'conversation'] load-order seam suspends on real fiber
-// semantics until the service (and with it the hole declaration) is present.
+// (sessionId) => I into row components, and a registrant can activate before
+// the declaration then land through slots.inject when the chat entry appears.

 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import { cleanup, fireEvent } from '@testing-library/react'
@@ -191,8 +190,8 @@ describe('keyed toolview hole through the real machinery', () => {
  })
 })

-describe('registrant load-order seam', () => {
-  it("suspends a registrant on inject: ['slots', 'conversation'] until the service (and the hole) exists", async () => {
+describe('registrant declaration injection', () => {
+  it('runs the plugin before ui-conversation and waits on the actual toolview declaration', async () => {
    const runtime = await SlotTestRuntime.create()
    runtime.provide('layout', { openDetails: vi.fn(), closeDetails: vi.fn() })
    const locale = new LocaleService(runtime.ctx)
@@ -200,31 +199,26 @@ describe('registrant load-order seam', () => {
    runtime.slots.installLocale(locale)
    await runtime.root.declare(LAYOUT_CHILDREN, AppRoot)

-    // Third-party posture, mounted BEFORE ui-conversation: real fiber inject
-    // semantics hold it — apply must not run while 'conversation' is absent.
-    // Uses ctx.plugin directly (the deliberate-suspension escape hatch; mount()
-    // would fail loud on the missing service). (Plain arrow, not vi.fn: mock
-    // functions carry a prototype and trip the fiber's isConstructor branch.)
+    // Third-party posture, mounted BEFORE ui-conversation. Plugin apply runs,
+    // while slots.inject waits for the declaration itself.
    let applyRuns = 0
    const registrantApply = (registrantCtx: typeof runtime.ctx): void => {
      applyRuns += 1
-      registrantCtx.slots.register(
-        { name: 'conversation.chat.toolview', key: 'late' }, () => null)
+      registrantCtx.slots.inject('conversation.chat.toolview', () => registrantCtx.slots.register(
+        { name: 'conversation.chat.toolview', key: 'late' }, () => null))
    }
    const late = runtime.ctx.plugin({
      name: 'late-registrant',
-      inject: ['slots', 'conversation'],
+      inject: ['slots'],
      apply: registrantApply,
    })
    await Promise.resolve()
-    expect(applyRuns).toBe(0)
-
-    // Mounting the package resolves the seam: service present ⟹ the chat
-    // entry (and its hole declaration) is already on the ledger, so the
-    // suspended registrant lands without an undeclared-slot throw.
-    await runtime.mount({ inject: [...inject], apply })
    await late.await()
    expect(applyRuns).toBe(1)
+    expect(runtime.slots.entries('conversation.chat.toolview')).toHaveLength(0)
+
+    // Mounting the package declares the slot and activates the waiting entry.
+    await runtime.mount({ inject: [...inject], apply })
    expect(runtime.slots.entries('conversation.chat.toolview').map(e => e.options.key))
      .toEqual(expect.arrayContaining(['bash', 'late']))
    await runtime.dispose()
@@ -274,8 +274,14 @@ describe('fileMutationToolview registration', () => {
  it('registers one component under both edit and write, and each disposes', () => {
    const registered: { key: string; locale: unknown; disposed: boolean }[] = []
    const disposers: (() => void)[] = []
+    let disposeInjection = (): void => {}
    const ctx = {
      slots: {
+        inject: (_name: string, callback: () => Iterable<() => void>) => {
+          const active = [...callback()]
+          disposeInjection = () => { for (const dispose of active.reverse()) dispose() }
+          return disposeInjection
+        },
        register: ({ key, locale }: { name: string; key: string; locale?: string }) => {
          const entry = { key, locale, disposed: false }
          registered.push(entry)
@@ -289,10 +295,9 @@ describe('fileMutationToolview registration', () => {
    expect(registered.map(r => r.key).sort()).toEqual(['edit', 'write'])
    // Both keys claim the conversation locale seat ToolRow's body copy needs.
    expect(registered.map(r => r.locale)).toEqual(['conversation', 'conversation'])
-    // The registrant's inject seam is the load-order contract the row relies on.
-    expect(fileMutationToolview.inject).toEqual(['slots', 'conversation'])
+    expect(fileMutationToolview.inject).toEqual(['slots'])
    // Disposal removes each contribution (packages/AGENTS.md registry contract).
-    for (const dispose of disposers) dispose()
+    disposeInjection()
    expect(registered.every(r => r.disposed)).toBe(true)
  })
 })
@@ -375,8 +375,10 @@ describe('QueueDock', () => {
  it('registers as the terminal composer-context entry', () => {
    expect(queueDockEntry.name).toBe('conversation-queue-dock')
    expect(queueDockEntry.inject).toEqual(['slots', 'conversation', 'sessions'])
-    const register = vi.fn()
-    queueDockEntry.apply({ slots: { register } } as never)
+    const register = vi.fn(() => () => undefined)
+    const inject = vi.fn((_name: string, callback: () => () => void) => callback())
+    queueDockEntry.apply({ slots: { inject, register } } as never)
+    expect(inject).toHaveBeenCalledWith('conversation.input.dock', expect.any(Function))
    expect(register).toHaveBeenCalledWith(
      expect.objectContaining({ name: 'conversation.input.dock', id: 'queue', order: 20 }),
      QueueDock,
@@ -237,11 +237,14 @@ describe('ReadRow keyed toolview', () => {

  it('registers under the read key of the keyed toolview slot', () => {
    const registered: { name: unknown; key?: unknown }[] = []
-    const ctx = { slots: { register: (options: { name: unknown; key?: unknown }) => { registered.push(options) } } } as unknown as Context
+    const ctx = { slots: {
+      inject: (_name: string, callback: () => () => void) => callback(),
+      register: (options: { name: unknown; key?: unknown }) => { registered.push(options); return () => undefined },
+    } } as unknown as Context
    readToolview.apply(ctx)
    // The row composes ToolRow, so it declares its locale namespace at the seat.
    expect(registered).toEqual([{ name: 'conversation.chat.toolview', key: 'read', locale: 'conversation' }])
-    expect(readToolview.inject).toContain('conversation')
+    expect(readToolview.inject).toEqual(['slots'])
  })
 })

@@ -349,8 +349,13 @@ describe('SearchRow keyed card', () => {
    const registered: { key: unknown; locale: unknown; component: unknown }[] = []
    const ctx = {
      slots: {
+        inject: (_name: string, callback: () => Iterable<() => void>) => {
+          for (const _dispose of callback()) { /* exhaust transactional setup */ }
+          return () => undefined
+        },
        register: (options: { name: string; key: string; locale?: string }, component: unknown) => {
          registered.push({ key: options.key, locale: options.locale, component })
+          return () => undefined
        },
      },
    } as never
@@ -361,7 +366,7 @@ describe('SearchRow keyed card', () => {
    // One component, two keys.
    expect(registered[0]!.component).toBe(SearchRow)
    expect(registered[1]!.component).toBe(SearchRow)
-    expect(searchToolview.inject).toEqual(['slots', 'conversation'])
+    expect(searchToolview.inject).toEqual(['slots'])
  })
 })

@@ -111,9 +111,11 @@ describe('TodoDock', () => {

  it('registers before the goal and queue entries', () => {
    expect(todoDockEntry.name).toBe('conversation-todo-dock')
-    expect(todoDockEntry.inject).toEqual(['slots', 'conversation'])
-    const register = vi.fn()
-    todoDockEntry.apply({ slots: { register } } as never)
+    expect(todoDockEntry.inject).toEqual(['slots'])
+    const register = vi.fn(() => () => undefined)
+    const inject = vi.fn((_name: string, callback: () => () => void) => callback())
+    todoDockEntry.apply({ slots: { inject, register } } as never)
+    expect(inject).toHaveBeenCalledWith('conversation.input.dock', expect.any(Function))
    expect(register).toHaveBeenCalledWith({ name: 'conversation.input.dock', id: 'todo', order: 0, locale: NS }, TodoDock)
  })
 })
@@ -196,11 +198,13 @@ describe('TodoRow', () => {
    expect(screen.getByText('todo_write · c1')).toBeTruthy()
  })

-  it('todoToolview is a plain registrant riding the conversation load-order seam', () => {
+  it('todoToolview injects the toolview declaration directly', () => {
    expect(todoToolview.name).toBe('todo-toolview')
-    expect(todoToolview.inject).toEqual(['slots', 'conversation'])
-    const register = vi.fn()
-    todoToolview.apply({ slots: { register } } as never)
+    expect(todoToolview.inject).toEqual(['slots'])
+    const register = vi.fn(() => () => undefined)
+    const inject = vi.fn((_name: string, callback: () => () => void) => callback())
+    todoToolview.apply({ slots: { inject, register } } as never)
+    expect(inject).toHaveBeenCalledWith('conversation.chat.toolview', expect.any(Function))
    expect(register).toHaveBeenCalledWith({ name: 'conversation.chat.toolview', key: 'todo_write', locale: NS }, TodoRow)
  })
 })
@@ -272,6 +272,10 @@ describe('web toolview registration', () => {
    const registered: { key: string; locale: unknown; component: unknown }[] = []
    const ctx = {
      slots: {
+        inject: (_name: string, callback: () => Iterable<() => void>) => {
+          for (const _dispose of callback()) { /* exhaust transactional setup */ }
+          return () => undefined
+        },
        register: (options: { name: string; key: string; locale?: string }, component: unknown) => {
          registered.push({ key: options.key, locale: options.locale, component })
          return () => {}
@@ -285,7 +289,6 @@ describe('web toolview registration', () => {
    // One component under both keys, not two thin rows.
    expect(registered[0]?.component).toBe(WebRow)
    expect(registered[1]?.component).toBe(WebRow)
-    // The load-order seam the render site depends on.
-    expect(webToolview.inject).toEqual(['slots', 'conversation'])
+    expect(webToolview.inject).toEqual(['slots'])
  })
 })