dsh-llm-fallbacks 0.5.0 → 0.5.2

package/README.md

@@ -161,6 +161,8 @@ The original generation is never modified and never truncated; rollback is delet
 
 **`--apply` refuses a revision it did not decode.** The digest of the bytes this run read is compared with the file before anything is staged, so a concurrent append is refused before the first write. If the source moves *after* a publication this run created, that successor is removed again; if it moves after accepting a pre-existing identical successor, the failure names that file and says to delete it — never "nothing was published".
 
+**A closed report stream is not a store event.** Piping the report into a consumer that stops reading (`pnpm repair:session-logs -- | head -n 5`) closes stdout, and the next write would otherwise raise an unhandled `EPIPE`. Instead the tool stops writing to that stream (with no stack trace), **still finishes the run** — an `--apply` pass publishes every remaining successor — and exits with the exit code below, which always describes what happened to the **store**, never whether the reader stayed. A stream error that is not a closed pipe (a full disk, an I/O failure) is **not** swallowed: it still surfaces as an uncaught error.
+
 **Exit codes**: `0` = every log loads (a session that opens with rows dropped under the strict policy is `ok-truncated` and still exits `0`); `1` = at least one log is still refused/unrepairable, a repair failed, a log was left unpublished (including one `--class` excluded), an input could not be inspected (a `skipped` path), or a stale `session.repair.*.jsonl.zstd.tmp` was found under the root; `2` = fatal (bad arguments, a missing or unreadable `--root`, `--apply` without a resolved catalog, a catalog below format v3, `--apply --drop-legacy-events` without `--backup`, or a runtime without `node:zlib` zstd).
 
 ### Lossy recovery for `fallbacks/switch` (opt-in)
@@ -186,7 +188,9 @@ The durable fix belongs upstream at the migration edges (the frozen V0→V1 edge
 - **Chain as root primary from the picker**: when `enabled` is on, the host model picker (web and TUI alike) shows a virtual `FallbacksChain` / `Auto` row — selecting it uses the configured chain as the root primary (a conforming all-day head is required for the delegation to succeed); selecting a real model keeps fallback-only (see [FallbacksChain in the model picker](#fallbackschain-in-the-model-picker)).
 - **Time slots**: optional `fallbacks.timeSlots` rows rotate the effective root chain by wall-clock windows in the config-level `tz` timezone (default `Asia/Shanghai`) — four frozen UTC+8 presets (`liang-peak` / `liang-valley` / `glm-peak` / `glm-valley`, windows are code constants, models-only edits) or custom `start`/`end`/`days` windows. The first matching row wins; the all-day row is always last. A slot change applies on the **next** root request and is logged as a **time-slot switch** — a routing seed, never a failure decision: it consumes no cooldown and does not count against `maxSwitchesPerStep`. Failure walks keep the **fallback switch** copy (see [Time-slot presets](#time-slot-presets)).
 - **Dispatch-time role resolution**: on a subagent's first request its role is resolved in three stages — explicit (`agentPreset` matches a declared role id) → deterministic rules (matching either the recorded pair or the served head — see [FallbacksChain in the model picker](#fallbackschain-in-the-model-picker)) → LLM auto-match from the declared role taxonomy (`fallbacks.roleAutoMatch`, default `true`). The resolved role's chain-head model is injected into the first request and recorded via an explicit `role → model` log line (no durable `fallbacks/switch` event is written — issue #52 stop-write); set `roleAutoMatch: false` to disable the LLM auto-match stage (the explicit `agentPreset` stage still applies — with no explicit role this reproduces the previous rules-only behavior). The settings card always renders an **Enable role auto-match** switch (default `true`) to toggle it — the schema default applies even to legacy configs that never declared the key.
-- **Subagent role badge**: when a subagent's dispatch resolves a non-`inherit` role (policy on or off), its session shows a compact role badge next to the session title in the web session header — hover shows `role → provider/model`, the effective route after any override/inject. `inherit`/unresolved sessions render no badge; records are in-process only (a host restart clears them — the `role → model` info log stays the durable record).
+- **Role persona on the child (chain-independent)**: when a subagent's dispatch declares a role this plugin knows (the `**Execute as**: <id>` field of its Assignment), that role's `persona` is installed on the child as its own persona — the role is the child's identity, not only a routing decision, and delivery does not depend on routing: a role with an empty `chain` gets its persona exactly like a chained one (the chain only picks the model). A persona the caller already set is never overwritten; a provider that cannot carry a persona skips it and the dispatch runs natively.
+- **Role announced inside the subagent's own session**: a child dispatched with a declared role gets exactly one plugin notice row in its own session, naming the role it was dispatched as — `[role: <id>]`, with ` (persona not applied)` when the role declares a persona that was skipped — written once at the child's first non-empty pre-step, never for a root session and never for `inherit`/unresolved dispatches. The row is a durable transcript row, so the role stays readable in the child's session after it settles.
+- **Subagent role badge**: when a subagent is **dispatched with a declared role** — the `**Execute as**: <id>` field of its Assignment, the same declaration that carries the persona, and the badge's ONLY source (policy on or off) — its session shows a compact role badge next to the session's agent-preset (mode) chip in the web session header; hover shows `role → latest request route` (the route of the newest recorded request, not the dispatch-time route). Only the DECLARED header is read, so a child whose role came from another stage (`agentPreset` match, a role rule, or the LLM auto-match) but which declares no Assignment header is still routed as that role yet shows **no** badge — the badge never reports a role inferred after the fact. `inherit`/unresolved sessions render no badge. The badge is durable: it is read from the child's own session record, so it is still shown for a **settled** subagent session and **after a host restart**.
 - **Context-window-aware fallback**: `triggerCodes` accepts any dsh failure code, including `CONTEXT_WINDOW_EXCEEDED` — a request too big for the current model fails over to a candidate with a **larger** context window (candidates that cannot fit either are skipped), and because the route itself is healthy the switch is request-scoped: no cooldown, no half-open probe burned (see [Fallback triggers](#fallback-triggers-triggercodes)).
 - **Cooldown and revert**: failed / switched-away models are not re-selected during cooldown; `revertPolicy: cooldown-expiry` returns to the primary model automatically.
 - **Host subagent model policy (dsh 0.1.2)**: when the host `subagent-model-selection` policy is enabled, its allowlist is a hard constraint on every plugin-originated subagent route — an explicit authorized spawn route stays the chain head (role-inject skipped), inheritance inject heads and failure-switch targets are intersected with the effective allowlist, and an empty intersection skips the inject/switch (warn log + read-only card warning; no out-of-allowlist request is ever sent). A present-but-unreadable policy fails closed. Policy off/absent → inject and failure-switch selection exactly as 0.3.5. Override `reasoningEffort` follows the upstream routeChanged rule on every path (same route → keep; route change → drop unless explicit). See [Host subagent model policy](#host-subagent-model-policy-dsh-012).

package/README.zh-CN.md

@@ -161,6 +161,8 @@ pnpm repair:session-logs -- --apply                  # 发布修复后的后继
 
 **`--apply` 拒绝发布它不是基于其解码的那一版。** 本次运行读取到的字节摘要会在暂存任何内容之前与文件比对，因此并发追加会在首次写入前被拒绝。若源文件在本次运行**创建**的后继发布之后发生变化，该后继会被移除；若是在接受一个已存在的相同后继之后发生变化，失败信息会指出该文件并说明需删除它以回滚——绝不会说 “nothing was published”。
 
+**报告流被关闭不是存储事件。** 把报告接到提前停止读取的消费者（`pnpm repair:session-logs -- | head -n 5`）会关闭 stdout，此后的写入本会抛出未处理的 `EPIPE`。现在工具会停止向该流写入（不打印堆栈），**仍把整轮运行跑完**——`--apply` 会发布其余每一个后继世代——并以下面的退出码退出；该退出码始终描述**存储**发生了什么，而与读取方是否留下无关。非关闭管道造成的流错误（磁盘写满、I/O 失败）**不会**被吞掉：它仍会以未捕获错误暴露。
+
 **退出码**：`0` = 每个日志都能加载（在严格策略下会丢行打开的会话报告为 `ok-truncated`，仍以 `0` 退出）；`1` = 至少一个日志仍被拒绝/不可修复、修复失败、有日志未发布（包括被 `--class` 排除的）、某个输入无法被检查（`skipped` 路径），或发现残留的 `session.repair.*.jsonl.zstd.tmp`；`2` = 致命错误（参数非法、缺少或无法读取 `--root`、`--apply` 未解析出 catalog、catalog 低于格式 v3、`--apply --drop-legacy-events` 缺少 `--backup`，或运行时没有 `node:zlib` zstd）。
 
 ### fallbacks/switch 的有损恢复（opt-in）
@@ -186,7 +188,9 @@ pnpm repair:session-logs -- --drop-legacy-events --apply --backup  # 此处必
 - **选择器里把链当主模型**：`enabled` 开启时，宿主模型选择器（web 与 TUI 一致）出现虚拟 `FallbacksChain` / `Auto` 行——选中它即以配置的链作为 root 主模型（需要 all-day 链头合规才能成功委托）；选真实模型则保持 fallback-only（见 [模型选择器中的 FallbacksChain](#模型选择器中的-fallbackschain)）。
 - **峰谷无忧（分时切换）**：可选的 `fallbacks.timeSlots` 行按墙钟窗口（配置级 `tz` 时区，默认 `Asia/Shanghai`）轮换 root 生效链——四个冻结的 UTC+8 预设（`liang-peak` / `liang-valley` / `glm-peak` / `glm-valley`，窗口为代码常量、仅模型链可编辑），或自定义 `start`/`end`/`days` 窗口。第一条命中的行生效；全时段行固定最后。时段切换在**下一个** root 请求生效，日志记为**分时切换**——路由种子而非失败决策：不消耗冷却、不计入 `maxSwitchesPerStep`。失败降级保留**降级切换**文案（见 [分时槽预设（分时切换）](#分时槽预设分时切换)）。
 - **派发时角色解析**：在 subagent 的首次请求上，其角色按三个阶段解析——显式（`agentPreset` 匹配已声明角色 id）→ 确定性规则（匹配记录 pair 或实际服务的链头——见 [模型选择器中的 FallbacksChain](#模型选择器中的-fallbackschain)）→ LLM 自动匹配（从已声明角色体系中选择，`fallbacks.roleAutoMatch` 默认 `true`）。解析出的角色的链头模型注入首次请求，并以显式 `role → model` 日志行记录（不写 durable `fallbacks/switch` 事件——issue #52 停写）；设 `roleAutoMatch: false` 仅关闭 LLM 自动匹配阶段（显式 `agentPreset` 阶段仍生效——无显式角色时即复现原有仅规则行为）。设置卡总是渲染「启用角色自动匹配」开关（默认 `true`）以切换之——即使是从未声明过该键的旧配置，schema 默认值同样生效。
-- **子代理角色徽标**：当 subagent 的派发解析出非 `inherit` 角色（策略开或关）时，其会话在 Web 会话头部的标题旁显示一个紧凑的角色徽标——悬停显示 `role → provider/model`（覆盖/注入后的实际生效路由）。`inherit`/未解析角色的会话不显示徽标；记录仅存于进程内（宿主重启即清空——`role → model` info 日志仍是持久记录）。
+- **角色人格注入到子代理（与链无关）**：当 subagent 的派发声明了本插件已知的角色（Assignment 的 `**Execute as**: <id>` 字段）时，该角色的 `persona` 会安装为子代理自身的人格——角色就是子代理的身份，而不只是路由决策；注入与路由无关：`chain` 为空的角色与带链角色的人格注入完全一致（链只负责选模型）。调用方已设置的人格永不覆盖；宿主 provider 无法承载人格时跳过注入，派发照常原生运行。
+- **角色在子代理自己的会话中声明**：声明了角色的派发会让子代理自身的会话得到恰好一条插件 notice 行，写明它被派发为哪个角色——`[role: <id>]`，当角色声明了人格但被跳过时追加 ` (persona not applied)`——在子代理首个非空 pre-step 写入一次，root 会话以及 `inherit`/未解析角色的派发永不写入。该行是持久轨迹行，子代理结束后角色仍可在其会话中读到。
+- **子代理角色徽标**：当 subagent 被**声明了角色地派发**——即其 Assignment 中的 `**Execute as**: <id>` 字段，也就是承载人格的同一处声明，并且是徽标的**唯一**来源（策略开或关皆同）——时，其会话在 Web 会话头部的标题旁显示一个紧凑的角色徽标；悬停显示 `role → 最近一次请求的路由`（最近一条已记录请求的路由，而非派发时的路由）。由于只读取被声明的头部字段，通过其他阶段解析出角色（`agentPreset` 匹配、role 规则或 LLM 自动匹配）但**未**在 Assignment 头部声明角色的子代理仍会按该角色路由，却**不**显示徽标——徽标绝不报告事后推断的角色。`inherit`/未解析角色的会话不显示徽标。徽标是持久的：它读取子代理自身的会话记录，因此**已结束的子代理会话**与**宿主重启之后**仍然显示。
 - **上下文窗口感知降级**：`triggerCodes` 接受任意 dsh 失败码，包括 `CONTEXT_WINDOW_EXCEEDED`——请求超出当前模型上下文时，降级到上下文窗口**更大**的候选（装不下的候选被跳过）；由于路由本身健康，该切换是请求级的：不冷却、不浪费半开探针（见 [降级触发码](#降级触发码triggercodes)）。
 - **冷却与回主**：被切离/失败的模型在冷却期内不再入选；`revertPolicy: cooldown-expiry` 冷却到期后自动回主模型。
 - **宿主子代理模型策略（dsh 0.1.2）**：当宿主 `subagent-model-selection` 策略启用时，其允许列表对每个插件发起的 subagent 路由都是硬约束——显式授权的派发路由保持为链头（跳过角色注入），继承注入的链头与失败切换目标都与生效允许列表求交集，交集为空则跳过注入/切换（warn 日志 + 只读卡片警告；绝不发送允许列表之外的请求）。策略存在但不可读时 fail-closed。策略关闭/缺省时，注入与失败切换的选择与 0.3.5 完全一致。覆盖路径上的 `reasoningEffort` 遵循上游 routeChanged 规则（同路由 → 保留；跨路由 → 除非显式指定否则丢弃）。见 [宿主子代理模型策略](#宿主子代理模型策略dsh-012)。

package/dist/client/SubagentRoleBadge.d.ts

@@ -1,22 +1,47 @@
-import type { ReactNode } from 'react';
-import type { PropsLocale, PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots';
-import type { FallbacksSettingsController } from './fallbacks-store.ts';
 /**
- * Injected dependencies of {@link SubagentRoleBadge} (slot `inject`): the
- * shared controller, the same seam the settings card and the General row use.
- * The badge reads through {@link FallbacksSettingsController.fetchSubagentRole}
- * — the controller's rpc face (the same `/api` caller the store rides); no
- * second channel, no extra inject member.
+ * Session-header subagent role badge (plan subagent-role-badge T3; durable
+ * channel plan role-based-subagent-adoption Task 3b): a compact read-only pill
+ * in `conversation.session.header.actions` showing which Subagent role the
+ * viewed session's dispatch resolved, hovering as `role → latest request route`.
+ *
+ * Contract notes (verified 2026-09-09 against the harness checkout):
+ * - The slot is `kind: 'list'`, `scope: 'session'`, owner props an empty marker
+ *   (`ConversationHeaderActionOwnerProps`, `children?: never`) — the header
+ *   renders occupants with `renderSlot(..., {})`, so ALL data flows through the
+ *   session standard kit.
+ * - Every `scope: 'session'` occupant receives the session standard kit
+ *   (`useSession` + `useProjection`; ui-session `src/client/index.ts:112-119`,
+ *   merged into the runtime share by ui-slots' `PropsRuntime`). The compiled
+ *   peer types do not carry that merge into this plugin's typecheck program
+ *   (ui-session is deliberately not a plugin peer), so both seats are read
+ *   STRUCTURALLY and guarded — a version-skewed host without them renders
+ *   nothing, never throws.
+ * - Data: the host's `fallbacksSubagentRole` projection (Task 3b), folded
+ *   server-side out of the child's own durable log — the ONE role source. The
+ *   session kit binds the hook to the VIEWED session (`binding.session.
+ *   projections.faceOf(key)`), so no `sessionId` plumbing, no effect, no state,
+ *   and no polling: a settled child's follow opening snapshot already carries
+ *   the value, and a running child's change frame updates the pill. An absent
+ *   key (host without the unit, or no notice row) reads as "no pill".
+ * - Hook order is render-independent (Task 3b L2 review C-1): the seat is a real
+ *   hook, so BOTH projection reads are unconditional and only their derived
+ *   values are guarded — a conditional second read would change the hook count
+ *   on the very re-render that publishes a running child's role.
+ * - The hover route comes from the host's EXISTING `modelSelection` projection
+ *   (`lastUsed` — the route of the LATEST recorded request), NOT from the
+ *   dispatch-time route: it is a separate, richer fact, and the label says so.
+ * - Render-only discipline (C4 pattern, same as `ConversationFallbackSwitch`):
+ *   the badge contributes a view; no message construction, no model-context
+ *   injection. Degrade-never-crash: a missing/foreign projection value or an
+ *   `inherit` role renders `null` — the actions row collapses cleanly.
  */
-export interface SubagentRoleBadgeInjected {
-    /** The shared controller (its `fetchSubagentRole` rides the gateway channel). */
-    controller: FallbacksSettingsController;
-}
-/** Props delivered by the utilities slot outlet: runtime share + locale seat + inject face. */
-export type SubagentRoleBadgeProps = PropsRuntime<'conversation.session.header.utilities'> & PropsLocale<'fallbacks'> & SubagentRoleBadgeInjected;
+import type { ReactNode } from 'react';
+import type { PropsLocale, PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots';
+/** Props delivered by the actions slot outlet: runtime share + locale seat. */
+export type SubagentRoleBadgeProps = PropsRuntime<'conversation.session.header.actions'> & PropsLocale<'fallbacks'>;
 /**
  * Render the viewed session's dispatch-resolved role badge.
- * @param props - composed slot props (the `sessionId` session-kit seat is
+ * @param props - composed slot props (the session-kit `useProjection` seat is
  *   read structurally — see the module docblock).
  * @returns the badge element, or `null` when there is nothing to show.
  */

package/dist/client/fallbacks-store.d.ts

@@ -169,47 +169,6 @@ export type SubagentPolicyView = {
  * throws on an old or misshapen field (old-payload tolerance).
  */
 export declare function parseSubagentPolicyWire(value: unknown): SubagentPolicyView | undefined;
-/**
- * One dispatch-resolved subagent role record as the session-header badge
- * reads it (plan subagent-role-badge T3) — a structural twin of the gateway
- * wire type, parsed from unknown, never imported from host modules
- * (`src/client/**` consumes the gateway channel only — the
- * `SubagentPolicyView` precedent). `model` is optional on the wire (gateway
- * version skew); the writer always sets it.
- */
-export interface SubagentRoleView {
-    /** The dispatch-resolved role id (never `inherit` — the writer skips it). */
-    role: string;
-    /** The route the subagent actually runs (override target, else the seed). */
-    model?: {
-        provider: string;
-        model: string;
-    };
-    /** Record time, Unix epoch milliseconds. */
-    at: number;
-}
-/**
- * Shape-guard one wire role record (`fallbacks/subagent-roles` readback).
- * A non-object, a blank/non-string `role`, or a non-number `at` fails the
- * WHOLE record (`undefined` → the badge renders nothing). A present-but-
- * malformed `model` drops the FIELD while the record still parses (the
- * `parseSeedsWire` `source` rule) — the badge then hovers the role alone
- * instead of disappearing. Records are NORMALIZED to the known keys, so a
- * wire record can never smuggle a non-string `model` past the guard's type.
- */
-export declare function parseSubagentRoleRecord(value: unknown): SubagentRoleView | undefined;
-/**
- * Read this session's dispatch-resolved role record through the plugin
- * gateway channel (plan subagent-role-badge T3): the batch-of-ids endpoint
- * called with the one id the badge cares about. NEVER throws — a channel
- * down, an old gateway without the endpoint (rpc failure), or a malformed
- * payload all resolve `undefined` (the badge renders nothing —
- * degrade-never-crash, the fail-closed shape of `parseSubagentPolicyWire`).
- * @param rpc - the connection's generic RPC caller (`/api` channel).
- * @param sessionId - the session whose record to read.
- * @returns the parsed record, or `undefined` when absent/failed.
- */
-export declare function fetchSubagentRoleRecord(rpc: ClientConnectionRpc, sessionId: string): Promise<SubagentRoleView | undefined>;
 /**
  * The provider dropdown's offer set (spec §2.5 D-4): catalog providers whose
  * settings profile resolves in the describe namespaces — the Models page's
@@ -548,18 +507,6 @@ export declare class FallbacksSettingsController {
      * merge cannot express). Same error handling as {@link save} (KD-G3).
      */
     resetToDefaults(): Promise<void>;
-    /**
-     * Read one session's dispatch-resolved subagent role record through the
-     * gateway channel (plan subagent-role-badge T3 — the session-header badge's
-     * data face). Thin delegate over {@link fetchSubagentRoleRecord} on the
-     * SAME rpc caller the store rides: the batch-of-ids readback called with
-     * the one id the badge cares about. Never throws — a channel down, an old
-     * gateway without the endpoint, or a malformed payload all resolve
-     * `undefined` (the badge renders nothing).
-     * @param sessionId - the session whose record to read.
-     * @returns the parsed record, or `undefined` when absent/failed.
-     */
-    fetchSubagentRole(sessionId: string): Promise<SubagentRoleView | undefined>;
     /** Stop in-flight responses from publishing after plugin disposal. */
     dispose(): void;
     /**

package/dist/client/index.d.ts

@@ -36,7 +36,7 @@ import type { Context as ClientContext } from '@deepseek-ai/cordis';
 export type { FallbacksCardInjected, FallbacksCardProps } from './FallbacksCard.tsx';
 export type { GeneralFallbacksRowInjected, GeneralFallbacksRowProps } from './GeneralFallbacksRow.tsx';
 export type { ConversationFallbackSwitchProps, FallbacksSwitchChatData, } from './ConversationFallbackSwitch.tsx';
-export type { SubagentRoleBadgeInjected, SubagentRoleBadgeProps } from './SubagentRoleBadge.tsx';
+export type { SubagentRoleBadgeProps } from './SubagentRoleBadge.tsx';
 export type { FallbacksSettingsState } from './fallbacks-store.ts';
 export { FallbacksSettingsController, FALLBACKS_SETTINGS_NS } from './fallbacks-store.ts';
 /**

package/dist/client/index.js

@@ -610,48 +610,6 @@ window.__ModuleLoader__.load({
 			return parseSubagentPolicyWire(value.subagentPolicy);
 		}
 		/**
-		* Shape-guard one wire role record (`fallbacks/subagent-roles` readback).
-		* A non-object, a blank/non-string `role`, or a non-number `at` fails the
-		* WHOLE record (`undefined` → the badge renders nothing). A present-but-
-		* malformed `model` drops the FIELD while the record still parses (the
-		* `parseSeedsWire` `source` rule) — the badge then hovers the role alone
-		* instead of disappearing. Records are NORMALIZED to the known keys, so a
-		* wire record can never smuggle a non-string `model` past the guard's type.
-		*/
-		function parseSubagentRoleRecord(value) {
-			if (!isRecord(value)) return void 0;
-			if (typeof value.role !== "string" || value.role.trim() === "") return void 0;
-			if (typeof value.at !== "number") return void 0;
-			const model = parsePolicyRoute(value.model);
-			return {
-				role: value.role,
-				...model === void 0 ? {} : { model },
-				at: value.at
-			};
-		}
-		/**
-		* Read this session's dispatch-resolved role record through the plugin
-		* gateway channel (plan subagent-role-badge T3): the batch-of-ids endpoint
-		* called with the one id the badge cares about. NEVER throws — a channel
-		* down, an old gateway without the endpoint (rpc failure), or a malformed
-		* payload all resolve `undefined` (the badge renders nothing —
-		* degrade-never-crash, the fail-closed shape of `parseSubagentPolicyWire`).
-		* @param rpc - the connection's generic RPC caller (`/api` channel).
-		* @param sessionId - the session whose record to read.
-		* @returns the parsed record, or `undefined` when absent/failed.
-		*/
-		async function fetchSubagentRoleRecord(rpc, sessionId) {
-			try {
-				const result = await rpc.call("/api", "fallbacks/subagent-roles", { args: { ids: [sessionId] } });
-				if (!result.ok) return void 0;
-				const value = result.value;
-				if (!isRecord(value)) return void 0;
-				return parseSubagentRoleRecord(value[sessionId]);
-			} catch {
-				return;
-			}
-		}
-		/**
 		* The provider dropdown's offer set (spec §2.5 D-4): catalog providers whose
 		* settings profile resolves in the describe namespaces — the Models page's
 		* `configured` predicate (`ui-models` store.ts): a provider is configured
@@ -1274,20 +1232,6 @@ window.__ModuleLoader__.load({
 					this.fail(error);
 				}
 			}
-			/**
-			* Read one session's dispatch-resolved subagent role record through the
-			* gateway channel (plan subagent-role-badge T3 — the session-header badge's
-			* data face). Thin delegate over {@link fetchSubagentRoleRecord} on the
-			* SAME rpc caller the store rides: the batch-of-ids readback called with
-			* the one id the badge cares about. Never throws — a channel down, an old
-			* gateway without the endpoint, or a malformed payload all resolve
-			* `undefined` (the badge renders nothing).
-			* @param sessionId - the session whose record to read.
-			* @returns the parsed record, or `undefined` when absent/failed.
-			*/
-			fetchSubagentRole(sessionId) {
-				return fetchSubagentRoleRecord(this.rpc, sessionId);
-			}
 			/** Stop in-flight responses from publishing after plugin disposal. */
 			dispose() {
 				this.readGeneration += 1;
@@ -1562,7 +1506,7 @@ window.__ModuleLoader__.load({
 			"chat.switch.summary": "{from} → {to}（{reason}）",
 			"chat.switch.summary.roleInject": "（{reason}）",
 			"chat.switch.roleMap": "{role} → {model}",
-			"subagentRole.hover": "{role} → {model}",
+			"subagentRole.hover": "{role} → {model}（最近一次请求的路由）",
 			"defaults.prefix": "默认值",
 			"save": "保存",
 			"save.saving": "保存中…",
@@ -1759,7 +1703,7 @@ window.__ModuleLoader__.load({
 			"chat.switch.summary": "{from} → {to} ({reason})",
 			"chat.switch.summary.roleInject": "({reason})",
 			"chat.switch.roleMap": "{role} → {model}",
-			"subagentRole.hover": "{role} → {model}",
+			"subagentRole.hover": "{role} → {model} (latest request route)",
 			"defaults.prefix": "Default",
 			"save": "Save",
 			"save.saving": "Saving…",
@@ -4531,6 +4475,40 @@ window.__ModuleLoader__.load({
 			});
 		}
 		//#endregion
+		//#region src/role-projection-key.ts
+		/**
+		* The session-projection contract of the subagent role pill (plan
+		* role-based-subagent-adoption Task 3b): the ONE key the host fold
+		* (`./role-projection.ts`) publishes and the session-header badge reads.
+		*
+		* PURE module — no `@deepseek-ai/*` import, no host-only dependency — because
+		* BOTH halves import it: the host through the seam's install point, the client
+		* through `SubagentRoleBadge`. Splitting the key (and the value guard) out of
+		* the host module is what keeps the client half free of the fold's host
+		* imports, and a single shared literal is what keeps the two halves from
+		* drifting into a silent "no pill".
+		*
+		* @module dsh-llm-fallbacks/role-projection-key
+		*/
+		/**
+		* The projection key the role pill reads (`useProjection(ROLE_PROJECTION_KEY)`).
+		* Lower-camel like the host's own session-scoped keys (`modelSelection`,
+		* `sessionListMetadata`); the `fallbacks` prefix keeps a third-party key
+		* unambiguous inside the shared `SessionProjectionMap`.
+		*/
+		const ROLE_PROJECTION_KEY = "fallbacksSubagentRole";
+		/**
+		* Read a projection value defensively (degrade-never-crash): only a non-blank
+		* string is a role. `undefined` — the key is not registered on this host, or no
+		* baseline/frame has carried it yet — and every foreign value read as "no
+		* role", so the pill collapses to nothing instead of naming something wrong.
+		*
+		* @param value - the raw `useProjection('<key>')` value.
+		*/
+		function readRoleProjectionValue(value) {
+			return typeof value === "string" && value.trim() !== "" ? value : void 0;
+		}
+		//#endregion
 		//#region \0dsh-css:/home/runner/work/dsh-llm-fallbacks/dsh-llm-fallbacks/src/client/SubagentRoleBadge.module.css.mjs
 		const css = "\n\n._35648278_badge {\n  display: inline-block;\n  max-width: 120px;\n  padding: 0 8px;\n  border-radius: 999px;\n  font-size: 12px;\n  line-height: 20px;\n  overflow: hidden;\n  text-overflow: ellipsis;\n  white-space: nowrap;\n  vertical-align: middle;\n  background: var(--dsw-alias-bg-module-platform);\n  color: var(--dsw-alias-label-primary);\n}\n";
 		const tagId = "dsh-llm-fallbacks/SubagentRoleBadge.module.css";
@@ -4545,101 +4523,47 @@ window.__ModuleLoader__.load({
 		//#endregion
 		//#region src/client/SubagentRoleBadge.tsx
 		/**
-		* Session-header subagent role badge (plan subagent-role-badge T3): a
-		* compact read-only pill in `conversation.session.header.utilities` showing
-		* which Subagent role the viewed session's dispatch resolved, hovering as
-		* `role → provider/model`.
-		*
-		* Contract notes (verified 2026-09-09 against the harness checkout):
-		* - The slot is `kind: 'list'`, `scope: 'session'`, owner props an empty
-		*   marker (`ConversationHeaderActionOwnerProps`, `children?: never`) — the
-		*   header renders occupants with `renderSlot(..., {})`, so ALL data flows
-		*   through this component's inject face and the session standard kit.
-		* - Every `scope: 'session'` occupant receives the session standard kit
-		*   (`sessionId` + `useSession` + `useProjection`; ui-session
-		*   `src/client/index.ts:112-119`, merged into the runtime share by ui-slots'
-		*   `PropsRuntime`) — the fetch keys off the `sessionId` prop directly (mount
-		*   + whenever the prop changes; the slot machinery remounts the occupant per
-		*   viewed session — no manual session subscription). The compiled peer types
-		*   do not carry the ui-session standard-props merge into this plugin's
-		*   typecheck program (that package is deliberately not a plugin peer), so
-		*   the seat is read structurally and guarded — a version-skewed host without
-		*   it renders nothing, never throws.
-		* - Data: `fallbacks/subagent-roles` gateway readbacks via the injected fetch
-		*   face ({@link fetchSubagentRoleRecord} — never throws): one on mount +
-		*   whenever the viewed session changes, then a BOUNDED delayed re-probe
-		*   while no record has landed (the record is written at the subagent's first
-		*   dispatch request, which can land after this header mounted).
-		* - Render-only discipline (C4 pattern, same as `ConversationFallbackSwitch`):
-		*   the badge contributes a view; no message construction, no model-context
-		*   injection. Degrade-never-crash: a missing record, an `inherit` role, or
-		*   ANY readback error renders `null` — the utilities strip collapses cleanly.
+		* The host's own durable model-selection projection key (`dsh-api-session-
+		* controller`, merged into `SessionProjectionMap`): its client value carries
+		* `lastUsed` — the route the LATEST recorded request ran on. Read through the
+		* same structural seat as the role key.
 		*/
+		const MODEL_SELECTION_PROJECTION_KEY = "modelSelection";
 		/**
-		* Bounded delayed re-probe (QC fix wave F-001): while the viewed session has
-		* no record yet, re-fetch up to {@link ROLE_RECORD_PROBES} times
-		* {@link ROLE_RECORD_PROBE_DELAY_MS} apart (~10s window) and stop on the
-		* first record, a session switch, or unmount. The record is written once, at
-		* the subagent's FIRST dispatch request — a header opened before that moment
-		* would otherwise never see the badge until remount.
+		* `provider/model` of the model-selection projection's `lastUsed`, or
+		* `undefined` when the value/key/fields are absent or foreign — the badge then
+		* hovers the role alone instead of rendering a wrong route.
 		*/
-		const ROLE_RECORD_PROBE_DELAY_MS = 2e3;
-		const ROLE_RECORD_PROBES = 5;
+		function latestRequestRoute(value) {
+			if (typeof value !== "object" || value === null) return void 0;
+			const { lastUsed } = value;
+			if (typeof lastUsed !== "object" || lastUsed === null) return void 0;
+			const { provider, model } = lastUsed;
+			if (typeof provider !== "string" || provider === "" || typeof model !== "string" || model === "") return void 0;
+			return `${provider}/${model}`;
+		}
 		/**
 		* Render the viewed session's dispatch-resolved role badge.
-		* @param props - composed slot props (the `sessionId` session-kit seat is
+		* @param props - composed slot props (the session-kit `useProjection` seat is
 		*   read structurally — see the module docblock).
 		* @returns the badge element, or `null` when there is nothing to show.
 		*/
 		function SubagentRoleBadge(props) {
-			const { t, controller } = props;
-			const seatSessionId = props.sessionId;
-			const sessionId = typeof seatSessionId === "string" && seatSessionId !== "" ? seatSessionId : void 0;
-			const [stamped, setStamped] = (0, react.useState)({
-				sessionId,
-				record: void 0
-			});
-			if (stamped.sessionId !== sessionId) setStamped({
-				sessionId,
-				record: void 0
-			});
-			const record = stamped.sessionId === sessionId ? stamped.record : void 0;
-			(0, react.useEffect)(() => {
-				if (sessionId === void 0) return;
-				let cancelled = false;
-				let timer;
-				const probe = (attempt) => {
-					controller.fetchSubagentRole(sessionId).then((next) => {
-						if (cancelled) return;
-						if (next !== void 0) {
-							setStamped({
-								sessionId,
-								record: next
-							});
-							return;
-						}
-						if (attempt >= ROLE_RECORD_PROBES) return;
-						timer = setTimeout(() => {
-							timer = void 0;
-							probe(attempt + 1);
-						}, ROLE_RECORD_PROBE_DELAY_MS);
-					});
-				};
-				probe(0);
-				return () => {
-					cancelled = true;
-					if (timer !== void 0) clearTimeout(timer);
-				};
-			}, [controller, sessionId]);
-			if (record === void 0 || record.role === "inherit") return null;
-			const model = record.model === void 0 ? void 0 : `${record.model.provider}/${record.model.model}`;
+			const { t } = props;
+			const readProjection = props.useProjection;
+			if (typeof readProjection !== "function") return null;
+			const rawRole = readProjection(ROLE_PROJECTION_KEY);
+			const rawModelSelection = readProjection(MODEL_SELECTION_PROJECTION_KEY);
+			const role = readRoleProjectionValue(rawRole);
+			if (role === void 0 || role === "inherit") return null;
+			const model = latestRequestRoute(rawModelSelection);
 			return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
 				className: SubagentRoleBadge_module_css_default.badge,
-				title: model === void 0 ? record.role : t("subagentRole.hover", {
-					role: record.role,
+				title: model === void 0 ? role : t("subagentRole.hover", {
+					role,
 					model
 				}),
-				children: record.role
+				children: role
 			});
 		}
 		//#endregion
@@ -4759,13 +4683,12 @@ window.__ModuleLoader__.load({
 					locale: NS
 				}, ConversationFallbackSwitch);
 			});
-			ctx.slots.inject("conversation.session.header.utilities", function* () {
+			ctx.slots.inject("conversation.session.header.actions", function* () {
 				yield ctx.slots.register({
-					name: "conversation.session.header.utilities",
+					name: "conversation.session.header.actions",
 					id: "fallbacks-subagent-role",
-					order: -20,
-					locale: NS,
-					inject: () => ({ controller })
+					order: -5,
+					locale: NS
 				}, SubagentRoleBadge);
 			});
 		}

package/dist/gateway.d.ts

@@ -2,7 +2,7 @@
  * T1 (plan llm-fallbacks-settings-gateway) + T3 (plan fallbacks-role-seeds) —
  * host-side `fallbacks` config gateway: the `/api/fallbacks/get` +
  * `/api/fallbacks/set` + `/api/fallbacks/reset` + `/api/fallbacks/revert-seed`
- * + `/api/fallbacks/subagent-roles` endpoints.
+ * endpoints.
  *
  * Transport: the typertGateway `/api` interceptor is the single host-wide RPC
  * slot (a plugin must NOT `connection.rpc.intercept('/api')` again — it would
@@ -43,11 +43,6 @@
  * `revert-seed` exposes revert-to-current-seed-default for one id — both
  * delegate to the per-apply `FallbacksSeedManager` passed into the
  * constructor (single point of truth, no copied manager logic).
- * `subagent-roles` (plan subagent-role-badge T2) is the read-only badge
- * readback: it projects the per-apply dispatch-resolved role-record map
- * (same T1 map the inject block writes, via the optional snapshot fn) for a
- * batch of session ids — unknown ids are omitted, an unwired or throwing
- * snapshot degrades to `{}`, never an error.
  *
  * The settings service is OPTIONAL (no settings service → the bridge source
  * stays the entry, `get` still works; `set`/`reset` fail with a clear
@@ -131,29 +126,6 @@ export type SubagentPolicySnapshotFn = () => {
         reason: string;
     };
 };
-/**
- * One dispatch-resolved subagent role record on the wire (plan
- * subagent-role-badge T2): the role the subagent's dispatch resolved and the
- * route it actually runs after the inject decision. `model` is optional on
- * the WIRE type only — the writer (T1) always sets it, but a record without
- * one still reads back as `{ role, at }` instead of failing the readback.
- */
-export type SubagentRoleRecord = {
-    role: string;
-    model?: {
-        provider: string;
-        model: string;
-    };
-    at: number;
-};
-/**
- * Live role-record snapshot the gateway reads through (plan
- * subagent-role-badge T2) — the `SubagentPolicySnapshotFn` pattern: built in
- * `apply()` over the SAME T1 map the dispatch inject block writes, no second
- * record source. Optional: constructors that omit it make the
- * `/api/fallbacks/subagent-roles` endpoint return `{}`.
- */
-export type SubagentRolesSnapshotFn = () => ReadonlyMap<string, SubagentRoleRecord>;
 /**
  * The live configuration source for the gateway (guide §7 — the same bridge
  * shape the runtime reads through). `source()` returns the live composed
@@ -212,12 +184,6 @@ export declare class FallbacksConfigGateway extends TypertRemoteService {
      * used by gateway unit tests stays byte-identical to the pre-T5 payload.
      */
     private readonly subagentPolicy;
-    /**
-     * Optional role-record snapshot (plan subagent-role-badge T2). When omitted
-     * the `subagentRoles` endpoint returns `{}` — every existing constructor
-     * call site keeps its payload byte-identical.
-     */
-    private readonly subagentRolesSnapshot;
     /**
      * @param ctx - owning context (the plugin fiber's ctx inside `apply`).
      * @param bridge - the same `FallbacksSettingsBridge` the runtime reads, so
@@ -227,11 +193,8 @@ export declare class FallbacksConfigGateway extends TypertRemoteService {
      *   copied manager logic), through the io seam built over this bridge.
      * @param subagentPolicy - live host-policy snapshot from `apply()`; omit
      *   to leave the additive field off the wire.
-     * @param subagentRoles - live dispatch-resolved role-record snapshot from
-     *   `apply()` (plan subagent-role-badge T2); omit to make the
-     *   `subagent-roles` endpoint return `{}`.
      */
-    constructor(ctx: Context, bridge: FallbacksSettingsBridge, seeds: FallbacksSeedManager, subagentPolicy?: SubagentPolicySnapshotFn, subagentRoles?: SubagentRolesSnapshotFn);
+    constructor(ctx: Context, bridge: FallbacksSettingsBridge, seeds: FallbacksSeedManager, subagentPolicy?: SubagentPolicySnapshotFn);
     /**
      * Read the current composed config (schema defaults → entry base → settings
      * user layer). No hard-gate resolver (ADR-2): the raw composed config is
@@ -290,22 +253,6 @@ export declare class FallbacksConfigGateway extends TypertRemoteService {
      *   write channel is unavailable (KD-G5).
      */
     revertSeed(id: string): Promise<FallbacksRevertResult>;
-    /**
-     * Batch readback of dispatch-resolved subagent role records (plan
-     * subagent-role-badge T2) — the read side of the session-header role badge.
-     * Ids are agent ids (≡ session ids: the same id space the dispatch inject
-     * block records under). Unknown/absent ids are OMITTED from the result,
-     * never an error — the badge renders nothing for them. No snapshot wired
-     * (pre-T2 constructors) or a throwing snapshot ⇒ `{}` — degrade-never-crash,
-     * the same fail-closed shape as `projectSubagentPolicy`.
-     * @param ids - the session ids to read (at most
-     *   {@link SUBAGENT_ROLES_MAX_IDS} entries).
-     * @returns a plain JSON object keyed by KNOWN id only, each carrying the
-     *   wire record (`role`, `at`, `model` when the record has one).
-     * @throws TypeError when `ids` is not an array of strings or the batch
-     *   exceeds {@link SUBAGENT_ROLES_MAX_IDS} entries.
-     */
-    subagentRoles(ids: string[]): Record<string, SubagentRoleRecord>;
     /**
      * Read the live composed config and normalize it to the typertGateway JSON
      * wire boundary. Containment (guide §10): a malformed stored user layer

package/dist/index.d.ts

@@ -124,29 +124,6 @@ export declare function blockedAttempts(ctx: Context): ReadonlyMap<string, Block
  * plugin is applied.
  */
 export declare function chainHeads(ctx: Context): ReadonlyMap<string, EffectiveChainHead> | undefined;
-/**
- * One dispatch-resolved subagent role record (plan subagent-role-badge T1):
- * the role `resolveRoleAtDispatch` resolved at the subagent's first request
- * and the route the subagent will actually run after the inject decision
- * (the override target when it applies, else the host seed).
- */
-type SubagentRoleRecord = {
-    role: string;
-    model: {
-        provider: string;
-        model: string;
-    };
-    at: number;
-};
-/**
- * @internal Test seam (mirrors `chainHeads`): the per-agent dispatch-resolved
- * role records written by the role-inject block (plan subagent-role-badge T1)
- * for the plugin applied to `ctx`. Not part of the plugin's public surface;
- * lets tests read the badge record without reaching into the closure (the
- * gateway readback closes over the per-apply map directly). `undefined` when
- * no plugin is applied.
- */
-export declare function subagentRoleRecords(ctx: Context): ReadonlyMap<string, SubagentRoleRecord> | undefined;
 /**
  * Count durable `llm/retry` events for the current (turn, step, provider) in
  * **always mode** (ADR-2; spec §2 clause 5). Normal-mode retries belong to