@morlay/dsh-session-mode 0.0.1-alpha.4

package/dist/index.mjs

@@ -0,0 +1,368 @@
+import { t as SESSION_MODE_PATH } from "./shared-ChCbbJa8.mjs";
+import { Service } from "@deepseek-ai/cordis";
+import { ReasoningEffortId } from "@deepseek-ai/dsh-llm";
+import { z } from "zod";
+import z$1 from "@deepseek-ai/schemastery";
+import { PERSONA_PREFIX_SECTION, PERSONA_SUFFIX_SECTION } from "@deepseek-ai/dsh-system-prompt";
+//#region src/modes.ts
+const personaSchema = z$1.object({
+	prefix: z$1.string().default(""),
+	suffix: z$1.string().default("")
+});
+/** 角色是个封闭集合：写错的 role 在装配期就拒绝，而不是静默变成"谁都不用"。 */
+const roleSchema = z$1.union([z$1.const("main"), z$1.const("subagent")]);
+/** 默认模型的形状与全局 `agent-default-model` 一致；省略 effort 就跟 provider 默认。 */
+const modelSchema = z$1.object({
+	provider: z$1.string().required(),
+	model: z$1.string().required(),
+	reasoningEffort: z$1.string()
+});
+const modeSchema = z$1.object({
+	name: z$1.string().required(),
+	description: z$1.string().default(""),
+	role: z$1.array(roleSchema).default(["main"]),
+	persona: personaSchema.default({}),
+	allowTools: z$1.array(z$1.string()).default([]),
+	instructions: z$1.boolean().default(true),
+	runtimeContext: z$1.boolean().default(true)
+});
+const Config = z$1.object({
+	default: z$1.string().required(),
+	modes: z$1.dict(modeSchema).required(),
+	models: z$1.dict(modelSchema).default({}).volatile()
+});
+/** 模式定义里不合法的地方（装配期 fail loud，而不是等到某个会话装配提示词时才发现）。 */
+function configProblem(config) {
+	/** 没写 `role` 等于默认 `["main"]`（与 schema 的默认一致）——字面量与归一化后的形状都能校验。 */
+	const roles = (id) => config.modes[id]?.role ?? ["main"];
+	const ids = Object.keys(config.modes);
+	if (ids.length === 0) return "session-mode: `modes` must declare at least one mode";
+	if (!ids.includes(config.default)) return `session-mode: \`default\` names ${JSON.stringify(config.default)}, which is not in modes (${ids.join(", ")})`;
+	const roleless = ids.filter((id) => roles(id).length === 0);
+	if (roleless.length > 0) return `session-mode: mode(s) ${roleless.join(", ")} declare no \`role\`; declare main and/or subagent instead of leaving it empty`;
+	if (!roles(config.default).includes("main")) return `session-mode: \`default\` names ${JSON.stringify(config.default)}, which does not declare role "main"; a session that can never be re-selected is a contradiction`;
+	const empty = ids.filter((id) => (config.modes[id]?.allowTools ?? []).length === 0);
+	if (empty.length > 0) return `session-mode: mode(s) ${empty.join(", ")} declare no \`allowTools\`; list the tools instead of leaving it empty`;
+	const unknown = Object.keys(config.models ?? {}).filter((id) => !ids.includes(id));
+	if (unknown.length > 0) return `session-mode: \`models\` names unknown mode(s) ${unknown.join(", ")}; available are ${ids.join(", ")}`;
+	const partial = Object.entries(config.models ?? {}).filter(([, model]) => model.provider === void 0 || model.model === void 0 || model.provider.length === 0 || model.model.length === 0).map(([id]) => id);
+	if (partial.length > 0) return `session-mode: mode(s) ${partial.join(", ")} declare \`models\` without both \`provider\` and \`model\``;
+}
+//#endregion
+//#region src/persona.ts
+const PREFIX_ORDER = "DEPLOYMENT_PERSONA_PREFIX";
+const SUFFIX_ORDER = "DEPLOYMENT_PERSONA_SUFFIX";
+/**
+* 把一段 persona 装到该 agent 的 scope 上。
+* @param agent - 目标 agent（用它的 `ctx` 定作用域）。
+* @param persona - 模式的提示词；缺省时两段都注册成空串，等于遮蔽掉部署级那层。
+* @returns 注销这两个 section 的 disposer（模式切换时先调它）。
+*/
+function installPersona(agent, persona) {
+	const prompt = agent.ctx.systemPrompt;
+	const disposers = [prompt.section({
+		name: PERSONA_PREFIX_SECTION,
+		order: prompt.getSectionOrder(PREFIX_ORDER),
+		text: persona?.prefix ?? ""
+	}), prompt.section({
+		name: PERSONA_SUFFIX_SECTION,
+		order: prompt.getSectionOrder(SUFFIX_ORDER),
+		text: persona?.suffix ?? ""
+	})];
+	return () => {
+		for (const dispose of disposers) dispose();
+	};
+}
+//#endregion
+//#region src/index.ts
+/**
+* 会话模式的 host 半：模式清单（config 里的纯数据）、会话 ↔ 模式的选择、按会话应用 persona 与收口。
+*
+* **模式不是 Cordis 子树**。旧的 `@morlay/dsh-agent-preset` 每个模式都是一行
+* `@deepseek-ai/dsh-agent-preset`，`config.plugins` 里装 persona 与 scope 行，靠 preset scope 的父链
+* 对会话生效——代价是整个官方 registry（声明式行、每 revision 一棵 Loader 子树、`isolate` realm）都在
+* 部署里。这里只留两件事：模式是一份数据，应用落在会话自己的 scope 上：
+*
+* | 事实             | 落在哪                                                                                     |
+* | ---------------- | ------------------------------------------------------------------------------------------ |
+* | 模式清单与默认值 | 本行的 `config`（装配层可整体改写；`modes.ts` 给形状与校验）                                |
+* | 各模式的默认模型 | 同一份 config 的顶层 `models`（**volatile**：设置页那张卡片改的就是它）                      |
+* | 会话当前模式     | session 事件 `session-mode/selected` + 投影 `sessionMode`（log-only，重建读投影）           |
+* | 提示词           | `persona`：把模式的 persona 注册到该 agent 的 scope（`persona.ts`）                         |
+* | 工具与注入开关   | 推给 `ctx.sessionToolScope`（`@morlay/dsh-context-assembler/scope`，行 id `context-assembler-scope`） |
+* | 页面上的选择面   | HTTP 路由 `GET/POST /session-mode`（清单与切换）+ 会话投影（当前值）                        |
+*
+* 应用时机是 `agent/created`：它早于任何一次提示词装配（装配发生在 turn 里），所以 persona 一定在该会话
+* 第一次装配之前就注册好了。模式在**空白会话**里可以切换，切换时对着已有的 agent 重新应用一遍。
+*
+* 切换只允许在空白窗口（还没开过 turn）：会话的历史是在某个模式的工具集与提示词下产生的，换了模式，那段
+* 历史就与实际装配对不上——与上游 `agentPresets.select` 的判据一致，也用同一个投影（`turnBoundary`）。
+*/
+/** Cordis 插件名：与行 id 一致。 */
+const name = "session-mode";
+/**
+* 依赖：投影服务（登记 `sessionMode`、读 `turnBoundary`）、读会话与 agent 的两个注册表，以及提示词注册表
+* （persona 的 section 注册在它上面）。
+*
+* 这些名字必须在 `inject` 里点名：cordis 的**属性访问**（`this.ctx.sessions`）要求本 fiber 声明过那个服务，
+* 未声明会抛 `cannot get property "sessions" without inject`（`ctx.get(name)` 才不需要声明）。
+*/
+const inject = [
+	"agents",
+	"sessions",
+	"sessionProjections",
+	"systemPrompt"
+];
+const sessionModeSchema = z.union([z.string(), z.null()]);
+/** 会话模式的投影：初值来自空日志（没选过就是 `null`），只被选择事件推进。 */
+const sessionModeProjection = {
+	key: "sessionMode",
+	stateSchema: sessionModeSchema,
+	init: () => null,
+	apply: (state, event) => event.type === "session-mode/selected" ? event.data.sessionMode : state,
+	wire: {
+		viewSchema: sessionModeSchema,
+		view: (state) => state
+	},
+	stateVersion: 1
+};
+/** 模式清单、默认模式、按会话读取与切换。 */
+var SessionModes = class extends Service {
+	config;
+	/** 每个 agent 已经装上的那一份（persona + 默认模型兜底；模式变了就换一份）。 */
+	installs = /* @__PURE__ */ new WeakMap();
+	constructor(ctx, config) {
+		super(ctx, "sessionModes");
+		this.config = config;
+		const problem = configProblem({
+			...config,
+			models: config.models.get()
+		});
+		if (problem !== void 0) throw new Error(problem);
+		ctx.sessionProjections.register(sessionModeProjection);
+		ctx.on("agent/created", ({ agent }) => {
+			this.installFor(agent);
+		});
+	}
+	/** 新会话用它：config 里的 `default`。 */
+	get defaultId() {
+		return this.config.default;
+	}
+	/** 选择器要的清单：只列 `main` 角色的模式（id、展示名、说明，顺序即 config 里 `modes` 的插入序）。 */
+	list() {
+		return this.idsFor("main").map((id) => {
+			const mode = this.definition(id);
+			return {
+				id,
+				name: mode.name,
+				...mode.description === "" ? {} : { description: mode.description }
+			};
+		});
+	}
+	/**
+	* 声明了某个角色的模式 id（顺序即 config 的插入序）：`main` 给用户选择器，`subagent` 给子代理候选。
+	* @param role - 目标角色。
+	* @returns 该角色下的模式 id。
+	*/
+	idsFor(role) {
+		return Object.entries(this.config.modes).filter(([, mode]) => mode.role.includes(role)).map(([id]) => id);
+	}
+	/**
+	* 同 {@link idsFor}，给的是定义——"指定 mode" 那条接缝要拿候选集。
+	* @param role - 目标角色。
+	* @returns 该角色下的模式与其定义。
+	*/
+	modesFor(role) {
+		return this.idsFor(role).map((id) => ({
+			id,
+			mode: this.definition(id)
+		}));
+	}
+	/** 页面用的清单 + 默认模式。 */
+	roster() {
+		return {
+			default: this.defaultId,
+			modes: this.list()
+		};
+	}
+	/** 按 id 取定义；未知 id 直接抛（切换路径上它就是用户的错）。 */
+	definition(id) {
+		const wanted = id ?? this.defaultId;
+		const mode = this.config.modes[wanted];
+		if (mode === void 0) throw new Error(`未知的模式 ${JSON.stringify(wanted)}；可用的是 ${Object.keys(this.config.modes).join(", ")}`);
+		return mode;
+	}
+	/** 会话当前模式：投影上有就用它，否则是部署默认。 */
+	modeOf(session) {
+		return this.ctx.sessionProjections.stateOf(session, "sessionMode") ?? this.defaultId;
+	}
+	/** 会话当前模式的定义。 */
+	modeOfSession(session) {
+		return this.definition(this.modeOf(session));
+	}
+	/**
+	* 把某个空白会话切到某个模式。
+	* @param sessionId - 目标会话（必须还没有开过 turn）。
+	* @param mode - 目标模式 id。
+	* @returns 提交后的模式 id。
+	*/
+	async select(sessionId, mode) {
+		if (!this.definition(mode).role.includes("main")) throw new Error(`模式 ${JSON.stringify(mode)} 不是用户可选的（它的 role 里没有 main）。`);
+		const session = this.ctx.sessions.get(sessionId);
+		if (session === void 0) throw new Error(`未知的会话 ${sessionId}`);
+		const boundary = this.ctx.sessionProjections.stateOf(session, "turnBoundary");
+		if (boundary !== void 0 && (boundary.openTurnStartSeq !== null || boundary.lastTurn > 0)) throw new Error("这个会话已经开始，模式不能再改；要换模式请新开一个会话。");
+		session.append("session-mode/selected", { sessionMode: mode });
+		const agent = this.ctx.agents.get(sessionId);
+		if (agent !== void 0) this.installFor(agent);
+		return mode;
+	}
+	/**
+	* 把某个活着的 agent 切到某个模式。与 {@link select} 的差别：它不要求空白会话——子代理创建时的继承
+	* 走这里，**未来的"指定 mode"入口（模型侧或配置侧）也走这里**（那条接缝还没做）。
+	* @param agent - 目标 agent。
+	* @param mode - 目标模式 id。
+	* @param options.record - 是否把这次切换写进会话日志（缺省写；只想改当前进程时给 `false`）。
+	*/
+	applyTo(agent, mode, options = {}) {
+		this.definition(mode);
+		if (options.record !== false) agent.session.append("session-mode/selected", { sessionMode: mode });
+		this.installFor(agent, mode);
+	}
+	/**
+	* 该 agent 用哪个模式：会话选过（投影上有）优先，子代理继承父，其余用部署默认。
+	*
+	* 继承要**写进子会话日志**：它是一条会话事实，冷恢复与 fork 都要靠它重建（{@link modeOf} 只读投影）。
+	*/
+	resolveModeId(agent) {
+		const selected = this.ctx.sessionProjections.stateOf(agent.session, "sessionMode");
+		if (typeof selected === "string") return selected;
+		const inherited = this.inheritedModeId(agent);
+		if (inherited === void 0) return this.defaultId;
+		agent.session.append("session-mode/selected", { sessionMode: inherited });
+		return inherited;
+	}
+	/** 子代理（有 durable 父会话）继承父当前模式；父不在场、或不是子代理时没有可继承的。 */
+	inheritedModeId(agent) {
+		const parentId = agent.session.header.parentSession;
+		if (parentId === void 0) return void 0;
+		const parent = this.ctx.agents.get(parentId);
+		return parent === void 0 ? void 0 : this.modeOf(parent.session);
+	}
+	/** 装或换该 agent 的那一份（幂等：同一模式不重复注册）。 */
+	installFor(agent, modeId = this.resolveModeId(agent)) {
+		const installed = this.installs.get(agent);
+		if (installed?.mode === modeId) return;
+		installed?.dispose();
+		const mode = this.definition(modeId);
+		const disposers = [installPersona(agent, mode.persona), this.installDefaultModel(agent, modeId)];
+		this.installs.set(agent, {
+			mode: modeId,
+			dispose: () => {
+				for (const dispose of disposers) dispose();
+			}
+		});
+		this.toolScope()?.apply(agent, mode);
+	}
+	/**
+	* 模式的默认模型（config 顶层 `models.<模式 id>`）兜底：只在会话**尚无任何模型事实**（没选过模型、也
+	* 还没跑过请求）时接管这一请求的路由；一旦用户选过（投影 `pending`）或会话已经落过 header，就不再插手。
+	*
+	* 它是**配置事实**，不写会话事件——重启后仍由 config 决定；设置页里那条会话级选择才是会话事实。
+	*
+	* 模型取自 `config.models`：那是个 volatile 引用，设置页保存时只有**引用里的值**变，这一行不重挂，
+	* 所以每次请求都现场 `.get()`（与 `llm-openai-compatible` 读 `config.providers` 同一种读法）。
+	*/
+	installDefaultModel(agent, modeId) {
+		return agent.ctx.on("agent/request", async (_payload, next) => {
+			const resolved = await next();
+			const model = this.config.models.get()[modeId];
+			if (model === void 0) return resolved;
+			const pending = this.ctx.sessionProjections.stateOf(agent.session, "modelSelection")?.pending;
+			if (pending !== void 0 && pending !== null) return resolved;
+			if (agent.session.requestHeader() !== void 0) return resolved;
+			return {
+				...resolved,
+				provider: model.provider,
+				model: model.model,
+				...model.reasoningEffort === void 0 ? {} : { reasoningEffort: ReasoningEffortId(model.reasoningEffort) }
+			};
+		});
+	}
+	/** 收口服务由 `@morlay/dsh-context-assembler/scope` 那一行发布；没装它就只有 persona。 */
+	toolScope() {
+		try {
+			return this.ctx.get("sessionToolScope");
+		} catch {
+			return;
+		}
+	}
+};
+function apply(ctx, config) {
+	registerHttpRoutes(ctx, new SessionModes(ctx, config));
+}
+function respondJson(response, status, body) {
+	response.writeHead(status, { "content-type": "application/json; charset=utf-8" });
+	response.end(JSON.stringify(body));
+}
+function requestJson(request) {
+	return new Promise((resolve, reject) => {
+		const chunks = [];
+		request.on("data", (chunk) => {
+			chunks.push(typeof chunk === "string" ? chunk : new TextDecoder().decode(chunk));
+		});
+		request.on("end", () => {
+			try {
+				resolve(chunks.length === 0 ? void 0 : JSON.parse(chunks.join("")));
+			} catch {
+				reject(/* @__PURE__ */ new TypeError("请求体不是合法 JSON。"));
+			}
+		});
+		request.on("error", reject);
+	});
+}
+function requiredString(value, field) {
+	if (typeof value !== "string" || value.length === 0) throw new TypeError(`${field} 必须是非空字符串。`);
+	return value;
+}
+async function handleRoute(modes, request, response) {
+	try {
+		if (request.method === "GET") {
+			respondJson(response, 200, modes.roster());
+			return;
+		}
+		if (request.method === "POST") {
+			const body = await requestJson(request);
+			if (typeof body !== "object" || body === null || Array.isArray(body)) throw new TypeError("请求体必须是 JSON 对象。");
+			const record = body;
+			const sessionId = requiredString(record["sessionId"], "sessionId");
+			const mode = requiredString(record["mode"], "mode");
+			respondJson(response, 200, { mode: await modes.select(sessionId, mode) });
+			return;
+		}
+		response.writeHead(405);
+		response.end();
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		respondJson(response, error instanceof TypeError ? 400 : 409, { error: message });
+	}
+}
+/**
+* 把清单与切换挂到同一张宿主路由表上。
+*
+* `webServer` **必须等**：它可能比本行晚激活，而一次性 `ctx.get` 取到 `undefined` 之后不会再试一次——
+* 路由没注册的后果是请求落到静态资源 fallback，非 GET/HEAD 一律 405。
+*/
+function registerHttpRoutes(ctx, modes) {
+	ctx.inject(["webServer"], (scope) => {
+		const webServer = scope.get("webServer");
+		if (webServer === void 0) return;
+		scope.effect(() => webServer.register({
+			kind: "exact",
+			path: SESSION_MODE_PATH,
+			handler: (request, response) => handleRoute(modes, request, response)
+		}), "session-mode: HTTP route");
+	});
+}
+//#endregion
+export { Config, SESSION_MODE_PATH, SessionModes, apply, inject, name, sessionModeProjection };

package/dist/shared-ChCbbJa8.mjs

@@ -0,0 +1,14 @@
+//#region src/shared.ts
+/**
+* host 半与 client 半共用的接口面：一条 HTTP 路径、模式行的对外形状、请求与响应体。
+*
+* 为什么不是 Typert Remote：客户端的 remote 清单（`@deepseek-ai/dsh-api-remotes/client`）由上游硬编码，
+* 我们的服务不在里面，`ctx.remote.sessionModes` 解析不到。仓库既有的跨半通路是 HTTP 路由
+* （见 `@morlay/ui-conversation-message-actions` 的 `/session-editor`），这里沿用同一种。
+*
+* 会话当前模式不走这条通路：它是一条 session 投影（`sessionMode`），随会话列表一起到页面。
+*/
+/** 模式清单与切换的路由路径：宿主（web 与桌面）在同一张路由表上服务它。 */
+const SESSION_MODE_PATH = "/session-mode";
+//#endregion
+export { SESSION_MODE_PATH as t };

package/dist/shared-FNWe-_rS.d.cts

@@ -0,0 +1,106 @@
+import { Volatile } from "@deepseek-ai/cordis";
+import z from "@deepseek-ai/schemastery";
+//#region src/modes.d.ts
+/** 一个模式的提示词：两段文本，注册成 agent 作用域的 `deployment:persona-prefix` / `-suffix` section。 */
+interface SessionModePersona {
+  /** 系统提示词最前的一段；空串表示不遮蔽部署级那层。 */
+  readonly prefix: string;
+  /** 系统提示词最后的一段；空串表示不写。 */
+  readonly suffix: string;
+}
+/**
+ * 一个模式对谁可见：`main` 进用户选择器（会话级选择），`subagent` 表示它**可以**作为子代理的 mode。
+ * 两个角色可以同时声明；不写默认 `["main"]`——没写角色的模式不该悄悄变成子代理候选。
+ *
+ * `subagent` 目前只是候选集的声明：子代理默认继承父 mode（不看角色），"按角色指派 mode" 还没做。
+ */
+type SessionModeRole = "main" | "subagent";
+/** 一个模式的默认模型；省略的字段跟着 provider 默认走（与全局 `agent-default-model` 同形状）。 */
+interface SessionModeModel {
+  readonly provider: string;
+  readonly model: string;
+  readonly reasoningEffort?: string;
+}
+/** 各模式的默认模型：模式 id → 模型；键必须在 `modes` 里（装配期校验）。 */
+type SessionModeModels = Readonly<Record<string, SessionModeModel>>;
+/**
+ * 一个模式：提示词 + 能力开关。
+ *
+ * 这份形状是 **schema 归一化之后**的：每个字段都有值（写配置时可以不写，schema 用默认补上——`description`
+ * 补空串、`persona` 补两段空文本、两个布尔开关补 `true`）。配置里能省略哪些字段看 `modeSchema` 的 default，
+ * 不看这里。
+ */
+interface SessionMode {
+  /** 选择器里的展示名。 */
+  readonly name: string;
+  /** 一句话说明这个模式干什么；空串表示没写。 */
+  readonly description: string;
+  /** 这个模式归谁用：`main`（用户选择器）/ `subagent`（可作子代理 mode）。至少一个。 */
+  readonly role: SessionModeRole[];
+  /** 该模式的提示词。 */
+  readonly persona: SessionModePersona;
+  /**
+   * 这个模式能用哪些工具；其余工具既不进模型目录、调用也被执行层拒绝，它们自己的说明 section
+   * （`tool:<工具名>`）也不留在提示词里。**至少给一个**——想要"全都要"就列出全部，别留空。
+   */
+  readonly allowTools: string[];
+  /**
+   * 是否要 instruction 类注入（工作区指令、技能目录、用法正文）。缺省要；`false` 表示这个模式一条都不要
+   * ——对话模式就是它。开关由 `@morlay/dsh-context-assembler/scope` 落到通道上。
+   */
+  readonly instructions: boolean;
+  /**
+   * 是否要 runtime context（文件沙箱策略、审批策略那两条动态快照）。缺省要；`false` 表示这个模式不要它们
+   * ——对话模式没有文件与 shell 工具，"能改工作区哪些文件、要不要走审批"对它全是噪音。
+   */
+  readonly runtimeContext: boolean;
+}
+/** 本包 config 的**源码形状**：装配层与设置页写的那个形状（`models` 是普通对象，可以整块省略）。 */
+interface Config {
+  /** 新会话（还没选过模式的会话）用哪个模式。必须是 `modes` 里的一个 id。 */
+  readonly default: string;
+  /** 模式清单：id → 定义。顺序即选择器里的顺序（`Object.entries` 的插入序）。 */
+  readonly modes: Record<string, SessionMode>;
+  /**
+   * 各模式的默认模型：模式 id → 模型。省略的模式跟着全局 `agent-default-model` 走。
+   *
+   * 它是 config 的**顶层 volatile 字段**：设置面（`ctx.configForms` → 我们那张卡片）编辑的就是它。挪进
+   * `modes.<id>` 会让设置面看不见它——`schemastery` 的 `validateVolatileSchema` 把 dict 内部一律当成
+   * blocked，而 settings 只挑得出固定路径上的 volatile 字段。
+   */
+  readonly models?: SessionModeModels;
+}
+/** schema 解析之后的形状：volatile 字段被换成**稳定引用**，读它要过 `.get()`（设置页改的就是同一份）。 */
+interface ResolvedConfig {
+  readonly default: string;
+  readonly modes: Record<string, SessionMode>;
+  /** 各模式的默认模型；一个都没配时是空对象（schema 的 default）。 */
+  readonly models: Volatile<SessionModeModels>;
+}
+declare const Config: z<Config, ResolvedConfig>;
+//#endregion
+//#region src/shared.d.ts
+/**
+ * host 半与 client 半共用的接口面：一条 HTTP 路径、模式行的对外形状、请求与响应体。
+ *
+ * 为什么不是 Typert Remote：客户端的 remote 清单（`@deepseek-ai/dsh-api-remotes/client`）由上游硬编码，
+ * 我们的服务不在里面，`ctx.remote.sessionModes` 解析不到。仓库既有的跨半通路是 HTTP 路由
+ * （见 `@morlay/ui-conversation-message-actions` 的 `/session-editor`），这里沿用同一种。
+ *
+ * 会话当前模式不走这条通路：它是一条 session 投影（`sessionMode`），随会话列表一起到页面。
+ */
+/** 模式清单与切换的路由路径：宿主（web 与桌面）在同一张路由表上服务它。 */
+declare const SESSION_MODE_PATH = "/session-mode";
+/** 一个模式对外的那部分：选择器要的名字与说明。 */
+interface SessionModeRow {
+  readonly id: string;
+  readonly name: string;
+  readonly description?: string;
+}
+/** `GET` 的响应体：清单与默认模式。 */
+interface SessionModeRoster {
+  readonly default: string;
+  readonly modes: readonly SessionModeRow[];
+}
+//#endregion
+export { ResolvedConfig as a, SessionModeModels as c, Config as i, SessionModePersona as l, SessionModeRoster as n, SessionMode as o, SessionModeRow as r, SessionModeModel as s, SESSION_MODE_PATH as t, SessionModeRole as u };

package/dist/shared-FNWe-_rS.d.mts

@@ -0,0 +1,106 @@
+import { Volatile } from "@deepseek-ai/cordis";
+import z from "@deepseek-ai/schemastery";
+//#region src/modes.d.ts
+/** 一个模式的提示词：两段文本，注册成 agent 作用域的 `deployment:persona-prefix` / `-suffix` section。 */
+interface SessionModePersona {
+  /** 系统提示词最前的一段；空串表示不遮蔽部署级那层。 */
+  readonly prefix: string;
+  /** 系统提示词最后的一段；空串表示不写。 */
+  readonly suffix: string;
+}
+/**
+ * 一个模式对谁可见：`main` 进用户选择器（会话级选择），`subagent` 表示它**可以**作为子代理的 mode。
+ * 两个角色可以同时声明；不写默认 `["main"]`——没写角色的模式不该悄悄变成子代理候选。
+ *
+ * `subagent` 目前只是候选集的声明：子代理默认继承父 mode（不看角色），"按角色指派 mode" 还没做。
+ */
+type SessionModeRole = "main" | "subagent";
+/** 一个模式的默认模型；省略的字段跟着 provider 默认走（与全局 `agent-default-model` 同形状）。 */
+interface SessionModeModel {
+  readonly provider: string;
+  readonly model: string;
+  readonly reasoningEffort?: string;
+}
+/** 各模式的默认模型：模式 id → 模型；键必须在 `modes` 里（装配期校验）。 */
+type SessionModeModels = Readonly<Record<string, SessionModeModel>>;
+/**
+ * 一个模式：提示词 + 能力开关。
+ *
+ * 这份形状是 **schema 归一化之后**的：每个字段都有值（写配置时可以不写，schema 用默认补上——`description`
+ * 补空串、`persona` 补两段空文本、两个布尔开关补 `true`）。配置里能省略哪些字段看 `modeSchema` 的 default，
+ * 不看这里。
+ */
+interface SessionMode {
+  /** 选择器里的展示名。 */
+  readonly name: string;
+  /** 一句话说明这个模式干什么；空串表示没写。 */
+  readonly description: string;
+  /** 这个模式归谁用：`main`（用户选择器）/ `subagent`（可作子代理 mode）。至少一个。 */
+  readonly role: SessionModeRole[];
+  /** 该模式的提示词。 */
+  readonly persona: SessionModePersona;
+  /**
+   * 这个模式能用哪些工具；其余工具既不进模型目录、调用也被执行层拒绝，它们自己的说明 section
+   * （`tool:<工具名>`）也不留在提示词里。**至少给一个**——想要"全都要"就列出全部，别留空。
+   */
+  readonly allowTools: string[];
+  /**
+   * 是否要 instruction 类注入（工作区指令、技能目录、用法正文）。缺省要；`false` 表示这个模式一条都不要
+   * ——对话模式就是它。开关由 `@morlay/dsh-context-assembler/scope` 落到通道上。
+   */
+  readonly instructions: boolean;
+  /**
+   * 是否要 runtime context（文件沙箱策略、审批策略那两条动态快照）。缺省要；`false` 表示这个模式不要它们
+   * ——对话模式没有文件与 shell 工具，"能改工作区哪些文件、要不要走审批"对它全是噪音。
+   */
+  readonly runtimeContext: boolean;
+}
+/** 本包 config 的**源码形状**：装配层与设置页写的那个形状（`models` 是普通对象，可以整块省略）。 */
+interface Config {
+  /** 新会话（还没选过模式的会话）用哪个模式。必须是 `modes` 里的一个 id。 */
+  readonly default: string;
+  /** 模式清单：id → 定义。顺序即选择器里的顺序（`Object.entries` 的插入序）。 */
+  readonly modes: Record<string, SessionMode>;
+  /**
+   * 各模式的默认模型：模式 id → 模型。省略的模式跟着全局 `agent-default-model` 走。
+   *
+   * 它是 config 的**顶层 volatile 字段**：设置面（`ctx.configForms` → 我们那张卡片）编辑的就是它。挪进
+   * `modes.<id>` 会让设置面看不见它——`schemastery` 的 `validateVolatileSchema` 把 dict 内部一律当成
+   * blocked，而 settings 只挑得出固定路径上的 volatile 字段。
+   */
+  readonly models?: SessionModeModels;
+}
+/** schema 解析之后的形状：volatile 字段被换成**稳定引用**，读它要过 `.get()`（设置页改的就是同一份）。 */
+interface ResolvedConfig {
+  readonly default: string;
+  readonly modes: Record<string, SessionMode>;
+  /** 各模式的默认模型；一个都没配时是空对象（schema 的 default）。 */
+  readonly models: Volatile<SessionModeModels>;
+}
+declare const Config: z<Config, ResolvedConfig>;
+//#endregion
+//#region src/shared.d.ts
+/**
+ * host 半与 client 半共用的接口面：一条 HTTP 路径、模式行的对外形状、请求与响应体。
+ *
+ * 为什么不是 Typert Remote：客户端的 remote 清单（`@deepseek-ai/dsh-api-remotes/client`）由上游硬编码，
+ * 我们的服务不在里面，`ctx.remote.sessionModes` 解析不到。仓库既有的跨半通路是 HTTP 路由
+ * （见 `@morlay/ui-conversation-message-actions` 的 `/session-editor`），这里沿用同一种。
+ *
+ * 会话当前模式不走这条通路：它是一条 session 投影（`sessionMode`），随会话列表一起到页面。
+ */
+/** 模式清单与切换的路由路径：宿主（web 与桌面）在同一张路由表上服务它。 */
+declare const SESSION_MODE_PATH = "/session-mode";
+/** 一个模式对外的那部分：选择器要的名字与说明。 */
+interface SessionModeRow {
+  readonly id: string;
+  readonly name: string;
+  readonly description?: string;
+}
+/** `GET` 的响应体：清单与默认模式。 */
+interface SessionModeRoster {
+  readonly default: string;
+  readonly modes: readonly SessionModeRow[];
+}
+//#endregion
+export { ResolvedConfig as a, SessionModeModels as c, Config as i, SessionModePersona as l, SessionModeRoster as n, SessionMode as o, SessionModeRow as r, SessionModeModel as s, SESSION_MODE_PATH as t, SessionModeRole as u };

package/locale/en.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "Session modes",
+    "description": "The coding / chat modes as one row of data (persona plus the allowed tools); the host applies the current one per session, and the new-session chip plus the header label replace the official agent-preset surface."
+  }
+}

package/locale/zh.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "会话模式",
+    "description": "coding / chat 两个模式：一行数据（提示词 + 工具白名单），host 按会话应用；新会话的顶部 chip 与会话头部标签替代官方的 agent preset 面。"
+  }
+}