dsh-llm-fallbacks 0.6.4 → 0.6.6

package/README.md

@@ -7,7 +7,7 @@
 ![node](https://img.shields.io/badge/node-%3E%3D22-339933.svg)
 ![pnpm](https://img.shields.io/badge/pnpm-%3E%3D10-f69220.svg)
 ![dsh tui](https://img.shields.io/badge/dsh%20tui-compatible-4B32C3.svg)
-![dsh](https://img.shields.io/badge/DSH-0.2.0--rc.1-4B32C3.svg)
+![dsh](https://img.shields.io/badge/DSH-0.2.1--rc.2-4B32C3.svg)
 [![dshfind](https://dshfind.com/api/badge/omdsh-dev/dsh-llm-fallbacks?lang=en)](https://dshfind.com/zh/plugins/omdsh-dev/dsh-llm-fallbacks?ref=badge)
 
 Automatic provider/model fallback chains for dsh (DeepSeek Harness): when an agent's LLM requests keep failing — retries exhausted, auth errors, quota exceeded, rate limiting (429) — the plugin switches provider/model along the fallback chain for the current role, and the current step/turn continues on the target model: tasks are not interrupted by model problems.
@@ -94,7 +94,7 @@ Build the section up in four steps:
 
 **2. Set the all-day `rootChain`.** Leading entries are the fallback chain, walked first when a request fails; the **last** entry is the Default model.
 
-> **Conformance**: the last entry must be exactly one official model — `deepseek-official/deepseek-flash` or `deepseek-official/deepseek-v4-pro` (XOR). The settings card and gateway reject any other tail on save; a legacy non-official tail warns at startup and keeps working as a fallback-only walk, but cannot be saved as-is. The retired `deepseek-v4-flash` id is no longer a legal tail — a saved tail with it now warns, goes inert (slot rows + virtual picker), and blocks save until a legal tail is picked. The official Pro tail is catalog-served as `deepseek-official/deepseek-v4-pro` (dsh 0.2.0-rc.1; the claim re-verified against the rc.2 default catalog) and selectable in the card; a hand-written legacy `deepseek-official/deepseek-pro` tail — never catalog-served — reads back as non-conforming (no migration; re-pick the tail). The plugin does not probe catalog availability — a chain containing `deepseek-official/deepseek-v4-pro` dispatches to it like any other exact entry, and on the virtual route the `stream()` delegate serves the first dispatchable exact head of the effective chain, so a chain with a working entry before Pro still routes to that earlier entry.
+> **Conformance**: the last entry must be exactly one official model — `deepseek-official/deepseek-flash` or `deepseek-official/deepseek-v4-pro` (XOR). The settings card and gateway reject any other tail on save; a legacy non-official tail warns at startup and keeps working as a fallback-only walk, but cannot be saved as-is. The retired `deepseek-v4-flash` id is no longer a legal tail — a saved tail with it now warns, goes inert (slot rows + virtual picker), and blocks save until a legal tail is picked. The official Pro tail is catalog-served as `deepseek-official/deepseek-v4-pro` (dsh 0.2.0-rc.2) and selectable in the card; a hand-written legacy `deepseek-official/deepseek-pro` tail — never catalog-served — reads back as non-conforming (no migration; re-pick the tail). The plugin does not probe catalog availability — a chain containing `deepseek-official/deepseek-v4-pro` dispatches to it like any other exact entry, and on the virtual route the `stream()` delegate serves the first dispatchable exact head of the effective chain, so a chain with a working entry before Pro still routes to that earlier entry.
 
 **3. Add `timeSlots` (optional).** Rows rotate the effective root chain by wall-clock windows. Preset rows use frozen UTC+8 windows (only their chain is editable; while a preset row exists, `tz` locks to `Asia/Shanghai`); custom rows take `start`/`end` (may wrap midnight) and an optional `days` list. The first row whose window contains the current moment wins; no match → the all-day `rootChain`. Rotation is a routing seed — it applies on the next root request and consumes no cooldown (see [Time slots](#time-slots)).
 
@@ -187,7 +187,7 @@ The durable fix belongs upstream at the migration edges (the frozen V0→V1 edge
 - **Chain as root primary from the picker**: whenever the plugin has content configured, 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.
-- **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 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 a scoped system-prompt section at the `deployment:persona-prefix` slot — the same slot the deployment persona uses, so the role persona **replaces** the deployment prefix for that child instead of stacking under it. 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). That section lives on the child's own context, so the persona is **not durable**: a role child resumed after a host restart runs without its role persona (the resumed descriptor cannot carry one). A same-named section the child's scope already holds (a persisted descriptor) counts as delivered; any other registration failure is contained — the child runs unchanged and its notice row carries the ` (persona not applied)` suffix. Role resolution and the catalog record still apply, but two accepted boundaries get no persona delivery at all: an external (acp) child creates no local agent, so it gets **no persona, no notice row and no badge**, and a host that never mounts the `systemPrompt` service runs the child with no persona and **no** ` (persona not applied)` suffix (issue `I-000059`).
 - **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)).

package/README.zh-CN.md

@@ -7,7 +7,7 @@
 ![node](https://img.shields.io/badge/node-%3E%3D22-339933.svg)
 ![pnpm](https://img.shields.io/badge/pnpm-%3E%3D10-f69220.svg)
 ![dsh tui](https://img.shields.io/badge/dsh%20tui-compatible-4B32C3.svg)
-![dsh](https://img.shields.io/badge/DSH-0.1.7--rc.1-4B32C3.svg)
+![dsh](https://img.shields.io/badge/DSH-0.2.1--rc.2-4B32C3.svg)
 [![dshfind](https://dshfind.com/api/badge/omdsh-dev/dsh-llm-fallbacks?lang=zh)](https://dshfind.com/zh/plugins/omdsh-dev/dsh-llm-fallbacks?ref=badge)
 
 dsh（DeepSeek Harness）的自动模型降级插件：当 root agent 或 subagent 的模型请求持续失败（重试耗尽、权限、配额超限、限流 429）时，按角色/模型 fallback 链自动切换 provider/model，当前 step/turn 在目标模型上继续完成——任务不因模型问题中断。
@@ -187,7 +187,7 @@ pnpm repair:session-logs -- --drop-legacy-events --apply --backup  # 此处必
 - **选择器里把链当主模型**：只要插件配置了内容，宿主模型选择器（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 的派发声明了本插件已知的角色（Assignment 的 `**Execute as**: <id>` 字段）时，该角色的 `persona` 会安装为子代理自身的人格——角色就是子代理的身份，而不只是路由决策；注入与路由无关：`chain` 为空的角色与带链角色的人格注入完全一致（链只负责选模型）。调用方已设置的人格永不覆盖；宿主 provider 无法承载人格时跳过注入，派发照常原生运行。
+- **角色人格注入到子代理（与链无关）**：当 subagent 的派发声明了本插件已知的角色（Assignment 的 `**Execute as**: <id>` 字段）时，该角色的 `persona` 会以作用域化的 system-prompt section 安装到子代理上，位置是 `deployment:persona-prefix` 槽位——与部署人格同一个槽位，因此角色人格**替换**该子代理的部署前缀，而不是叠加在其下。角色就是子代理的身份，而不只是路由决策；注入与路由无关：`chain` 为空的角色与带链角色的人格注入完全一致（链只负责选模型）。该 section 只存在于子代理自身的上下文中，因此人格**不持久**：宿主重启后恢复的角色子代理将不带其角色人格运行（恢复的 descriptor 无法承载人格）。子代理作用域中已有同名 section（持久化的 descriptor）时视为已投递；其他注册失败都会被兜住——子代理照常运行，其 notice 行会带上 ` (persona not applied)` 后缀。角色解析与 catalog 记录仍然生效，但两类已接受的边界完全没有人格投递：external（acp）子代理不创建本地 agent，因此**没有人格、没有 notice 行、也没有徽标**；宿主若从未挂载 `systemPrompt` 服务，子代理将不带人格运行，且**不会**带上 ` (persona not applied)` 后缀（issue `I-000059`）。
 - **角色在子代理自己的会话中声明**：声明了角色的派发会让子代理自身的会话得到恰好一条插件 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)）。

package/dist/index.js

@@ -1,6 +1,8 @@
 import { createRequire } from "node:module";
 import z from "@deepseek-ai/schemastery";
 import { LlmAdapter, LlmError, boundContextSummary, createUserMessage } from "@deepseek-ai/dsh-llm";
+import { randomUUID } from "node:crypto";
+import { PERSONA_PREFIX_SECTION } from "@deepseek-ai/dsh-system-prompt";
 import { TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
 //#region .build/host/selectors.js
 var SelectorError = class extends Error {
@@ -828,7 +830,7 @@ function buildRoleNotice(role, personaNotApplied) {
 		}
 	});
 }
-function errorMessage$2(error) {
+function errorMessage$3(error) {
 	return error instanceof Error ? error.message : String(error);
 }
 function installRoleNotice(ctx, options) {
@@ -855,7 +857,7 @@ function installRoleNotice(ctx, options) {
 				messages: [...decision.messages, notice]
 			};
 		} catch (error) {
-			debug(`llm-fallbacks: role notice for agent "${agent.id}" skipped (contained, the step is unchanged): ${errorMessage$2(error)}`);
+			debug(`llm-fallbacks: role notice for agent "${agent.id}" skipped (contained, the step is unchanged): ${errorMessage$3(error)}`);
 			return decision;
 		}
 	}, { prepend: true });
@@ -942,7 +944,7 @@ const roleProjectionUnit = {
 		view: (state) => state === null ? null : state.role ?? null
 	}
 };
-function errorMessage$1(error) {
+function errorMessage$2(error) {
 	return error instanceof Error ? error.message : String(error);
 }
 function installRoleProjection(ctx, options = {}) {
@@ -962,12 +964,12 @@ function installRoleProjection(ctx, options = {}) {
 				}
 				return registry.register(roleProjectionUnit);
 			} catch (error) {
-				debug(`llm-fallbacks: role projection not registered (contained): ${errorMessage$1(error)}`);
+				debug(`llm-fallbacks: role projection not registered (contained): ${errorMessage$2(error)}`);
 				return () => {};
 			}
 		});
 	} catch (error) {
-		debug(`llm-fallbacks: role projection install skipped (contained): ${errorMessage$1(error)}`);
+		debug(`llm-fallbacks: role projection install skipped (contained): ${errorMessage$2(error)}`);
 	}
 	return () => {
 		try {
@@ -1066,7 +1068,7 @@ function parentSessionIdOf(request) {
 function correlationKey(parentSessionId, label) {
 	return `${parentSessionId}\u0000${label}`;
 }
-function errorMessage(error) {
+function errorMessage$1(error) {
 	return error instanceof Error ? error.message : String(error);
 }
 const subagentSeamStores = new WeakMap();
@@ -1100,20 +1102,20 @@ function installSubagentSeam(ctx, options) {
 		} catch {}
 	};
 	const reportDegrade = (error) => {
-		debug(`llm-fallbacks: subagent role seam degraded to the native path (start unaffected): ${errorMessage(error)}`);
+		debug(`llm-fallbacks: subagent role seam degraded to the native path (start unaffected): ${errorMessage$1(error)}`);
 	};
-	const recordChild = (childSessionId, role, at, personaNotApplied) => {
-		const existing = records.get(childSessionId);
-		records.set(childSessionId, {
+	const recordChild = (childId, role, at, personaMissed) => {
+		const existing = records.get(childId);
+		records.set(childId, {
 			role,
 			at,
 			firstNoticePending: existing?.firstNoticePending ?? true,
-			...personaNotApplied || existing?.personaNotApplied === true ? { personaNotApplied: true } : {}
+			...existing?.personaNotApplied === true || personaMissed === true ? { personaNotApplied: true } : {}
 		});
 	};
-	const beginCorrelation = (request, role, personaNotApplied) => {
-		const parentSessionId = parentSessionIdOf(request);
-		const label = typeof request?.label === "string" ? request.label : void 0;
+	const beginCorrelation = (spec, role, at) => {
+		const parentSessionId = parentSessionIdOf(spec?.request);
+		const label = typeof spec?.label === "string" ? spec.label : void 0;
 		if (parentSessionId === void 0 || label === void 0 || label === "") return void 0;
 		const key = correlationKey(parentSessionId, label);
 		if (!pending.has(key) && pending.size >= 64) {
@@ -1123,8 +1125,7 @@ function installSubagentSeam(ctx, options) {
 		pending.delete(key);
 		pending.set(key, {
 			role,
-			at: Date.now(),
-			personaNotApplied
+			at
 		});
 		return key;
 	};
@@ -1168,68 +1169,13 @@ function installSubagentSeam(ctx, options) {
 		}
 		onValue(result);
 	};
-	const personaGate = (service, providerName, surface) => {
-		if (typeof service.getProvider !== "function") return "unavailable";
-		const provider = service.getProvider(providerName);
-		if (provider === void 0) return "unknown";
-		if (surface === "one-shot") return provider.capabilities?.persona === true ? "ok" : "unsupported";
-		return typeof provider.prepareContinuable === "function" ? "ok" : "unsupported";
-	};
-	const withRolePersona = (service, providerName, request, role, surface) => {
-		if (request.persona !== void 0) return {
-			request,
-			personaNotApplied: false
-		};
-		const readRoles = options.roles;
-		if (readRoles === void 0) return {
-			request,
-			personaNotApplied: false
-		};
-		const persona = personaForRole(readRoles(), role);
-		if (persona === void 0) return {
-			request,
-			personaNotApplied: false
-		};
-		const gate = personaGate(service, providerName, surface);
-		if (gate === "unknown") {
-			debug(`llm-fallbacks: no subagent provider '${providerName}' is registered on the ${surface} start — role persona for '${role}' not delivered (the native start fails loud its own way)`);
-			return {
-				request,
-				personaNotApplied: true
-			};
-		}
-		if (gate === "unavailable") {
-			debug(`llm-fallbacks: role persona for '${role}' skipped on the ${surface} start — the '${SUBAGENT_SEAM_SERVICE}' runtime exposes no provider lookup, so the persona capability cannot be verified (the start proceeds unchanged)`);
-			return {
-				request,
-				personaNotApplied: true
-			};
-		}
-		if (gate === "unsupported") {
-			debug(surface === "one-shot" ? `llm-fallbacks: subagent provider '${providerName}' lacks the persona capability on the ${surface} start — role persona for '${role}' skipped (the start proceeds unchanged)` : `llm-fallbacks: subagent provider '${providerName}' does not support continuable children on the ${surface} surface — role persona for '${role}' skipped (the native continuable start fails loud its own way)`);
-			return {
-				request,
-				personaNotApplied: true
-			};
-		}
-		debug(`llm-fallbacks: role persona delivered via the native subagent persona channel for role '${role}' (${surface} start on provider '${providerName}')`);
-		return {
-			request: {
-				...request,
-				persona
-			},
-			personaNotApplied: false
-		};
-	};
-	const mergePersonaAtSeam = (service, providerName, request, role, surface) => {
+	const isLocalBackend = (service, providerName) => {
 		try {
-			return withRolePersona(service, providerName, request, role, surface);
+			if (typeof service.getProvider !== "function") return false;
+			return typeof service.getProvider(providerName)?.prepareContinuable === "function";
 		} catch (error) {
 			reportDegrade(error);
-			return {
-				request,
-				personaNotApplied: false
-			};
+			return false;
 		}
 	};
 	const wrapService = (value) => {
@@ -1241,61 +1187,71 @@ function installSubagentSeam(ctx, options) {
 			return value;
 		}
 		const service = value;
-		if (typeof service.start !== "function") {
+		if (typeof service.startActivation !== "function") {
 			if (!unreadableServiceLogged) {
 				unreadableServiceLogged = true;
-				debug(`llm-fallbacks: subagent role seam skipped — '${SUBAGENT_SEAM_SERVICE}' is not a start-capable runtime`);
+				debug(`llm-fallbacks: subagent role seam skipped — '${SUBAGENT_SEAM_SERVICE}' is not an activation-capable runtime`);
 			}
 			return value;
 		}
 		const cached = wrappers.get(value);
 		if (cached !== void 0) return cached;
 		const wrapper = Object.create(value);
-		wrapper.start = (name, request) => {
-			const role = resolveRoleAtSeam(request);
-			if (role === void 0) return service.start(name, request);
-			const persona = mergePersonaAtSeam(service, name, request, role, "one-shot");
+		wrapper.startActivation = (spec) => {
+			const role = resolveRoleAtSeam(spec?.request) ?? (typeof spec?.childId === "string" ? records.get(spec.childId)?.role : void 0);
+			if (role === void 0) return service.startActivation(spec);
+			const at = Date.now();
+			let effectiveSpec = spec;
+			let reservedId;
+			let reservationPersonaMissed;
+			try {
+				if (isLocalBackend(service, spec.provider)) {
+					reservedId = spec.childId ?? randomUUID();
+					if (reservedId !== spec.childId) effectiveSpec = {
+						...spec,
+						childId: reservedId
+					};
+					recordChild(reservedId, role, at);
+				}
+			} catch (error) {
+				if (reservedId !== void 0) records.delete(reservedId);
+				effectiveSpec = spec;
+				reservedId = void 0;
+				reportDegrade(error);
+				try {
+					reservationPersonaMissed = personaForRole(options.roles?.() ?? [], role) !== void 0;
+				} catch (personaError) {
+					reportDegrade(personaError);
+				}
+			}
 			let pendingKey;
 			try {
-				pendingKey = beginCorrelation(request, role, persona.personaNotApplied);
+				pendingKey = beginCorrelation(spec, role, at);
 			} catch (error) {
 				reportDegrade(error);
 			}
 			let result;
 			try {
-				result = service.start(name, persona.request);
+				result = service.startActivation(effectiveSpec);
 			} catch (error) {
 				endCorrelation(pendingKey);
+				if (reservedId !== void 0) records.delete(reservedId);
 				throw error;
 			}
 			try {
-				observeStartResult(result, (childSessionId) => {
+				observeStartResult(result, (childId) => {
+					endCorrelation(pendingKey);
+					recordChild(childId, role, at, reservationPersonaMissed);
+				}, () => {}, () => {
 					endCorrelation(pendingKey);
-					recordChild(childSessionId, role, Date.now(), persona.personaNotApplied);
-				}, () => {}, () => endCorrelation(pendingKey));
+					if (reservedId !== void 0) records.delete(reservedId);
+				});
 			} catch (error) {
 				endCorrelation(pendingKey);
 				reportDegrade(error);
 			}
 			return result;
 		};
-		const startContinuable = service.startContinuable;
-		if (typeof startContinuable === "function") wrapper.startContinuable = (spec) => {
-			const role = resolveRoleAtSeam(spec?.request) ?? (typeof spec?.childId === "string" ? records.get(spec.childId)?.role : void 0);
-			if (role === void 0) return startContinuable.call(service, spec);
-			const outcome = mergePersonaAtSeam(service, spec.provider, spec.request, role, "continuable");
-			const effectiveSpec = outcome.request === spec.request ? spec : {
-				...spec,
-				request: outcome.request
-			};
-			const result = startContinuable.call(service, effectiveSpec);
-			try {
-				observeStartResult(result, (childSessionId) => recordChild(childSessionId, role, Date.now(), outcome.personaNotApplied), () => {}, () => {});
-			} catch (error) {
-				reportDegrade(error);
-			}
-			return result;
-		};
 		wrappers.set(value, wrapper);
 		return wrapper;
 	};
@@ -1322,7 +1278,7 @@ function installSubagentSeam(ctx, options) {
 				const claim = pending.get(key);
 				if (claim === void 0) return;
 				pending.delete(key);
-				recordChild(childSessionId, claim.role, claim.at, claim.personaNotApplied);
+				recordChild(childSessionId, claim.role, claim.at);
 			} catch (error) {
 				reportDegrade(error);
 			}
@@ -1347,6 +1303,96 @@ function installSubagentSeam(ctx, options) {
 	return seam;
 }
 //#endregion
+//#region .build/host/role-persona.js
+function errorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+const rolePersonaStates = new WeakMap();
+function rolePersonaStateFor(root) {
+	const existing = rolePersonaStates.get(root);
+	if (existing !== void 0) return existing;
+	const created = new Map();
+	rolePersonaStates.set(root, created);
+	return created;
+}
+function installRolePersona(ctx, options) {
+	const root = ctx.root;
+	const registered = rolePersonaStateFor(root);
+	const owner = {};
+	const fibers = new Map();
+	const debug = (message) => {
+		try {
+			options.debug?.(message);
+		} catch {}
+	};
+	const contain = (agent, record, error) => {
+		debug(`llm-fallbacks: role persona for agent "${agent.id}" (role "${record.role}") not applied — contained, the child runs unchanged: ${errorMessage(error)}`);
+		record.personaNotApplied = true;
+	};
+	const release = (id) => {
+		const fiber = fibers.get(id);
+		if (fiber === void 0) return;
+		fibers.delete(id);
+		fiber.dispose().catch((error) => {
+			debug(`llm-fallbacks: role persona section for agent "${id}" not withdrawn (contained): ${errorMessage(error)}`);
+		});
+	};
+	const installPersona = async (agent) => {
+		const record = options.records.get(agent.id);
+		if (record === void 0) return;
+		if (registered.has(agent.id)) return;
+		let persona;
+		try {
+			persona = personaForRole(options.roles(), record.role);
+		} catch (error) {
+			debug(`llm-fallbacks: role persona for agent "${agent.id}" not resolved — contained, the child runs unchanged: ${errorMessage(error)}`);
+			return;
+		}
+		if (persona === void 0) return;
+		const text = persona;
+		registered.set(agent.id, owner);
+		try {
+			const fiber = agent.ctx.inject(["systemPrompt"], (scope) => {
+				try {
+					scope.systemPrompt.section({
+						name: PERSONA_PREFIX_SECTION,
+						order: scope.systemPrompt.getSectionOrder("DEPLOYMENT_PERSONA_PREFIX"),
+						text
+					});
+				} catch (error) {
+					if (error instanceof Error && error.message === `prompt section "${PERSONA_PREFIX_SECTION}" is already registered in this scope`) {
+						debug(`llm-fallbacks: role persona for agent "${agent.id}" not installed — a section named "${PERSONA_PREFIX_SECTION}" already exists in its scope: ${errorMessage(error)}`);
+						return;
+					}
+					contain(agent, record, error);
+				}
+			});
+			fibers.set(agent.id, fiber);
+			await fiber;
+		} catch (error) {
+			release(agent.id);
+			contain(agent, record, error);
+		}
+	};
+	const disposers = [];
+	disposers.push(ctx.on("agent/created", async ({ agent }) => {
+		await installPersona(agent);
+	}));
+	disposers.push(ctx.on("agent/disposed", ({ agent }) => {
+		release(agent.id);
+		registered.delete(agent.id);
+	}));
+	const agents = ctx.get("agents");
+	if (typeof agents?.list === "function") for (const agent of agents.list()) installPersona(agent);
+	const dispose = () => {
+		for (const off of disposers.splice(0)) off();
+		for (const id of [...fibers.keys()]) release(id);
+		for (const [id, holder] of [...registered]) if (holder === owner) registered.delete(id);
+	};
+	ctx.effect(() => dispose, "llm-fallbacks: role persona listener");
+	return { dispose };
+}
+//#endregion
 //#region .build/host/cooldown.js
 var CooldownStore = class {
 	entries = new Map();
@@ -3151,6 +3197,11 @@ function apply(ctx, config = defaultFallbacksConfig) {
 		debug: (message) => logger.debug(message)
 	});
 	if (!subagentSeam.ownsWrapper) ctx.logger("llm-fallbacks").debug("subagent role seam wrapper already installed on this context root — this fiber registers the notice emitter and the projection unit only (multi-fiber dedupe)");
+	installRolePersona(ctx, {
+		records: subagentSeam.records,
+		roles: () => source().roles.list,
+		debug: (message) => logger.debug(message)
+	});
 	try {
 		new FallbacksConfigGateway(ctx, bridge, seeds, () => {
 			try {

package/dist/role-persona.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Role-persona delivery over `agent/created` (plan dsh-021-subagent-seam-repair
+ * Task 1).
+ *
+ * rc.1 removed `SubagentStartRequest.persona`, so the resolved dispatch role's
+ * persona is delivered as a SCOPED system-prompt section on the CHILD's own
+ * context — the shipped `file-reference-local` pattern (no request mutation, no
+ * provider capability gate, no Agent Preset). The section carries the SAME name
+ * and order the global deployment persona uses (`SystemPrompt.section`: a
+ * scoped section shadows a global section with the same name), so the child's
+ * persona REPLACES the deployment prefix instead of stacking under it — the
+ * semantics the removed request slot had.
+ *
+ * Timing: `agent/created` is a serial event awaited before the child's first
+ * prompt assembly, and this listener AWAITS the injected section fiber: cordis
+ * activates a child fiber on a later tick, so awaiting it is what makes the
+ * persona observable by the time the dispatch resolves (the shipped
+ * `file-reference-local` shape). The seam's `agent/pre-step` notice emitter
+ * therefore always observes a child whose persona section is already
+ * registered; both surfaces read the SAME ROOT-shared record map, which is what
+ * keeps the ` (persona not applied)` suffix truthful.
+ *
+ * Ownership: the injected fiber belongs to the CHILD's scope, so it does not
+ * die with this listener's fiber — each listener holds ITS OWN fibers per agent
+ * and releases them on `agent/disposed`, on plugin-fiber teardown, and on
+ * explicit `dispose()`. The root-shared claim that dedupes sibling listeners
+ * records which listener owns it, so one installer's teardown never releases
+ * another's fibers or claims, and a repeated notification never replaces the
+ * handle to the fiber that holds the live registration.
+ *
+ * Containment (the seam's degrade-never-crash invariant, and required here
+ * because a throwing serial `agent/created` listener fails agent creation):
+ * only an agent whose id hits the shared record map is touched (a miss is a
+ * silent no-op), the registry's exact same-name SCOPED section duplicate means
+ * a persona section is already on that scope (one attribution-free debug line,
+ * no verdict — the registry cannot say who registered it), and every other
+ * throw — including a failed fiber activation — is contained to ONE debug line
+ * plus the record's sticky `personaNotApplied`.
+ *
+ * @module dsh-llm-fallbacks/role-persona
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import { type SubagentSeamRecord } from './subagents-seam.ts';
+import type { FallbacksRole } from './config.ts';
+/** Options for {@link installRolePersona}. */
+export interface RolePersonaOptions {
+    /**
+     * The seam's ROOT-shared per-child records — the SAME map the notice
+     * emitter reads; the listener writes `personaNotApplied` verdicts back
+     * into it (sticky per the existing {@link SubagentSeamRecord} contract).
+     */
+    records: Map<string, SubagentSeamRecord>;
+    /** Live declared roles (`roles.list`) — the persona source, read per agent/created. */
+    roles: () => readonly FallbacksRole[];
+    /** Contained debug sink (at most one line per contained degrade). */
+    debug?: (message: string) => void;
+}
+/** The installed listener surface (explicit teardown; fiber teardown also stops it). */
+export interface RolePersona {
+    dispose(): void;
+}
+/**
+ * Install the role-persona listener on `ctx`: register the resolved role's
+ * persona as a scoped `deployment:persona-prefix` section on every created
+ * agent whose id hits the shared record map, plus a `agents.list()` backfill
+ * for children that already exist at install time.
+ *
+ * Returns the installed listener (its `dispose` withdraws this listener's OWN
+ * registrations; a fiber teardown stops it as well).
+ */
+export declare function installRolePersona(ctx: Context, options: RolePersonaOptions): RolePersona;

package/dist/subagents-seam.d.ts

@@ -1,13 +1,14 @@
 /**
  * Dispatch-seam role resolution + per-child record (plan
- * role-based-subagent-adoption Task 1).
+ * role-based-subagent-adoption Task 1; rc.1 `startActivation` migration, plan
+ * dsh-021-subagent-seam-repair Task 2).
  *
  * The seam is the documented cordis service-read waterfall
  * (`Events['internal/get']`, `@deepseek-ai/cordis`
  * `lib/types/events.d.ts`): a listener wraps the `subagents` service VALUE on
- * read and returns a prototype-delegating wrapper whose `start` /
- * `startContinuable` resolve the dispatch role from the incoming request
- * BEFORE delegating. The real service object is never mutated; readers of the
+ * read and returns a prototype-delegating wrapper whose `startActivation`
+ * resolves the dispatch role from the incoming activation spec BEFORE
+ * delegating. The real service object is never mutated; readers of the
  * `subagents` service transparently receive the wrapper.
  *
  * Role source (plan Global Constraints): the child request's prompt carries
@@ -29,34 +30,36 @@
  * ambiguity rule stands unchanged: the DISTINCT DECLARED ids must collapse to
  * exactly one, else the dispatch is a no-op — never a first-occurrence pick.
  *
- * Per-child record: the wrapped start's RESULT carries the child session id —
- * `start` resolves to a `SubagentRun` (`id` IS the published child session id
- * for a local run) and `startContinuable` to a `ContinuableStart` (`childId`).
- * The record `{ role, at, firstNoticePending }` is keyed by that id (Task 3
- * reads it to emit the one role notice row). A result carrying only a
- * `jobId` — a registry job id, NOT a session id — is never keyed: the child is
- * correlated instead through the parent-owned `subagent/catalog` session event
- * `{ childId, label }` joined on the delegating parent + request label.
+ * Per-child record + the timing rule (rc.1 `startActivation`): the record
+ * `{ role, at, firstNoticePending }` is keyed by the child id (Task 3 reads it
+ * to emit the one role notice row). The child is created INSIDE the native
+ * call — `manager.startLocal` mints/uses `spec.childId` and only then resolves
+ * the activation — so `agent/created` fires BEFORE any `.then` on this side
+ * could key a record off the resolved `SubagentActivation.childId`. The
+ * wrapper therefore reserves the child id itself for a LOCAL backend (the
+ * provider exposes `prepareContinuable`; a reserved id on any other backend is
+ * rejected with `UNSUPPORTED_CAPABILITY`) and writes the record SYNCHRONOUSLY
+ * before delegating, deleting it when the native call fails. An EXTERNAL
+ * backend allocates its own child id, receives the caller's OWN spec object
+ * untouched, and has its record keyed off the resolved activation's `childId`.
  *
- * Persona delivery (plan Task 2): the SAME single resolution point merges the
- * declared role's `roles.list[].persona` (trimmed, non-empty) into the
- * request's NATIVE `persona` slot — the slot the runtime composes as the
- * scoped `deployment:persona-prefix` system-prompt section on the child. The
- * source is the RESOLVED ROLE only, so delivery is chain-independent: a
- * `chain: []` role gets its persona exactly like a chained one (no routing
- * state is read). Both native start surfaces are covered, with the gate each
- * one's fail-loud contract needs (measured on the installed
- * `@deepseek-ai/dsh-subagent`): the one-shot `start` REJECTS a
- * request carrying `persona` for a provider whose
- * `getProvider(name).capabilities.persona` is not `true` (`lib/index.js:3284,3340-3363`,
- * `assertCapabilities`), so the merge pre-checks that flag; the continuable
- * surface is composed by the continuation manager, which applies
- * `request.persona` unconditionally (`lib/index.js:1691`) and is gated by
- * the provider's `prepareContinuable` presence instead (`lib/index.js:3316-3319`).
- * A gate miss skips the persona with ONE contained debug log — never a failed
- * start. An explicit caller `persona` WINS (the slot is filled only when it is
- * absent), and every skip path returns the caller's OWN request object, so the
- * native call stays byte-identical.
+ * A result carrying no child id — a `jobId` is a registry id, NOT a session id
+ * — is never keyed: the child is correlated instead through the parent-owned
+ * `subagent/catalog` session event `{ childId, label }` joined on the
+ * delegating parent + the activation `label` (the same string the cataloged
+ * child membership carries).
+ *
+ * Persona delivery is NO LONGER this module's job (plan Task 1): rc.1 removed
+ * `SubagentStartRequest.persona`, so the resolved role's persona is registered
+ * as a scoped `deployment:persona-prefix` section on the CHILD's own context
+ * by `./role-persona.ts`, over the SAME ROOT-shared record map this module
+ * writes. That listener owns the `personaNotApplied` verdict the notice row
+ * reads — EXCEPT when a reservation failure means it can never see the child
+ * (the runtime mints its own child id and `agent/created` has already run), in
+ * which case this module resolves the same question against the live roles
+ * source and carries the verdict onto the record keyed off the RESOLVED id,
+ * before the child's first pre-step. This module writes no request field,
+ * reads no provider persona capability, and injects no agent preset.
  *
  * In-session notice row (plan Task 3): the SAME install point registers the
  * `agent/pre-step` emitter (`./role-notice.ts`) over the record map it owns, so
@@ -103,14 +106,14 @@ export interface SubagentSeamRecord {
      * The DECLARED RAW role id resolved at the dispatch seam.
      *
      * Authoritative-role precedence (CF-10, documented rather than resolved by
-     * re-branding): a `startContinuable` resume re-keys the child and may resolve
-     * a DIFFERENT declared role, and this field is then rewritten while the
+     * re-branding): a resume that reuses a reserved `childId` may resolve a
+     * DIFFERENT declared role, and this field is then rewritten while the
      * durable notice row the child's session already carries keeps the FIRST role.
      * The projection deliberately reads the notice row, so the durable role is the
      * child's announced identity and this record is only the LIVE dispatch hint
-     * (what the next start / the resume fallback would use). The two can therefore
-     * disagree after a re-dispatch until the child is disposed; no consumer may
-     * treat the record as the durable role.
+     * (what the next activation / the resume fallback would use). The two can
+     * therefore disagree after a re-dispatch until the child is disposed; no
+     * consumer may treat the record as the durable role.
      */
     role: string;
     /** When the record was written (epoch ms). */
@@ -126,20 +129,24 @@ export interface SubagentSeamRecord {
     firstNoticePending: boolean;
     /**
      * `true` when the role DECLARES a persona and that persona was NOT delivered
-     * (Task 2's capability gate declined it, or no provider was registered to
-     * carry it). Absent when there was nothing to report: the persona was
-     * delivered, the caller set one (explicit intent wins), the role declares
-     * none, or no persona source is wired. Task 3 appends
-     * ` (persona not applied)` on `true` only.
+     * onto the child. Written by the `agent/created` role-persona listener
+     * (`./role-persona.ts`) over this same map — except when a reservation
+     * failure means that listener can never see the child (the runtime mints its
+     * own child id), where the seam itself carries the verdict onto the record
+     * keyed off the RESOLVED id. The seam never delivers or reads a persona
+     * other than for that one question. Absent when there was nothing to report:
+     * the section was registered, a same-name section was already on the child's
+     * scope (whoever registered it), the listener never saw the child (an
+     * EXTERNAL backend creates no local agent), the role declares none, or no
+     * persona source is wired. Task 3 appends ` (persona not applied)` on `true`
+     * only.
      *
-     * STICKY (Task 3 review Minor 4): a record rewrite (a `startContinuable`
-     * resume re-keys the child) can only ADD this verdict, never clear it. A
-     * resume recomputes the merge outcome on its own surface — and that surface
-     * legitimately returns `false` when it delivers the CALLER's persona or when
-     * its own merge degrades — but neither retroactively installs the role's
-     * DECLARED persona on the dispatch that already reported it missing. The
-     * child's one notice row is a claim about that dispatch, so the first `true`
-     * survives; a later `false` is simply not recorded.
+     * STICKY (Task 3 review Minor 4): a record rewrite — a resume reusing the
+     * reserved `childId`, or the resolved activation re-keying the same child
+     * after `agent/created` already ran — can only ADD this verdict, never clear
+     * it. A rewrite carries no verdict of its own, and the child's one notice row
+     * is a claim about the dispatch that already reported it missing, so the first
+     * `true` survives.
      */
     personaNotApplied?: boolean;
 }
@@ -149,29 +156,29 @@ export interface SubagentPromptBlockView {
     readonly text?: string;
 }
 /**
- * Structural view of the one-shot start request (consumed fields only): the
- * `prompt` is the role-extraction source, `label` + `parent` are the
- * catalog-correlation join key, and `persona` is the NATIVE per-child persona
- * slot the role persona is merged into (plan Global Constraints: an explicit
- * caller value wins). The wrapper forwards the request object itself, so every
- * other field reaches the service unchanged.
+ * Structural view of the activation request (consumed fields only): `prompt` is
+ * the role-extraction source and `parent` is the catalog-correlation join half.
+ * The wrapper forwards the request OBJECT itself, so every other field (cwd,
+ * agentOptions, outputSchema, maxDepth, the signal) reaches the service
+ * unchanged.
  */
 export interface SubagentStartRequestView {
     readonly prompt?: readonly SubagentPromptBlockView[];
-    readonly label?: string;
     readonly parent?: {
         readonly session?: {
             readonly id?: string;
         };
     };
-    readonly persona?: string;
 }
 /**
- * Structural view of the continuable start spec (consumed fields only):
- * `childId` is the caller-reserved identity a resume already carries, used as
- * the record fallback when the resume request has no Assignment header.
+ * Structural view of the activation spec (rc.1 `SubagentActivationSpec`,
+ * consumed fields only): `childId` is the caller-reserved identity a resume
+ * already carries — also the record fallback when the request carries no
+ * Assignment header — and `label` is the catalog join's other half (the
+ * cataloged child membership carries this exact string). `signal`, `delivery`
+ * and every future field travel with the caller's spec object.
  */
-export interface ContinuableStartSpecView {
+export interface SubagentActivationSpecView {
     readonly provider: string;
     readonly label?: string;
     readonly childId?: string;
@@ -180,14 +187,16 @@ export interface ContinuableStartSpecView {
 /** Options for {@link installSubagentSeam}. */
 export interface SubagentSeamOptions {
     /**
-     * Live declared-role id map (trimmed id → DECLARED RAW id), read per start
-     * so a settings change is observed without a re-install.
+     * Live declared-role id map (trimmed id → DECLARED RAW id), read per
+     * activation so a settings change is observed without a re-install.
      */
     roleIds: () => ReadonlyMap<string, string>;
     /**
-     * Live declared roles (`roles.list`) — the persona source, read per start so
-     * a settings/persona edit is observed without a re-install. Absent ⇒ the
-     * seam only records roles (no persona delivery).
+     * Live declared roles (`roles.list`) — the SAME source `./role-persona.ts`
+     * reads. Consulted ONLY when a reservation failure means that listener can
+     * never see the child: the seam is then the only place left that can carry
+     * the persona verdict to the child's notice row. Absent (no persona source is
+     * wired) ⇒ no verdict, exactly like a listener that never saw the child.
      */
     roles?: () => readonly FallbacksRole[];
     /** Contained debug sink (at most one line per contained degrade). */
@@ -196,10 +205,12 @@ export interface SubagentSeamOptions {
 /** The installed seam (Task 3 surface + explicit teardown). */
 export interface SubagentSeam {
     /**
-     * Per-child records keyed by the child SESSION id (the wrapped start's
-     * result id). ROOT-shared (CF-5): every fiber applied over the same root reads
+     * Per-child records keyed by the child id — the reserved id this wrapper
+     * wrote before a local activation, or the `childId` a resolved activation
+     * reported. ROOT-shared (CF-5): every fiber applied over the same root reads
      * the same map. Mutable by design: Task 3 clears `firstNoticePending` after
-     * emitting the notice.
+     * emitting the notice, and the role-persona listener writes
+     * `personaNotApplied`.
      */
     readonly records: Map<string, SubagentSeamRecord>;
     /**
@@ -253,7 +264,9 @@ export declare const PENDING_CORRELATION_LIMIT = 64;
  */
 export declare function resolveDeclaredRoleFromAssignment(prompt: string, roleIds: ReadonlyMap<string, string>): string | undefined;
 /**
- * PURE, chain-independent persona lookup (plan Task 2 / Global Constraints):
+ * PURE, chain-independent persona lookup for the `agent/created` role-persona
+ * listener (`./role-persona.ts`; rc.1 delivers the persona as a scoped prompt
+ * section on the child, never as a request field):
  * the DECLARED `persona` of `roleId`, trimmed, and only when it is still
  * non-empty after the trim — a blank persona is NO persona. `roleId` is the
  * DECLARED RAW id the seam already resolved, so this is an exact id match, not

package/package.json

@@ -5,7 +5,7 @@
     "dsh",
     "dsh-plugin"
   ],
-  "version": "0.6.4",
+  "version": "0.6.6",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -64,30 +64,31 @@
     "use-sync-external-store": "^1.6.0"
   },
   "peerDependencies": {
-    "@deepseek-ai/cordis": "^4.0.2",
-    "@deepseek-ai/dsh-agent": "^0.2.0-rc.1",
-    "@deepseek-ai/dsh-api-gateway": "^0.2.0-rc.1",
-    "@deepseek-ai/dsh-api-remotes": "^0.2.0-rc.1",
-    "@deepseek-ai/dsh-api-session-controller": "^0.2.0-rc.1",
-    "@deepseek-ai/dsh-client-connection": "^0.2.0-rc.1",
-    "@deepseek-ai/dsh-client-locale": "^0.2.0-rc.1",
-    "@deepseek-ai/dsh-client-store": "^0.2.0-rc.1",
-    "@deepseek-ai/dsh-client-ui-chat": "^0.2.0-rc.1",
-    "@deepseek-ai/dsh-client-ui-conversation": "^0.2.0-rc.1",
-    "@deepseek-ai/dsh-client-ui-plugin-manager": "^0.2.0-rc.1",
-    "@deepseek-ai/dsh-client-ui-renderer": "^0.2.0-rc.1",
-    "@deepseek-ai/dsh-client-ui-settings": "^0.2.0-rc.1",
-    "@deepseek-ai/dsh-client-ui-slots": "^0.2.0-rc.1",
-    "@deepseek-ai/dsh-commands": "^0.2.0-rc.1",
-    "@deepseek-ai/dsh-llm": "^0.2.0-rc.1",
-    "@deepseek-ai/dsh-llm-retry": "^0.2.0-rc.1",
-    "@deepseek-ai/dsh-session": "^0.2.0-rc.1",
-    "@deepseek-ai/dsh-session-projection": "^0.2.0-rc.1",
-    "@deepseek-ai/dsh-settings": "^0.2.0-rc.1",
-    "@deepseek-ai/dsh-tool-subagent": "^0.2.0-rc.1",
-    "@deepseek-ai/dsh-typert-protocol": "^0.2.0-rc.1",
-    "@deepseek-ai/dsh-typert-registry": "^0.2.0-rc.1",
-    "@deepseek-ai/schemastery": "^3.18.2",
+    "@deepseek-ai/cordis": "^4.0.5",
+    "@deepseek-ai/dsh-agent": "^0.2.1-rc.2",
+    "@deepseek-ai/dsh-api-gateway": "^0.2.1-rc.2",
+    "@deepseek-ai/dsh-api-remotes": "^0.2.1-rc.2",
+    "@deepseek-ai/dsh-api-session-controller": "^0.2.1-rc.2",
+    "@deepseek-ai/dsh-client-connection": "^0.2.1-rc.2",
+    "@deepseek-ai/dsh-client-locale": "^0.2.1-rc.2",
+    "@deepseek-ai/dsh-client-store": "^0.2.1-rc.2",
+    "@deepseek-ai/dsh-client-ui-chat": "^0.2.1-rc.2",
+    "@deepseek-ai/dsh-client-ui-conversation": "^0.2.1-rc.2",
+    "@deepseek-ai/dsh-client-ui-plugin-manager": "^0.2.1-rc.2",
+    "@deepseek-ai/dsh-client-ui-renderer": "^0.2.1-rc.2",
+    "@deepseek-ai/dsh-client-ui-settings": "^0.2.1-rc.2",
+    "@deepseek-ai/dsh-client-ui-slots": "^0.2.1-rc.2",
+    "@deepseek-ai/dsh-commands": "^0.2.1-rc.2",
+    "@deepseek-ai/dsh-llm": "^0.2.1-rc.2",
+    "@deepseek-ai/dsh-llm-retry": "^0.2.1-rc.2",
+    "@deepseek-ai/dsh-session": "^0.2.1-rc.2",
+    "@deepseek-ai/dsh-session-projection": "^0.2.1-rc.2",
+    "@deepseek-ai/dsh-settings": "^0.2.1-rc.2",
+    "@deepseek-ai/dsh-system-prompt": "^0.2.1-rc.2",
+    "@deepseek-ai/dsh-tool-subagent": "^0.2.1-rc.2",
+    "@deepseek-ai/dsh-typert-protocol": "^0.2.1-rc.2",
+    "@deepseek-ai/dsh-typert-registry": "^0.2.1-rc.2",
+    "@deepseek-ai/schemastery": "^3.18.5",
     "react": "^18.2.0"
   },
   "devDependencies": {