@morlay/dsh-session-mode 0.0.1 → 0.0.3

package/dist/index.mjs

@@ -1,22 +1,19 @@
-import { t as SESSION_MODE_PATH } from "./shared-ChCbbJa8.mjs";
+import { n as SESSION_MODE_PATH, t as POLICY_NAMES } from "./shared-DX2Giyh3.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
-/**
-* 本地化说明：`description()` 的类型签名只声明 `string`，而 meta 本身接受 `Dict<string>`
-* （`vendor/schemastery/src/index.ts` 的 `mergeDesc` 就是按字典合并的），所以这里只做一次类型放行。
-*/
+function derivedSkills(mode) {
+	return (mode.allowTools.length === 0 || mode.allowTools.includes("skill")) && !mode.denyTools.includes("skill");
+}
 const localized = (text) => text;
 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().role("select", { source: "llm-providers" }).description(localized({
 		zh: "服务商 id（部署里注册的任意路由，不论哪个适配器插件注册的）。",
@@ -33,8 +30,8 @@ const modelSchema = z$1.object({
 });
 const modeSchema = z$1.object({
 	preset: z$1.string().default("").description(localized({
-		zh: "这个模式挂哪个 agent preset（它的 id，官方或本部署自建的）：行清单由那个 preset 提供，几个模式可以共享同一个；空串表示不挂（只能由 applyTo / 继承使用）。",
-		en: "Which agent preset this mode rides on (its id, shipped or deployment-owned): that preset supplies the row list and several modes may share it; empty means none (usable only through applyTo / inheritance)."
+		zh: "这个模式挂哪个 agent preset（它的 id，官方或本部署自建的）：行清单由那份 preset 提供，几个模式可以共享同一个。留空就是不绑——选这个模式不换 preset，会话保持当前挂着的那份，模式自己的提示词、工具收口与开关照常生效。",
+		en: "Which agent preset this mode rides on (its id, shipped or deployment-owned): that preset supplies the row list, and several modes may share it. Leave it empty to bind none — selecting the mode then keeps whatever preset the session already has, while the mode's persona, tool narrowing, and switches still apply."
 	})),
 	name: z$1.string().required().description(localized({
 		zh: "模式名（事实文案；选择面归官方 roster）。",
@@ -50,21 +47,33 @@ const modeSchema = z$1.object({
 	})),
 	persona: personaSchema.default({}),
 	allowTools: z$1.array(z$1.string()).default([]).description(localized({
-		zh: "这个会话能用的工具；其余既不进目录，调用也被拒。",
-		en: "Tools this session may use; everything else leaves the catalog and calls are refused."
+		zh: "这个会话能用的工具；其余既不进目录，调用也被拒。**留空就是不设收窄**：用这个会话挂着的 preset 提供的全部工具。",
+		en: "Tools this session may use; everything else leaves the catalog and calls are refused. Leave it empty to narrow nothing: the session then uses every tool its preset provides."
+	})),
+	denyTools: z$1.array(z$1.string()).default([]).description(localized({
+		zh: "这个模式不用的工具（黑名单）：从 `allowTools` 定下的那份里减掉（`allowTools` 留空就是从全部里减）。留空 = 一条都不禁；同时命中两份名单时以这里为准。",
+		en: "Tools this mode must not use (deny list): subtracted from whatever `allowTools` settled on (with an empty `allowTools`, from everything). Empty denies nothing; a name in both lists is denied."
+	})),
+	allowPolicies: z$1.array(z$1.string()).default([]).description(localized({
+		zh: "上游 policy 规则的生效白名单（`fs/write-intent` / `fs/edit-intent`）：留空 = 全部规则照旧生效；有值 = 只有列出的生效，其余的被绕过。",
+		en: "Allow list of upstream policy rules that stay in force (`fs/write-intent` / `fs/edit-intent`): empty keeps every rule; when set, only the listed ones stay, and the others are bypassed."
+	})),
+	denyPolicies: z$1.array(z$1.string()).default([]).description(localized({
+		zh: "上游 policy 规则的黑名单：列出的规则禁用（它的裁决连拒绝一起丢掉，调用按没有这条规则继续）。留空 = 一条都不禁；同时命中两份名单时以这里为准。",
+		en: "Deny list of upstream policy rules: the listed ones are disabled — their verdict (rejection included) is dropped and the call proceeds as if the rule were absent. Empty denies nothing; a name in both lists is denied."
 	})),
 	instructions: z$1.boolean().default(true).description(localized({
-		zh: "是否要 instruction 类注入（工作区指令、技能目录、用法正文）。",
-		en: "Whether instruction-class injections apply (workspace instructions, skill catalog, guidance)."
+		zh: "是否要 instruction 类注入（工作区指令、用法正文）：`false` 时丢掉官方 `agent-instructions` 的注入，并关掉通道自己的降级注入。",
+		en: "Whether instruction-class injections apply (workspace instructions, guidance): `false` drops the official `agent-instructions` injection and turns off the channel's own demoted delivery."
+	})),
+	skills: z$1.boolean().description(localized({
+		zh: "是否要技能目录（官方 `skill-catalog` 的注入）。**不写就按这个模式自己的工具名单推导**：`(allowTools 留空 ? 全部 : allowTools) − denyTools` 里含 `skill` 就要；写 `false` 就丢掉官方 `skill-catalog` 的注入（`skill` 工具的可见性仍归 `allowTools`）。",
+		en: "Whether the skill catalog applies (the official `skill-catalog` injection). Unset derives it from this mode's own tool lists: it applies when `(empty allowTools ? every tool : allowTools) − denyTools` contains `skill`; `false` drops the official `skill-catalog` injection (`skill` tool visibility still belongs to `allowTools`)."
 	})),
 	runtimeContext: z$1.boolean().default(true).description(localized({
 		zh: "是否要动态快照（文件沙箱策略、审批策略）。",
 		en: "Whether the runtime snapshot applies (sandbox and approval policy)."
 	})),
-	/**
-	* 这个模式的默认模型。不标 `volatile`：`modes` 本身就是 volatile，整棵子树都在页面上——再标一层会被
-	* schemastery 拒（`validateVolatileSchema` 不许 volatile 套 volatile）。
-	*/
 	defaultModel: modelSchema.default(null).description(localized({
 		zh: "这个模式的默认模型；省略就跟全局默认模型。只在会话还没有模型事实时接管。",
 		en: "Default model for this mode; unset follows the global default. Applies only while a session has no model fact yet."
@@ -76,18 +85,13 @@ const Config = z$1.object({
 		en: "Mode a session starts in before anyone picks one; must be an id in `modes`."
 	})).volatile(),
 	modes: z$1.dict(modeSchema).required().description(localized({
-		zh: "模式清单：id → 定义（persona / 允许的工具 / 角色）。改它对**已运行会话**不自动生效——重挂后新建的会话、或重新应用模式的会话才用新定义。",
-		en: "Mode roster: id to definition (persona, allowed tools, role). Edits do not follow into already-running sessions; sessions created after the row is remounted use the new definition."
+		zh: "模式清单：id → 定义（persona / 工具名单 / 生效的 policy 规则 / 角色）。改它对**已运行会话**不自动生效——重挂后新建的会话、或重新应用模式的会话才用新定义。",
+		en: "Mode roster: id to definition (persona, tool lists, effective policy rules, role). Edits do not follow into already-running sessions; sessions created after the row is remounted use the new definition."
 	})).volatile(),
-	/**
-	* 退役字段：默认模型住在每个模式自己的 `defaultModel` 里。这里留着是为了**报错**（见 `configProblem`），
-	* 页面上不出现（`hidden()`）。
-	*/
 	models: z$1.dict(modelSchema).default({}).hidden()
 });
-/** 模式定义里不合法的地方（装配期 fail loud，而不是等到某个会话装配提示词时才发现）。 */
+const POLICY_NAME_SET = new Set(POLICY_NAMES);
 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";
@@ -95,8 +99,8 @@ function configProblem(config) {
 	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 unknownPolicies = Object.entries(config.modes).flatMap(([id, mode]) => [...mode.allowPolicies ?? [], ...mode.denyPolicies ?? []].filter((policy) => !POLICY_NAME_SET.has(policy)).map((policy) => `${id}: ${policy}`));
+	if (unknownPolicies.length > 0) return `session-mode: mode(s) ${unknownPolicies.join(", ")} name unknown policies; the known ones are ${POLICY_NAMES.join(", ")}`;
 	if (Object.keys(config.models ?? {}).length > 0) return "session-mode: `models` has moved into each mode's `defaultModel`; move the entries there and drop the top-level `models`";
 	const partial = Object.entries(config.modes).filter(([, mode]) => {
 		const model = mode.defaultModel;
@@ -109,12 +113,6 @@ function configProblem(config) {
 //#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({
@@ -131,39 +129,99 @@ function installPersona(agent, persona) {
 	};
 }
 //#endregion
+//#region src/scope.ts
+const OUT_OF_SCOPE = (toolName, modeName) => `${toolName} 不在「${modeName}」的工具白名单里，用它不会有结果；按当前模式提供的工具完成任务，或让用户切到别的模式。`;
+const DENYLISTED = (toolName, modeName) => `${toolName} 被「${modeName}」的工具黑名单排除，用它不会有结果；按当前模式提供的工具完成任务，或让用户切到别的模式。`;
+function refusalOf(toolName, modeName, denial) {
+	return denial === "denylisted" ? DENYLISTED(toolName, modeName) : OUT_OF_SCOPE(toolName, modeName);
+}
+const TOOL_SECTION_PREFIX = "tool:";
+function gateOf(definition) {
+	const deny = new Set(definition.denyTools);
+	const allow = definition.allowTools.length === 0 ? void 0 : new Set(definition.allowTools);
+	if (allow === void 0 && deny.size === 0) return void 0;
+	return {
+		allow,
+		deny
+	};
+}
+function denialOf(gate, toolName) {
+	if (gate.deny.has(toolName)) return "denylisted";
+	if (gate.allow !== void 0 && !gate.allow.has(toolName)) return "not-allowlisted";
+}
+function kindOf(message) {
+	const kind = message.source.kind;
+	return typeof kind === "string" ? kind : void 0;
+}
+var SessionScope = class {
+	applied = /* @__PURE__ */ new WeakMap();
+	ctx;
+	constructor(ctx) {
+		this.ctx = ctx;
+		ctx.on("system-prompt/assemble", async (_assembly, context, next) => {
+			const agent = context.agent;
+			const applied = agent === void 0 ? void 0 : this.applied.get(agent);
+			if (applied === void 0 || applied.gate === void 0) return next();
+			const gate = applied.gate;
+			const result = await next();
+			return {
+				...result,
+				sections: result.sections.filter((section) => section.name.startsWith(TOOL_SECTION_PREFIX) ? denialOf(gate, section.name.slice(5)) === void 0 : true),
+				tools: result.tools.filter((tool) => denialOf(gate, tool.name) === void 0)
+			};
+		});
+		ctx.on("agent/pre-step", async (payload, next) => {
+			const decision = await next();
+			if (decision.kind !== "enter") return decision;
+			const applied = this.applied.get(payload.agent);
+			if (applied === void 0) return decision;
+			const kept = decision.messages.filter((message) => {
+				const kind = kindOf(message);
+				if (kind === "agent-instructions") return applied.instructions;
+				if (kind === "skill-catalog") return applied.skills;
+				return true;
+			});
+			return kept.length === decision.messages.length ? decision : {
+				...decision,
+				messages: kept
+			};
+		}, { prepend: true });
+	}
+	apply(agent, definition) {
+		const previous = this.applied.get(agent);
+		if (previous !== void 0) previous.dispose();
+		const gate = gateOf(definition);
+		const dispose = agent.ctx.effect(() => {
+			const stoppers = [];
+			if (definition.runtimeContext === false) stoppers.push(agent.ctx.systemPrompt.suppressRuntimeContext());
+			const fiber = agent.ctx.inject(["tools"], (scope) => {
+				if (gate === void 0) return;
+				scope.tools.guard((exec) => {
+					const denial = denialOf(gate, exec.name);
+					return denial === void 0 ? void 0 : refusalOf(exec.name, definition.name, denial);
+				});
+			});
+			return [...stoppers, () => fiber.dispose()];
+		}, "session-mode: per-session gate");
+		this.channel()?.setInstructions(agent, definition.instructions);
+		this.applied.set(agent, {
+			gate,
+			instructions: definition.instructions,
+			skills: definition.skills,
+			dispose
+		});
+	}
+	channel() {
+		try {
+			return this.ctx.get("contextAssembler");
+		} catch {
+			return;
+		}
+	}
+};
+//#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",
@@ -171,7 +229,6 @@ const inject = [
 	"systemPrompt"
 ];
 const sessionModeSchema = z.union([z.string(), z.null()]);
-/** 会话模式的投影：初值来自空日志（没选过就是 `null`），只被选择事件推进。 */
 const sessionModeProjection = {
 	key: "sessionMode",
 	stateSchema: sessionModeSchema,
@@ -184,13 +241,6 @@ const sessionModeProjection = {
 	stateVersion: 1
 };
 const sessionModeEditableSchema = z.boolean();
-/**
-* 这个会话能不能换模式的投影：空白会话为 `true`，一旦 `turn/start` 落库就永远 `false`（换模式要的是**整段
-* 历史**的模式一致，所以"开过 turn"之后连正在跑的那个 turn 也算）。
-*
-* **判据只有这一处**：服务端 {@link SessionModes.select} 的拒绝与 client chip 的只读形态都读它——以前
-* client 只能等服务端报错，现在连入口都不给，而两边的结论来自同一份会话事实。
-*/
 const sessionModeEditableProjection = {
 	key: "sessionModeEditable",
 	stateSchema: sessionModeEditableSchema,
@@ -202,11 +252,9 @@ const sessionModeEditableProjection = {
 	},
 	stateVersion: 1
 };
-/** 模式清单、默认模式、按会话读取与切换。 */
 var SessionModes = class extends Service {
-	/** 每个 agent 已经装上的那一份（persona + 默认模型兜底；模式变了就换一份）。 */
 	installs = /* @__PURE__ */ new WeakMap();
-	/** 装配时的配置快照：`default` / `modes` 读它，改这两项靠 Loader 重挂这一行（已运行会话不自动换定义）。 */
+	scope;
 	config;
 	constructor(ctx, config) {
 		super(ctx, "sessionModes");
@@ -219,8 +267,11 @@ var SessionModes = class extends Service {
 			models: config.models
 		});
 		if (problem !== void 0) throw new Error(problem);
+		this.scope = new SessionScope(ctx);
 		ctx.sessionProjections.register(sessionModeProjection);
 		ctx.sessionProjections.register(sessionModeEditableProjection);
+		ctx.on("fs/write-intent", (_target, actor, next) => this.decidePolicy("fs/write-intent", actor, next), { prepend: true });
+		ctx.on("fs/edit-intent", (_target, actor, next) => this.decidePolicy("fs/edit-intent", actor, next), { prepend: true });
 		ctx.on("agent/created", ({ agent }) => {
 			this.installFor(agent);
 		});
@@ -232,11 +283,9 @@ var SessionModes = class extends Service {
 			this.installFor(agent, mapped);
 		});
 	}
-	/** 新会话用它：config 里的 `default`。 */
 	get defaultId() {
 		return this.config.default;
 	}
-	/** 选择器要的清单：只列 `main` 角色的模式（id、展示名、说明，顺序即 config 里 `modes` 的插入序）。 */
 	list() {
 		return this.idsFor("main").map((id) => {
 			const mode = this.definition(id);
@@ -247,60 +296,47 @@ var SessionModes = class extends Service {
 			};
 		});
 	}
-	/**
-	* 声明了某个角色的模式 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));
 	}
-	/**
-	* 把某个空白会话切到某个模式。
-	*
-	* 模式带着它的 preset（`preset` 决定行清单），所以这里**先把 agent preset 换成模式声明的那个**，再落我们的
-	* 会话事实：否则 preset realm 还是旧那一套的行，而它的注入在我们的开关之外（旧形态 `chat` 挂 `minimal`、
-	* 会话的 preset 却还是 `standard` 时，上游 `agent-instructions` 会照旧把工作区指令注进这个"不要注入"的会话）。
-	*
-	* 目标 preset 与当前挂着的**相同时不切**（本部署两个模式共享同一份 preset，所以切模式通常走不到这一步）：
-	* 换 preset 是一次重挂（卸旧行、装新行），没有变化就没有理由付出这个代价。
-	* @param sessionId - 目标会话（必须还没有开过 turn）。
-	* @param mode - 目标模式 id。
-	* @returns 提交后的模式 id。
-	*/
+	policyInForce(policy, actor) {
+		const agent = actor?.agent;
+		if (agent === void 0) return true;
+		const mode = this.config.modes[this.modeOf(agent.session)];
+		if (mode === void 0) return true;
+		if (mode.denyPolicies.includes(policy)) return false;
+		return mode.allowPolicies.length === 0 || mode.allowPolicies.includes(policy);
+	}
+	async decidePolicy(policy, actor, next) {
+		if (this.policyInForce(policy, actor)) return await next();
+		try {
+			await next();
+		} catch {}
+	}
 	async select(sessionId, mode) {
 		const definition = this.definition(mode);
 		if (!definition.role.includes("main")) throw new Error(`模式 ${JSON.stringify(mode)} 不是用户可选的（它的 role 里没有 main）。`);
@@ -316,12 +352,6 @@ var SessionModes = class extends Service {
 		if (agent !== void 0) this.installFor(agent);
 		return mode;
 	}
-	/**
-	* 某个 agent 当前挂着的 preset（registry 的 `composedPreset`）。
-	*
-	* 读不到时返回 `undefined`（按"未知"处理 → 该切就切）：`composedPreset` 是 registry 较新的读面，替身与老
-	* 版本可能没有它；而"没挂任何 preset"（返回值 `undefined`）与"读不到"在这里是同一个结论。
-	*/
 	presetOfAgent(registry, agent) {
 		const read = registry.composedPreset;
 		if (typeof read !== "function") return void 0;
@@ -331,10 +361,6 @@ var SessionModes = class extends Service {
 			return;
 		}
 	}
-	/**
-	* 官方 preset registry：行清单与它的选择面住在那一行。不在 `inject` 里点名（headless 部署没有它，
-	* 点名会让本行永不激活），所以按"可能拿不到"读——`ctx.get` 在当前 ctx 没声明那个服务时会抛。
-	*/
 	presetRegistry() {
 		try {
 			return this.ctx.get("agentPresets");
@@ -342,23 +368,11 @@ var SessionModes = class extends Service {
 			return;
 		}
 	}
-	/**
-	* 把某个活着的 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;
@@ -372,7 +386,6 @@ var SessionModes = class extends Service {
 		agent.session.append("session-mode/selected", { sessionMode: inherited });
 		return inherited;
 	}
-	/** 官方 roster 选定的 preset（没选过、或 registry 没装时为 `undefined`）。 */
 	presetOf(session) {
 		try {
 			const state = this.ctx.sessionProjections.stateOf(session, "agentPreset");
@@ -381,29 +394,17 @@ var SessionModes = class extends Service {
 			return;
 		}
 	}
-	/**
-	* 某个 agent preset 对应的模式 id——**只在映射唯一时**回答（几个模式挂同一份 preset 时返回
-	* `undefined`，不反查）。
-	*
-	* 本部署的两个模式共享同一个 preset（`MODE_PRESET_ID`），差异全在会话级收口，所以 preset → 模式的反查在
-	* 这里无意义：模式由**会话事实**决定（`session-mode/selected` 投影 → 子代理继承 → 部署默认），
-	* 官方 roster 选了什么 preset 不改变这个会话是哪个模式。这条反查留给"一对一映射"的部署形态。
-	* @param preset - preset id（`undefined` 表示没选过、或 registry 没装）。
-	* @returns 该 preset 唯一对应的模式 id；没配扩展、或由多个模式共享时 `undefined`。
-	*/
 	modeForPreset(preset) {
 		if (preset === void 0) return void 0;
 		const owners = Object.keys(this.config.modes).filter((id) => this.config.modes[id]?.preset === preset);
 		return owners.length === 1 ? owners[0] : void 0;
 	}
-	/** 子代理（有 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;
@@ -416,15 +417,15 @@ var SessionModes = class extends Service {
 				for (const dispose of disposers) dispose();
 			}
 		});
-		this.toolScope()?.apply(agent, mode);
+		this.scope.apply(agent, {
+			name: mode.name,
+			allowTools: mode.allowTools,
+			denyTools: mode.denyTools,
+			instructions: mode.instructions,
+			skills: mode.skills ?? derivedSkills(mode),
+			runtimeContext: mode.runtimeContext
+		});
 	}
-	/**
-	* 模式的默认模型（`modes.<模式 id>.defaultModel`）兜底：只在会话**尚无任何模型事实**（没选过模型、也
-	* 还没跑过请求）时接管这一请求的路由；一旦用户选过（投影 `pending`）或会话已经落过 header，就不再插手。
-	*
-	* 它是**配置事实**，不写会话事件——重启后仍由 config 决定；设置页里那条会话级选择才是会话事实。读的是构造
-	* 时那份模式清单快照：设置页保存会让这一行重挂（`reconcileProfilePatches`），新定义随重挂生效。
-	*/
 	installDefaultModel(agent, modeId) {
 		return agent.ctx.on("agent/request", async (_payload, next) => {
 			const resolved = await next();
@@ -441,14 +442,6 @@ var SessionModes = class extends Service {
 			};
 		});
 	}
-	/** 收口服务由 `@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));
@@ -499,12 +492,6 @@ async function handleRoute(modes, request, response) {
 		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");
@@ -517,4 +504,4 @@ function registerHttpRoutes(ctx, modes) {
 	});
 }
 //#endregion
-export { Config, SESSION_MODE_PATH, SessionModes, apply, inject, name, sessionModeEditableProjection, sessionModeProjection };
+export { Config, POLICY_NAMES, SESSION_MODE_PATH, SessionModes, apply, inject, name, sessionModeEditableProjection, sessionModeProjection };

package/dist/rows.d.cts

@@ -1,38 +1,12 @@
-//#region src/mode-sources.d.ts
-/**
- * 模式定义的真源：`session-mode` 行的 `config` 由 `./rows.ts` 渲染（装配入口在 `packages/bundles/session-mode-profile`）。
- *
- * "自定义"就落在这份数据上——装配层（profile 的用户 patch 层）可以整体改写 `config.modes`，也可以只给
- * 某个模式换提示词或工具白名单，不需要任何插件行。
- *
- * `allowTools` 从 [`@morlay/dsh-agent-toolkit/rows`](../../../dsh-agent-toolkit/src/rows.ts) 的
- * `TOOLKIT_TOOL_NAMES` 派生（工具名与汉化同源）：**行清单由本部署自己注册的那份 preset 提供**
- * （{@link MODE_PRESET_ID}，两个模式共享它），白名单里那份 preset 没有的工具自动跳过。想改某一个模式的名单，
- * 直接在这条源数据里加/减。
- */
-/**
- * 本部署自己注册的那份 agent preset 的 id：两个模式共享它（行清单见
- * `packages/bundles/session-mode-profile`，`config.plugins` 引用 `@morlay/dsh-agent-toolkit/rows` 的
- * `TOOLKIT_PRESET_ROWS`）。
- *
- * 为什么自己注册而不是复用官方 preset：官方 `minimal` 没有 `tool-web`，`chat` 的白名单（提问 + 联网三件）
- * 收口后一件都不剩；而且官方 preset 自带的上游注入要在我们的开关之外做"让位"，抢 `skill` 面还得把目录 kind
- * 换掉。行清单归我们之后，两个模式的**差异全在会话级收口**（persona / `allowTools` / 两个开关）。
- */
-declare const MODE_PRESET_ID = "mode-switch";
-//#endregion
 //#region src/rows.d.ts
-/** 一行装配条目：与 `cordis.patch.yml` 的顶层结构同形。 */
 interface PatchRow {
   readonly insert?: readonly RowEntry[];
 }
-/** `insert` 里的一个条目。 */
 interface RowEntry {
   readonly id: string;
   readonly name: string;
   readonly config?: Readonly<Record<string, unknown>>;
 }
-/** `session-mode` 行的装配：默认模式与各模式的扩展定义。 */
 declare function sessionModeRows(): readonly PatchRow[];
 //#endregion
-export { MODE_PRESET_ID, PatchRow, RowEntry, sessionModeRows };
+export { PatchRow, RowEntry, sessionModeRows };

package/dist/rows.d.mts

@@ -1,38 +1,12 @@
-//#region src/mode-sources.d.ts
-/**
- * 模式定义的真源：`session-mode` 行的 `config` 由 `./rows.ts` 渲染（装配入口在 `packages/bundles/session-mode-profile`）。
- *
- * "自定义"就落在这份数据上——装配层（profile 的用户 patch 层）可以整体改写 `config.modes`，也可以只给
- * 某个模式换提示词或工具白名单，不需要任何插件行。
- *
- * `allowTools` 从 [`@morlay/dsh-agent-toolkit/rows`](../../../dsh-agent-toolkit/src/rows.ts) 的
- * `TOOLKIT_TOOL_NAMES` 派生（工具名与汉化同源）：**行清单由本部署自己注册的那份 preset 提供**
- * （{@link MODE_PRESET_ID}，两个模式共享它），白名单里那份 preset 没有的工具自动跳过。想改某一个模式的名单，
- * 直接在这条源数据里加/减。
- */
-/**
- * 本部署自己注册的那份 agent preset 的 id：两个模式共享它（行清单见
- * `packages/bundles/session-mode-profile`，`config.plugins` 引用 `@morlay/dsh-agent-toolkit/rows` 的
- * `TOOLKIT_PRESET_ROWS`）。
- *
- * 为什么自己注册而不是复用官方 preset：官方 `minimal` 没有 `tool-web`，`chat` 的白名单（提问 + 联网三件）
- * 收口后一件都不剩；而且官方 preset 自带的上游注入要在我们的开关之外做"让位"，抢 `skill` 面还得把目录 kind
- * 换掉。行清单归我们之后，两个模式的**差异全在会话级收口**（persona / `allowTools` / 两个开关）。
- */
-declare const MODE_PRESET_ID = "mode-switch";
-//#endregion
 //#region src/rows.d.ts
-/** 一行装配条目：与 `cordis.patch.yml` 的顶层结构同形。 */
 interface PatchRow {
   readonly insert?: readonly RowEntry[];
 }
-/** `insert` 里的一个条目。 */
 interface RowEntry {
   readonly id: string;
   readonly name: string;
   readonly config?: Readonly<Record<string, unknown>>;
 }
-/** `session-mode` 行的装配：默认模式与各模式的扩展定义。 */
 declare function sessionModeRows(): readonly PatchRow[];
 //#endregion
-export { MODE_PRESET_ID, PatchRow, RowEntry, sessionModeRows };
+export { PatchRow, RowEntry, sessionModeRows };