@morlay/dsh-session-mode 0.0.12 → 0.0.14-alpha.0

package/src/index.ts

@@ -3,6 +3,7 @@
 // `modes.<id>.defaultModel`；换模式只允许在空白窗口。取舍见 `.agents/designs/20260924-会话模式.md`。
 
 import { Service, type Context } from "@deepseek-ai/cordis";
+import { modelSelectionProjectionDefinition } from "@deepseek-ai/dsh-agent";
 import type { Agent } from "@deepseek-ai/dsh-agent";
 // 会话级模型事实（投影 `modelSelection` 与事件 `model/selection`）由上游 session-controller 声明；
 // 那一行可能没装（headless 部署），所以读它时按"可能为空"处理。
@@ -10,11 +11,10 @@ import type {} from "@deepseek-ai/dsh-api-session-controller";
 import { ReasoningEffortId, type LlmCallConfig } from "@deepseek-ai/dsh-llm";
 import type { Session, SessionEvent, SessionId } from "@deepseek-ai/dsh-session";
 import type {} from "@deepseek-ai/dsh-session";
-import type { ProjectionDefinition } from "@deepseek-ai/dsh-session-projection";
+import { agentPresetProjectionDefinition } from "@deepseek-ai/dsh-agent-preset-registry";
+import type { ProjectionDefinition, ProjectionHandle } from "@deepseek-ai/dsh-session-projection";
 import type {} from "@deepseek-ai/dsh-session-projection";
-// Type-only：官方 roster 的会话投影（`agentPreset`）与它的选择事件——选择面归官方 preset，
-// 我们读它的选择、落成自己的会话事实。
-import type {} from "@deepseek-ai/dsh-agent-preset-registry";
+// 官方 roster 的会话投影（`agentPreset`）：选择面归官方 preset，我们读它的选择、落成自己的会话事实。
 // Type-only：上游 fs 的 policy 事件词汇（`fs/write-intent` / `fs/edit-intent` 的签名与 `FsWriteIntent`）。
 import type {} from "@deepseek-ai/dsh-fs";
 import { z } from "zod";
@@ -116,6 +116,14 @@ export class SessionModes extends Service {
   // 输入就是模式定义、唯一消费者也是模式。
   private readonly scope: SessionScope;
 
+  // 会话投影的读句柄（上游 0.2.1-rc.2 起 `register()` 是异步的，读状态要拿着那次注册的 handle；
+  // 全局的 `stateOf(session, key)` 已弃用）。前两个是本包自己的投影，后两个是上游的（同一份定义重复注册
+  // 只是共享同一个 unit，不改变它的行为）。
+  private projectionHandle!: ProjectionHandle<string | null>;
+  private editableHandle!: ProjectionHandle<boolean>;
+  private modelSelectionHandle!: ProjectionHandle<{ readonly pending: unknown; readonly lastUsed: unknown }>;
+  private agentPresetHandle!: ProjectionHandle<string | null>;
+
   // 装配时的配置快照：`default` / `modes` 读它，改这两项靠 Loader 重挂这一行（已运行会话不自动换定义）。
   readonly config: {
     default: string;
@@ -134,8 +142,6 @@ export class SessionModes extends Service {
     const problem = configProblem({ ...this.config, models: config.models });
     if (problem !== undefined) throw new Error(problem);
     this.scope = new SessionScope(ctx);
-    ctx.sessionProjections.register(sessionModeProjection);
-    ctx.sessionProjections.register(sessionModeEditableProjection);
     // 按模式的 policy 拦截：两条上游 waterfall 各 `prepend` **一次**，注册在行 ctx 上、随行卸载一起撤。
     //
     // 接缝为什么只有这一种：fs 的调用是 `ctx.waterfall('fs/write-intent', target, actor, next)`——事件名在第一个
@@ -169,13 +175,35 @@ export class SessionModes extends Service {
       const mapped = this.modeForPreset(preset);
       const agent = ctx.agents.get(sessionId);
       if (mapped === undefined || agent === undefined) return;
-      if (this.ctx.sessionProjections.stateOf(agent.session, "sessionMode") !== mapped) {
+      if (this.projectionHandle.stateOf(agent.session) !== mapped) {
         agent.session.append("session-mode/selected", { sessionMode: mapped });
       }
       this.installFor(agent, mapped);
     });
   }
 
+  // 构造即注册（`init` 是异步的）：入口 `apply` 走这条异步工厂。
+  static async create(ctx: Context, config: ResolvedConfig): Promise<SessionModes> {
+    const modes = new SessionModes(ctx, config);
+    await modes.init();
+    return modes;
+  }
+
+  // 注册投影并拿读句柄。`register()` 要 await：句柄与注册同生命期（行卸载时自动释放），而读状态只能经句柄。
+  private async init(): Promise<void> {
+    this.projectionHandle = await this.ctx.sessionProjections.register(sessionModeProjection);
+    this.editableHandle = await this.ctx.sessionProjections.register(sessionModeEditableProjection);
+    // 上游那份 `modelSelection` 由 agent-loop 注册；这里拿同一个定义再注册一次只是要一个读句柄
+    // （refs 共享，卸载时我们这一份跟着减回去）。headless 部署里 agent-loop 也在，所以 key 一定有人注册。
+    this.modelSelectionHandle = await this.ctx.sessionProjections.register(
+      modelSelectionProjectionDefinition,
+    );
+    // `agentPreset` 归官方 roster；同样只借它的定义读会话事实（registry 没装时 header 里的值照旧可读）。
+    this.agentPresetHandle = await this.ctx.sessionProjections.register(
+      agentPresetProjectionDefinition,
+    );
+  }
+
   // 新会话用它：config 里的 `default`。
   get defaultId(): string {
     return this.config.default;
@@ -222,12 +250,23 @@ export class SessionModes extends Service {
     return mode;
   }
 
+  // 会话自己选过的模式（投影原值；没选过是 null）。`modeOf` 在它之上落部署默认。
+  selectedOf(session: Session): string | null {
+    return this.projectionHandle.stateOf(session);
+  }
+
   // 会话当前模式：投影上有就用它，否则是部署默认。
   modeOf(session: Session): string {
-    const selected = this.ctx.sessionProjections.stateOf(session, "sessionMode");
+    const selected = this.projectionHandle.stateOf(session);
     return selected ?? this.defaultId;
   }
 
+  // 这个会话还能不能换模式（空白窗口）：投影 `sessionModeEditable` 的读口。
+  // 页面 chip 的只读形态与服务端的拒绝判据都读它。
+  editableOf(session: Session): boolean {
+    return this.editableHandle.stateOf(session);
+  }
+
   // 会话当前模式的定义。
   modeOfSession(session: Session): SessionMode {
     return this.definition(this.modeOf(session));
@@ -274,7 +313,7 @@ export class SessionModes extends Service {
     const session = this.ctx.sessions.get(sessionId);
     if (session === undefined) throw new Error(`未知的会话 ${sessionId}`);
     // 空白窗口的判据只有一处：`sessionModeEditableProjection`（client chip 读同一个投影）。
-    if (this.ctx.sessionProjections.stateOf(session, "sessionModeEditable") === false) {
+    if (this.editableHandle.stateOf(session) === false) {
       throw new Error("这个会话已经开始，模式不能再改；要换模式请新开一个会话。");
     }
     const agent = this.ctx.agents.get(sessionId);
@@ -287,7 +326,7 @@ export class SessionModes extends Service {
         await registry.select(agent, target);
       }
     }
-    if (this.ctx.sessionProjections.stateOf(session, "sessionMode") !== mode) {
+    if (this.projectionHandle.stateOf(session) !== mode) {
       session.append("session-mode/selected", { sessionMode: mode });
     }
     // 会话可能已经建好了 agent（空白会话也有）：立刻按新模式重新应用一遍（与监听那次重复也无妨，幂等）。
@@ -344,7 +383,7 @@ export class SessionModes extends Service {
   // 继承要写进子会话日志——它是一条会话事实，冷恢复与 fork 靠它重建（`modeOf` 只读投影）。
   private resolveModeId(agent: Agent): string {
     // `undefined` = 这个投影没注册（或还没初始化），与"没选过"（`null`）一样落到下一层。
-    const selected = this.ctx.sessionProjections.stateOf(agent.session, "sessionMode");
+    const selected = this.projectionHandle.stateOf(agent.session);
     if (typeof selected === "string") return selected;
     // 会话级选择归官方 roster；结论落成我们自己的会话事实（`sessionMode`：恢复、子代理继承、
     // 服务端读取都读它）。
@@ -361,13 +400,9 @@ export class SessionModes extends Service {
 
   // 官方 roster 选定的 preset（没选过、或 registry 没装时为 `undefined`）。
   private presetOf(session: Session): string | undefined {
-    try {
-      const state = this.ctx.sessionProjections.stateOf(session, "agentPreset");
-      return typeof state === "string" ? state : undefined;
-    } catch {
-      // registry 没装（headless 部署）时这个投影不存在：按"没有选择"处理。
-      return undefined;
-    }
+    // registry 没装（headless 部署）时 header 里没有 preset，读到的就是 `null`：与"没选过"同义。
+    const state = this.agentPresetHandle.stateOf(session);
+    return typeof state === "string" ? state : undefined;
   }
 
   // 某个 preset 对应的模式 id——只在映射唯一时回答（只有它一个模式的名单里有这份 preset；没有模式认领、或几个
@@ -420,13 +455,19 @@ export class SessionModes extends Service {
 
   // 模式的默认模型兜底：只在会话尚无任何模型事实（没选过模型、也没落过 request header）时接管这一请求的
   // 路由。它是配置事实、不写会话事件，读构造时的模式快照（设置页保存会让这一行重挂）。
+  //
+  // `agent/request` 已被上游标为 deprecated（"Retained for existing listeners; do not add new listeners"，且明说
+  // 其他 per-request 控制**没有替代 API**）。这里是这个产品行为唯一的接缝：`agent.model.select()` 会写
+  // `model/selection` 事件，把"配置默认"变成"用户选择"，直接破坏"只在没有模型事实时兜底"的语义
+  // （见 `../.agents/adrs/20260925-默认模型住在模式定义里.md`）。债见
+  // `.agents/debts/20261026-默认模型兜底依赖deprecated的agent-request.md`。
   private installDefaultModel(agent: Agent, modeId: string): () => void {
     return agent.ctx.on("agent/request", async (_payload, next): Promise<LlmCallConfig> => {
       const resolved = await next();
       const model = this.config.modes[modeId]?.defaultModel;
       if (model === undefined) return resolved;
       // 上游 session-controller 没装（headless）时这个投影不存在，按"没有选择"处理。
-      const pending = this.ctx.sessionProjections.stateOf(agent.session, "modelSelection")?.pending;
+      const pending = this.modelSelectionHandle.stateOf(agent.session).pending;
       if (pending !== undefined && pending !== null) return resolved;
       if (agent.session.requestHeader() !== undefined) return resolved;
       return {
@@ -441,8 +482,8 @@ export class SessionModes extends Service {
   }
 }
 
-export function apply(ctx: Context, config: ResolvedConfig): void {
-  const modes = new SessionModes(ctx, config);
+export async function apply(ctx: Context, config: ResolvedConfig): Promise<void> {
+  const modes = await SessionModes.create(ctx, config);
   registerHttpRoutes(ctx, modes);
   // 配置页的工具 / 技能候选：一条本包自己开的 Remote 面（客户端半自己 mount，见 `./catalog-remote.ts`）。
   ctx.plugin(SessionModeCatalog);

package/src/mode-sources.ts

@@ -53,6 +53,7 @@ const CODING_PERSONA = {
   prefix: [
     "你是一个经验丰富的编程专家，YAGNI 是你的编程哲学，PDCA 是你的行为规范。",
     "全程 MUST 用中文（专有名词除外），包括但不限于思考，回答，工具描述，subagent 提示词；思考 NEVER 陷入重复循环，一旦循环立即退出；思考 SHOULD 聚焦需求理解与方案设计，不预演具体代码实现，正确性由验证环节确认。",
+    "单轮次内 MUST 完成明确的任务，任务未完成 NEVER 停下，除非有明确分歧点需要停下询问用户来做决断",
   ].join("\n"),
 };
 
@@ -83,7 +84,7 @@ export const MODE_SOURCES: readonly ModeSource[] = [
     role: ["main", "subagent"],
     // 不写 `allowTools`：不设收窄——这个会话用它挂着的 preset 提供的全部工具（抄一份清单只会与行清单漂移）。
     // 只排除一件工具：官方 Office 组合（宿主代码挂载，profile 层停不掉它的行）里那个载荷查询。
-    denyTools: ["load_workspace_dependencies"],
+    denyTools: ["load_workspace_dependencies", "plugin_manager"],
     // 官方 Office 技能的三个名字同样按会话排除：技能目录里不列它们，`skill` 工具加载它们也被拒。
     // 名单是技能名这一层的模型可见契约（官方 `skill-office` 的 `SKILL_NAMES`），跟着上游改名走。
     denySkills: ["office-docx", "office-pptx", "office-xlsx"],

package/src/scope.ts

@@ -3,17 +3,18 @@
 //
 // `apply` 落到这个 agent 身上四件事：
 //
-// - **装配期投影**：模型目录与 `tool:<工具名>` section 按同一份合成结果过滤；
-// - **执行层 guard**（在 `agent.ctx` 的 `tools` inject 回调里）：拒绝时给该模式的文案，并说得出是哪一类（白名单外 /
-//   黑名单内）；
+// - **工具面**（`agent.ctx.tools.restrict()`）：目录与执行走同一个视图——收窄掉的工具既不在模型目录里，
+//   调用也直接是 `UNKNOWN_TOOL`（上游 0.2.1-rc.2 起工具声明不再经 `system-prompt/assemble`，那里只剩
+//   sections / contexts / variables，所以只能落在注册表视图上；取舍见 `../.agents/adrs/20261026-工具面收窄改用tools.restrict.md`）；
+// - **`tool:<工具名>` section**：装配瀑布里按同一份名单过滤（工具自己的说明与目录同源）；
+// - **执行层 guard**：只留给技能面——`skill` 工具本身照旧可用，被收窄的是它这次要加载的那一件技能；
 // - **三个抑制面**（`agent/pre-step`）：官方 `agent-instructions`、`skill-catalog` 与 `time-context` 的注入按开关
 //   丢掉——官方那几行在装配投影之外自己往瀑布里 append，只能在瀑布上丢（不动注册表、也不动它们的行）；
 // - **另两个开关**（注入面那个 `skills` 在上面那条里）：`runtimeContext: false` 抑制动态快照
 //   （`systemPrompt.suppressRuntimeContext`）与时钟那条注入（`agent/pre-step` 上的 `time-context`），
 //   `instructions: false` 关掉通道自己的降级注入（`ctx.contextAssembler.setInstructions`）。
 //
-// 同一个 agent 再 `apply` 就是换一份（旧 disposer 全部收回）；不走 `tools.restrict()`（会触发 `tools/change`），
-// 也不建 preset 子树。
+// 同一个 agent 再 `apply` 就是换一份（旧 disposer 全部收回）；不建 preset 子树。
 
 import { type Context } from "@deepseek-ai/cordis";
 import type { Agent, PreStepDecision } from "@deepseek-ai/dsh-agent";
@@ -45,21 +46,10 @@ export interface SessionScopeDefinition {
   readonly runtimeContext: boolean;
 }
 
-// 一条工具被拒的两类原因：白名单外 / 黑名单内。文案要能看出是哪一类，模型才知道怎么绕（换工具还是换模式）。
+// 一条工具被拒的两类原因：白名单外 / 黑名单内。技能面文案用（工具面被收窄后不走这里，调用直接是
+// `UNKNOWN_TOOL`——见头注释）。
 type Denial = "not-allowlisted" | "denylisted";
 
-const OUT_OF_SCOPE = (toolName: string, modeName: string): string =>
-  `${toolName} 不在「${modeName}」的工具白名单里，用它不会有结果；按当前模式提供的工具完成任务，或让用户切到别的模式。`;
-
-const DENYLISTED = (toolName: string, modeName: string): string =>
-  `${toolName} 被「${modeName}」的工具黑名单排除，用它不会有结果；按当前模式提供的工具完成任务，或让用户切到别的模式。`;
-
-function refusalOf(toolName: string, modeName: string, denial: Denial): string {
-  return denial === "denylisted"
-    ? DENYLISTED(toolName, modeName)
-    : OUT_OF_SCOPE(toolName, modeName);
-}
-
 // 技能被拒的两类原因：同一套白名单 / 黑名单语义，文案换到技能面（拒绝加载某一件技能，而不是某个工具）。
 const SKILL_OUT_OF_SCOPE = (skillName: string, modeName: string): string =>
   `${skillName} 不在「${modeName}」的技能白名单里，加载它不会有结果；按当前模式可用的技能完成任务，或让用户切到别的模式。`;
@@ -194,7 +184,6 @@ export class SessionScope {
             ? denialOf(gate, section.name.slice(TOOL_SECTION_PREFIX.length)) === undefined
             : true,
         ),
-        tools: result.tools.filter((tool) => denialOf(gate, tool.name) === undefined),
       };
     });
   }
@@ -234,24 +223,52 @@ export class SessionScope {
         // service 在 `agent.ctx` 上是 shadow：抑制落在该 agent 的 scope 层，只覆盖这个会话。
         stoppers.push(agent.ctx.systemPrompt.suppressRuntimeContext());
       }
-      // 必须落在 `agent.ctx` 上才是这个会话的作用域。
-      const fiber = agent.ctx.inject(["tools"], (scope) => {
-        if (gate === undefined && skillGate === undefined) return;
-        scope.tools.guard((exec) => {
-          // 工具面：按名判这个工具本身能不能用。
-          const denial = gate === undefined ? undefined : denialOf(gate, exec.name);
-          if (denial !== undefined) return refusalOf(exec.name, definition.name, denial);
-          // 技能面：`skill` 工具本身照旧可用，被收窄的是它这次要加载的那一件技能。
-          if (skillGate === undefined || exec.name !== SKILL_TOOL_NAME) return undefined;
-          const skillName = skillNameOf(exec.arguments);
-          if (skillName === undefined) return undefined;
-          const skillDenial = denialOf(skillGate, skillName);
-          return skillDenial === undefined
-            ? undefined
-            : skillRefusalOf(skillName, definition.name, skillDenial);
+      // 工具面必须落在 `agent.ctx` 上才是这个会话的作用域。`tools` 服务通常已激活（agent 建好就有），
+      // 那时**同步**注册：装配瀑布读的目录必须立刻是收窄后的那一份；没激活才退回 `inject`（它的回调晚一步，
+      // 由下一次装配兜住）。注册返回的 disposer 自己收——`restrict` / `guard` 的 effect 归 tools 服务的 ctx，
+      // 不随本 effect 收回。
+      const install = (scope: Context): (() => void)[] => {
+        const disposers: (() => void)[] = [];
+        if (gate !== undefined) {
+          // 工具面：收窄**注册表视图**（目录与执行同一份）。名单里没注册的名字先滤掉——`restrict` 对未知的
+          // 全局工具名直接抛，而"行清单里缺工具的 preset"是合法部署形态；白名单过滤后可能为空数组，那正是
+          // "一件都收不到"的语义（与省略 `allow` 的"全部放行"区分开）。
+          const known = new Set(scope.tools.definitions(agent).map((tool) => tool.name));
+          disposers.push(
+            scope.tools.restrict({
+              ...(gate.allow === undefined
+                ? {}
+                : { allow: [...gate.allow].filter((name) => known.has(name)) }),
+              ...(gate.deny.size === 0
+                ? {}
+                : { deny: [...gate.deny].filter((name) => known.has(name)) }),
+            }),
+          );
+        }
+        if (skillGate === undefined) return disposers;
+        disposers.push(
+          scope.tools.guard((exec) => {
+            // 技能面：`skill` 工具本身照旧可用，被收窄的是它这次要加载的那一件技能。
+            if (exec.name !== SKILL_TOOL_NAME) return undefined;
+            const skillName = skillNameOf(exec.arguments);
+            if (skillName === undefined) return undefined;
+            const skillDenial = denialOf(skillGate, skillName);
+            return skillDenial === undefined
+              ? undefined
+              : skillRefusalOf(skillName, definition.name, skillDenial);
+          }),
+        );
+        return disposers;
+      };
+      if (agent.ctx.get("tools") === undefined) {
+        const fiber = agent.ctx.inject(["tools"], (scope) => {
+          stoppers.push(...install(scope));
         });
-      });
-      return [...stoppers, () => fiber.dispose()];
+        stoppers.push(() => fiber.dispose());
+      } else {
+        stoppers.push(...install(agent.ctx));
+      }
+      return stoppers;
     }, "session-mode: per-session gate");
 
     // 通道那一侧的降级注入按 agent 覆盖，不需要收回。