@morlay/dsh-session-mode 0.0.8 → 0.0.9

package/src/client/SessionModeSeat.tsx

@@ -10,7 +10,7 @@ import {
   SeatButton,
   Stack,
   Text,
-} from "@morlay/dsh-client-ui-primitives/client";
+} from "@morlay/dsh-client-ui-primitives";
 import type { PropsLocale, PropsRuntime } from "@deepseek-ai/dsh-client-ui-slots";
 // Type-only：拉入本包 host 半的 Context / 投影声明（`sessionMode`），让 `projectionValues` 有类型。
 import type {} from "../index.ts";

package/src/client/bundle-config.ts

@@ -19,7 +19,7 @@ import {
   type SelectOption,
   type SettingsFormShell,
   type ValidationFailure,
-} from "@morlay/dsh-client-ui-primitives/client";
+} from "@morlay/dsh-client-ui-primitives";
 import type { BundleLocaleKey } from "./bundle-locales.ts";
 import { loadLlmProviders, routesOf, type ModelRoute } from "./llm-directory.ts";
 

package/src/client/bundle-locales.ts

@@ -64,7 +64,8 @@ export const bundleZh = {
   "hint.instructions": "每步都把工作区指令（AGENTS.md 之类）发给模型；关掉就不发。",
   "hint.skills": "每步都把技能目录发给模型；默认按这个模式的工具名单自动判断。",
   "hint.runtimeContext": "每步都把沙箱与审批策略发给模型。",
-  "hint.defaultModel": "开 = 这个模式自带一个默认模型（会话还没选过模型时用它）；关 = 跟随全局模型。",
+  "hint.defaultModel":
+    "开 = 这个模式自带一个默认模型（会话还没选过模型时用它）；关 = 跟随全局模型。",
   "hint.modelRoute": "从部署里已设置的模型里挑一条：服务商与模型是一对，选它等于两个一起定。",
   "hint.reasoningEffort": "思考档位；不填用服务商默认。",
   "model.loading": "正在读部署里已设置的模型…",
@@ -115,7 +116,8 @@ export const bundleEn: Record<keyof typeof bundleZh, string> = {
   "add.confirm": "Add",
   "add.cancel": "Cancel",
   "add.close": "Close",
-  "add.hint": "Give the new mode an id (it also shows in pickers and lists; rename it after adding).",
+  "add.hint":
+    "Give the new mode an id (it also shows in pickers and lists; rename it after adding).",
   removeNamed: "Delete mode {name}",
   protected: "Built-in mode: no delete",
   untitled: "(untitled)",

package/src/client/index.ts

@@ -11,8 +11,11 @@ import type {} from "@deepseek-ai/dsh-client-ui-slots";
 import type {} from "@deepseek-ai/dsh-client-ui-conversation/client";
 // Type-only：`plugins.bundle.config` 的槽位声明（bundle 详情页的配置座位）。
 import type {} from "@deepseek-ai/dsh-client-ui-plugin-manager/client";
-import { apply as installUiPrimitives } from "@morlay/dsh-client-ui-primitives/client";
-import { CATALOG_NS, SESSION_MODE_CATALOG_REMOTE, type SessionModeCatalogRemote } from "../catalog-remote.ts";
+import {
+  CATALOG_NS,
+  SESSION_MODE_CATALOG_REMOTE,
+  type SessionModeCatalogRemote,
+} from "../catalog-remote.ts";
 import { POLICY_NAMES } from "../shared.ts";
 import {
   BUNDLE_CONFIG_KEY,
@@ -24,11 +27,7 @@ import {
 } from "./bundle-config.ts";
 import { BundleConfigPage } from "./BundleConfigPage.tsx";
 import { BUNDLE_NS, bundleEn, bundleZh, type BundleLocaleKey } from "./bundle-locales.ts";
-import {
-  loadLlmProviders,
-  remoteNamespace,
-  type ProviderModels,
-} from "./llm-directory.ts";
+import { loadLlmProviders, remoteNamespace, type ProviderModels } from "./llm-directory.ts";
 import { SessionModeSeat } from "./SessionModeSeat.tsx";
 import { en, zh, type SessionModeLocaleKey } from "./locales.ts";
 
@@ -58,8 +57,7 @@ const DYNAMIC = "*";
 // 部署里的 agent preset 清单（`remote.agentPresets.list()`）：本包只用它的 id 与显示名做候选。
 interface PresetRosterReader {
   list: () => Promise<
-    | { ok: true; value: { presets: readonly { id: string; name?: string }[] } }
-    | { ok: false }
+    { ok: true; value: { presets: readonly { id: string; name?: string }[] } } | { ok: false }
   >;
 }
 
@@ -83,7 +81,6 @@ function unwrapHintService(scope: Context): HintsService {
 // 装上会话里的那一个面、本行配置页的字段文案，以及装本行的 bundle 那一页的表单。
 export function apply(ctx: Context): void {
   // 基础面随本包 inline（不再是装配行）：装上它提供的字典、字段槽与按行配置页；多份副本只装一次。
-  installUiPrimitives(ctx);
   const t = ctx.locale.bind(NS);
   ctx.effect(() => ctx.locale.register(NS, { zh, en }), "session-mode: dictionaries");
 
@@ -162,7 +159,6 @@ export function apply(ctx: Context): void {
     }, "session-mode: model candidates"),
   );
 
-
   // 模式"允许挂哪些 preset"的候选：部署里注册的 agent preset（`remote.agentPresets.list()`），登记成具名源
   // `agent-presets`——schema 上 `presetsOnly` 声明 `role('select', { source })` 认领它，页面不必知道这些 preset
   // 从哪来。装配组合变了（设置文档一次更新）就重取一次。
@@ -220,7 +216,7 @@ export function apply(ctx: Context): void {
       }
       void scope.remote
         .$mount(SESSION_MODE_CATALOG_REMOTE)
-        .then(async (dispose) => {
+        .then(async (dispose: () => Promise<void>) => {
           disposeMount = dispose;
           const listed = await remoteNamespace<SessionModeCatalogRemote>(scope, CATALOG_NS)?.list();
           if (listed?.ok !== true) return;

package/src/client/llm-directory.ts

@@ -97,16 +97,19 @@ function modelsOf(
 // 部署里"已设置"的 provider 与它们的模型：活着的路由与可配置声明合并（按 provider 去重，声明的显示名优先）。
 export async function loadLlmProviders(scope: Context): Promise<readonly ProviderModels[]> {
   const llm = remoteNamespace<LlmReader>(scope, "llm");
-  const forms = (scope as unknown as { get(key: string): unknown }).get(
-    "configForms",
-  ) as ConfigFormsReader | undefined;
+  const forms = (scope as unknown as { get(key: string): unknown }).get("configForms") as
+    | ConfigFormsReader
+    | undefined;
   if (llm === undefined || forms === undefined) return [];
   const [routes, directory] = await Promise.all([
     llm.listProviders(),
     llm.listConfigurableProviders(),
   ]);
   if (!routes.ok || !directory.ok) return [];
-  const merged = new Map<string, { value: string; label: string; settingsNs: string; settingsPath: readonly string[] }>();
+  const merged = new Map<
+    string,
+    { value: string; label: string; settingsNs: string; settingsPath: readonly string[] }
+  >();
   for (const entry of directory.value) {
     merged.set(entry.provider, {
       value: entry.provider,

package/src/index.ts

@@ -297,7 +297,10 @@ export class SessionModes extends Service {
 
   // 把当前挂着的 preset 落进模式的白名单：已经在名单里就返回 `undefined`（不换）；不在里面（或读不到当前那份）
   // 就返回名单的**第一个**（`undefined` = 名单为空 = 不限制，什么都不换）。
-  private presetTarget(allowed: readonly string[], current: string | undefined): string | undefined {
+  private presetTarget(
+    allowed: readonly string[],
+    current: string | undefined,
+  ): string | undefined {
     if (allowed.length === 0) return undefined;
     // 当前那份在名单里：保持不动（用户自己选的 preset 落在许可范围内，模式不去覆盖它）。
     if (current !== undefined && allowed.includes(current)) return undefined;

package/src/mode-sources.ts

@@ -44,13 +44,16 @@ export interface ModeModelSource {
   readonly reasoningEffort?: string;
 }
 
-// 编码模式：编程专家 + 语言与思考纪律 + 工作目录提醒。
+// 编码模式：编程专家 + 语言与思考纪律。
+// 这里**不再有**工作目录那半句（原为 `你的工作目录在 \`{{cwd}}\``）：上游 0.2.1-alpha.2 起工作目录由
+// `working-directory:current` 这条运行时上下文注入（文本是 `Current working directory: "<绝对路径>".`），
+// 而 persona 用的提示词插值是**严格**的——`cwd` 变量已不再注册，残留 `{{cwd}}` 会在渲染时直接抛
+// `unknown prompt variable`（注册变量只剩 provider / model）。
 const CODING_PERSONA = {
   prefix: [
     "你是一个经验丰富的编程专家，YAGNI 是你的编程哲学，PDCA 是你的行为规范。",
     "全程用中文（专有名词除外），包括但不限于思考，回答，工具描述，subagent 提示词；思考不要陷入重复循环，一旦循环立即退出；思考聚焦需求理解与方案设计，不预演具体代码实现，正确性由验证环节确认。",
   ].join("\n"),
-  suffix: "你的工作目录在 `{{cwd}}`",
 };
 
 // 对话模式：一个助手，保留语言与思考纪律，没有 suffix。
@@ -83,10 +86,7 @@ export const MODE_SOURCES: readonly ModeSource[] = [
     // 官方 Office 技能的三个名字同样按会话排除：技能目录里不列它们，`skill` 工具加载它们也被拒。
     // 名单是技能名这一层的模型可见契约（官方 `skill-office` 的 `SKILL_NAMES`），跟着上游改名走。
     denySkills: ["office-docx", "office-pptx", "office-xlsx"],
-    //
-    // `denyPolicies` 只禁 `fs/edit-intent`（上游那条"先读后改"）：改文件不再要求先读过——写路径上的
-    // `fs/write-intent`（陈旧版本 CAS 那层安全网）照旧生效，那正是这条配置不写成"两条都禁"的理由。
-    denyPolicies: ["fs/edit-intent"],
+    denyPolicies: ["fs/edit-intent", "fs/write-intent"],
   },
   {
     id: "chat",
@@ -103,9 +103,12 @@ export const MODE_SOURCES: readonly ModeSource[] = [
     // 配了只是噪音，所以留空。
     // 没有文件与 shell 工具，"能改工作区哪些文件、要不要走审批"对它全是噪音。
     //
-    // 两个抑制面都关：`instructions: false` 丢掉官方 `agent-instructions`（工作区指令）的注入；这个模式不写
+    // 注入面全关：`instructions: false` 丢掉官方 `agent-instructions`（工作区指令）的注入；这个模式不写
     // `skills`，而白名单三件里没有 `skill`、`denyTools` 也留空 → 推导成 `false`，官方 `skill-catalog` 的注入
-    // 同样丢掉。取舍见 `.agents/designs/20260929-抑制官方注入面.md`。
+    // 同样丢掉；`runtimeContext: false` 连动态快照与时钟（`standard` 那类 preset 声明的 `time-context`）一起收。
+    // **收不掉的**：上游 `working-directory:current` 是 required 的目录上下文（0.2.1-alpha.2 起工作目录只走这条），
+    // 抑制可选运行时上下文不影响它——chat 会话的模型仍会看到工作目录那条快照。
+    // 取舍见 `.agents/designs/20260929-抑制官方注入面.md`。
     instructions: false,
     runtimeContext: false,
   },

package/src/modes.ts

@@ -72,8 +72,9 @@ export interface SessionMode {
   // denyTools` 里含 `skill` 就要（`allowTools` 留空即"全部"，所以只有 `denyTools` 能把它推成 `false`）。
   // `false` 表示这个模式不要技能目录：丢掉官方 `skill-catalog` 的注入（`skill` 工具的收窄仍归 `allowTools`）。
   readonly skills?: boolean;
-  // 是否要 runtime context（文件沙箱策略、审批策略那两条动态快照）。缺省要；`false` 表示这个模式不要它们
-  // ——对话模式没有文件与 shell 工具，"能改工作区哪些文件、要不要走审批"对它全是噪音。
+  // 是否要动态快照（文件沙箱策略、审批策略那两条 snapshot section，以及 `standard` 那类 preset 声明的时钟
+  // `time-context` 注入）。缺省要；`false` 表示这个模式不要它们——对话模式没有文件与 shell 工具，"能改工作区
+  // 哪些文件、要不要走审批"对它全是噪音，它也不谈时间。
   readonly runtimeContext: boolean;
   // 这个模式的默认模型；省略就跟全局 `agent-default-model`。**可选**：没配的模式在页面上不出现在这一行
   // （`defaultModel` 是它所在模式的一个可加字段）。
@@ -277,13 +278,13 @@ const modeSchema: z<SessionMode> = z.object({
     .default(true)
     .description(
       localized({
-        zh: "是否要动态快照（文件沙箱策略、审批策略）。",
-        en: "Whether the runtime snapshot applies (sandbox and approval policy).",
+        zh: "是否要动态快照（文件沙箱策略、审批策略）与时钟注入（`standard` 那类 preset 声明的 `time-context`）。",
+        en: "Whether the runtime snapshot (sandbox and approval policy) and the clock injection (`time-context`, declared by presets such as `standard`) apply.",
       }),
     ),
   // 这个模式的默认模型。不标 `volatile`：`modes` 本身就是 volatile，整棵子树都在页面上——再标一层会被
   // schemastery 拒（`validateVolatileSchema` 不许 volatile 套 volatile）。
-  defaultModel: modelSchema    // `default(null)` 是"没配就没有这个键"：schemastery 对缺省的对象字段会造一个空对象，那样每个模式都会
+  defaultModel: modelSchema // `default(null)` 是"没配就没有这个键"：schemastery 对缺省的对象字段会造一个空对象，那样每个模式都会
     // 凭空多出一行；给了 null 反而让它保持缺失（页面按非必填处理，从候选加成）。
     // 类型上放行一次：`null` 在这里只是"没有这个键"的写法，schema 的输入形状不接受它。
     .default(null as unknown as SessionModeModel)

package/src/scope.ts

@@ -6,11 +6,11 @@
 // - **装配期投影**：模型目录与 `tool:<工具名>` section 按同一份合成结果过滤；
 // - **执行层 guard**（在 `agent.ctx` 的 `tools` inject 回调里）：拒绝时给该模式的文案，并说得出是哪一类（白名单外 /
 //   黑名单内）；
-// - **两个抑制面**（`agent/pre-step`）：官方 `agent-instructions` 与 `skill-catalog` 的注入按开关丢掉——官方那两行
-//   在装配投影之外自己往瀑布里 append，只能在瀑布上丢（不动注册表、也不动它们的行）；
+// - **三个抑制面**（`agent/pre-step`）：官方 `agent-instructions`、`skill-catalog` 与 `time-context` 的注入按开关
+//   丢掉——官方那几行在装配投影之外自己往瀑布里 append，只能在瀑布上丢（不动注册表、也不动它们的行）；
 // - **另两个开关**（注入面那个 `skills` 在上面那条里）：`runtimeContext: false` 抑制动态快照
-//   （`systemPrompt.suppressRuntimeContext`），`instructions: false` 关掉通道自己的降级注入
-//   （`ctx.contextAssembler.setInstructions`）。
+//   （`systemPrompt.suppressRuntimeContext`）与时钟那条注入（`agent/pre-step` 上的 `time-context`），
+//   `instructions: false` 关掉通道自己的降级注入（`ctx.contextAssembler.setInstructions`）。
 //
 // 同一个 agent 再 `apply` 就是换一份（旧 disposer 全部收回）；不走 `tools.restrict()`（会触发 `tools/change`），
 // 也不建 preset 子树。
@@ -41,7 +41,7 @@ export interface SessionScopeDefinition {
   readonly instructions: boolean;
   // 这个会话要不要技能目录（`false` → 丢掉官方 `skill-catalog` 的注入）。
   readonly skills: boolean;
-  // 这个会话要不要动态快照（`false` → 按 scope 抑制）。
+  // 这个会话要不要动态快照（`false` → 按 scope 抑制，并在瀑布上丢掉时钟那条注入）。
   readonly runtimeContext: boolean;
 }
 
@@ -164,19 +164,15 @@ function skillNameOf(arguments_: unknown): string | undefined {
   return typeof name === "string" && name.length > 0 ? name : undefined;
 }
 
-// 一个 agent 当前装着的那一份：`apply` 时解析好的开关（抑制面读它）。
+// 一个 agent 当前装着的那一份：装配期过滤读它（`apply` 时解析好的名单）。
 interface Applied {
   // 两条名单都空 = 不过滤（装配期与执行层都放行）。
   readonly gate: NameGate | undefined;
-  // 技能面的名单：与工具面同形，`undefined` = 不设收窄（目录照旧、`skill` 工具不按名判）。
-  readonly skillGate: NameGate | undefined;
-  readonly instructions: boolean;
-  readonly skills: boolean;
   // 收回这一份在 `agent.ctx` 上的注册（抑制器与执行层 guard）。
   readonly dispose: () => void;
 }
 
-// 按会话收口工具面与注入面的状态机：一份 per-agent 的状态 + 两条全局监听器。
+// 按会话收口工具面与注入面的状态机：一份 per-agent 的装配期名单 + 挂在各 agent 上的注册。
 export class SessionScope {
   private readonly applied = new WeakMap<Agent, Applied>();
   private readonly ctx: Context;
@@ -201,54 +197,6 @@ export class SessionScope {
         tools: result.tools.filter((tool) => denialOf(gate, tool.name) === undefined),
       };
     });
-
-    // 两个抑制面：官方 `agent-instructions`（工作区指令）与官方 `skill-catalog`（技能目录）都在装配投影之外自己
-    // 往这条瀑布里 append，所以只有在这里丢掉它们的条目（技能名单则在这里把目录按名收窄）。
-    //
-    // `prepend` 是必需的：官方那两行比本行早注册（会话挂着的 preset 先于 host 平面），瀑布里先注册的是**外层**，
-    // 站在它们后面就看不到、也丢不掉它们 append 的条目——只有抢在最外层（`await next()` 之后再收）才拿得到最终
-    // 消息表。
-    ctx.on(
-      "agent/pre-step",
-      async (payload, next): Promise<PreStepDecision> => {
-        const decision = await next();
-        if (decision.kind !== "enter") return decision;
-        const applied = this.applied.get(payload.agent);
-        // 没收过口的会话一律不动。
-        if (applied === undefined) return decision;
-        let changed = false;
-        const kept: UserMessage[] = [];
-        for (const message of decision.messages) {
-          const kind = kindOf(message);
-          if (kind === "agent-instructions") {
-            if (applied.instructions) kept.push(message);
-            else changed = true;
-            continue;
-          }
-          if (kind === "skill-catalog") {
-            if (!applied.skills) {
-              changed = true;
-              continue;
-            }
-            const narrowed =
-              applied.skillGate === undefined
-                ? undefined
-                : narrowCatalog(message, applied.skillGate, (line) =>
-                    this.ctx.logger.warn(`session-mode: ${line}`),
-                  );
-            if (narrowed === undefined) kept.push(message);
-            else {
-              changed = true;
-              kept.push(narrowed);
-            }
-            continue;
-          }
-          kept.push(message);
-        }
-        return changed ? { ...decision, messages: kept } : decision;
-      },
-      { prepend: true },
-    );
   }
 
   // 把某个会话收口到这份定义上（同一个 agent 再调就是换一份）。
@@ -259,10 +207,29 @@ export class SessionScope {
     const gate = gateOfNames(definition.allowTools, definition.denyTools);
     const skillGate = gateOfNames(definition.allowSkills, definition.denySkills);
 
-    // 落在 `agent.ctx` 上的那两件用一个 effect 装：动态快照抑制是 scope 层的一次注册；执行层 guard 要等
-    // `tools` 激活才装得上（`inject` 的回调），它挂在那个 inject fiber 下，所以收回时连 fiber 一起收。
+    // 落在 `agent.ctx` 上的那几件用一个 effect 装：注入面的抑制与动态快照抑制是 scope 层的注册；执行层 guard
+    // 要等 `tools` 激活才装得上（`inject` 的回调），它挂在那个 inject fiber 下，所以收回时连 fiber 一起收。
     const dispose = agent.ctx.effect(() => {
       const stoppers: (() => void)[] = [];
+      // 三个抑制面：官方 `agent-instructions`（工作区指令）、官方 `skill-catalog`（技能目录）与官方 `time-context`
+      // （时钟）都在装配投影之外自己往这条瀑布里 append，所以只能在这里丢它们的条目（技能目录那条还要按名收窄）。
+      //
+      // 两件事让这条注册必须落在**会话**上而不是行上：
+      // - `prepend` 只是把自己排到表头，不保证一直在那儿：表头归**最后**注册的那个 prepend，而时钟那条也 prepend；
+      // - 官方那几行随 preset 挂载（早于 `agent/created`，本注册就在那儿），所以按会话注册天然排在它们之后。
+      //   换模式 / 换 preset 时 `apply` 会重来一遍（旧的收回、新的 prepend），最外层由此回到我们手上。
+      stoppers.push(
+        agent.ctx.on(
+          "agent/pre-step",
+          async (_payload, next): Promise<PreStepDecision> => {
+            const decision = await next();
+            if (decision.kind !== "enter") return decision;
+            const kept = this.suppress(decision.messages, definition, skillGate);
+            return kept === undefined ? decision : { ...decision, messages: kept };
+          },
+          { prepend: true },
+        ),
+      );
       if (definition.runtimeContext === false) {
         // service 在 `agent.ctx` 上是 shadow：抑制落在该 agent 的 scope 层，只覆盖这个会话。
         stoppers.push(agent.ctx.systemPrompt.suppressRuntimeContext());
@@ -292,14 +259,56 @@ export class SessionScope {
 
     this.applied.set(agent, {
       gate,
-      skillGate,
-      instructions: definition.instructions,
-      skills: definition.skills,
       dispose,
     });
   }
 
-  // 通道是可选的搭档：没有它就没有降级注入可关，工具面与两个抑制面照常生效。
+  // 三个抑制面按这份定义过一遍本步的消息表：`undefined` = 一条都不动（开关都是"要"、技能名单也没排除谁），
+  // 其余 = 过滤 / 按名收窄之后的那份表。
+  private suppress(
+    messages: readonly UserMessage[],
+    definition: SessionScopeDefinition,
+    skillGate: NameGate | undefined,
+  ): UserMessage[] | undefined {
+    let changed = false;
+    const kept: UserMessage[] = [];
+    for (const message of messages) {
+      const kind = kindOf(message);
+      if (kind === "agent-instructions") {
+        if (definition.instructions) kept.push(message);
+        else changed = true;
+        continue;
+      }
+      if (kind === "skill-catalog") {
+        if (!definition.skills) {
+          changed = true;
+          continue;
+        }
+        const narrowed =
+          skillGate === undefined
+            ? undefined
+            : narrowCatalog(message, skillGate, (line) =>
+                this.ctx.logger.warn(`session-mode: ${line}`),
+              );
+        if (narrowed === undefined) kept.push(message);
+        else {
+          changed = true;
+          kept.push(narrowed);
+        }
+        continue;
+      }
+      if (kind === "time-context") {
+        // 时钟也归"动态快照"：它不经 `suppressRuntimeContext`（那是 snapshot section 那条路），只在瀑布上丢。
+        if (definition.runtimeContext) kept.push(message);
+        else changed = true;
+        continue;
+      }
+      kept.push(message);
+    }
+    return changed ? kept : undefined;
+  }
+
+  // 通道是可选的搭档：没有它就没有降级注入可关，工具面与三个抑制面照常生效。
   private channel(): { setInstructions(agent: Agent, on: boolean): void } | undefined {
     try {
       return this.ctx.get("contextAssembler");

package/src/testing.ts

@@ -0,0 +1,3 @@
+// 本包测试辅助：client 面的测试要用宿主面的目录服务与它的远程面常量（跨面的引用走出口，不走相对路径）。
+export { SessionModeCatalog } from "./catalog.ts";
+export { CATALOG_NS, SESSION_MODE_CATALOG_REMOTE } from "./catalog-remote.ts";

package/dist/index.d.cts

@@ -1,146 +0,0 @@
-import { Context, Service, Volatile } from "@deepseek-ai/cordis";
-import { Agent } from "@deepseek-ai/dsh-agent";
-import { Session, SessionEvent, SessionId } from "@deepseek-ai/dsh-session";
-import { z } from "zod";
-import z$1 from "@deepseek-ai/schemastery";
-//#region src/modes.d.ts
-interface SessionModePersona {
-  readonly prefix: string;
-  readonly suffix: string;
-}
-type SessionModeRole = "main" | "subagent";
-interface SessionModeModel {
-  readonly provider: string;
-  readonly model: string;
-  readonly reasoningEffort?: string;
-}
-type SessionModeModels = Readonly<Record<string, SessionModeModel>>;
-interface SessionMode {
-  readonly presetsOnly: string[];
-  readonly name: string;
-  readonly description: string;
-  readonly role: SessionModeRole[];
-  readonly persona: SessionModePersona;
-  readonly allowTools: string[];
-  readonly denyTools: string[];
-  readonly allowSkills: string[];
-  readonly denySkills: string[];
-  readonly allowPolicies: string[];
-  readonly denyPolicies: string[];
-  readonly instructions: boolean;
-  readonly skills?: boolean;
-  readonly runtimeContext: boolean;
-  readonly defaultModel?: SessionModeModel;
-  readonly preset?: string;
-}
-export interface Config {
-  readonly default: string;
-  readonly modes: Record<string, SessionMode>;
-  readonly models?: SessionModeModels;
-}
-interface ResolvedConfig {
-  readonly default: Volatile<string>;
-  readonly modes: Volatile<Record<string, SessionMode>>;
-  readonly models: SessionModeModels;
-}
-export declare const Config: z$1<Config, ResolvedConfig>;
-//#endregion
-//#region src/shared.d.ts
-export declare const SESSION_MODE_PATH = "/session-mode";
-export declare const POLICY_NAMES: readonly ["fs/write-intent", "fs/edit-intent"];
-type PolicyName = (typeof POLICY_NAMES)[number];
-interface SessionModeRow {
-  readonly id: string;
-  readonly name: string;
-  readonly description?: string;
-}
-interface SessionModeRoster {
-  readonly default: string;
-  readonly modes: readonly SessionModeRow[];
-}
-//#endregion
-//#region src/index.d.ts
-export declare const name = "session-mode";
-export declare const inject: string[];
-declare module "@deepseek-ai/cordis" {
-  interface Context {
-    sessionModes: SessionModes;
-  }
-}
-declare module "@deepseek-ai/dsh-session/types" {
-  interface SessionEventMap {
-    "session-mode/selected": {
-      sessionMode: string;
-    };
-  }
-}
-declare module "@deepseek-ai/dsh-session-projection/types" {
-  interface SessionProjectionStateMap {
-    sessionMode: string | null;
-    sessionModeEditable: boolean;
-  }
-  interface SessionProjectionMap {
-    sessionMode: string | null;
-    sessionModeEditable: boolean;
-  }
-}
-export declare const sessionModeProjection: {
-  key: "sessionMode";
-  stateSchema: z.ZodType<string | null, unknown, z.core.$ZodTypeInternals<string | null, unknown>>;
-  init: () => null;
-  apply: (state: string | null, event: SessionEvent) => string | null;
-  wire: {
-    viewSchema: z.ZodType<string | null, unknown, z.core.$ZodTypeInternals<string | null, unknown>>;
-    view: (state: string | null) => string | null;
-  };
-  stateVersion: number;
-};
-export declare const sessionModeEditableProjection: {
-  key: "sessionModeEditable";
-  stateSchema: z.ZodType<boolean, unknown, z.core.$ZodTypeInternals<boolean, unknown>>;
-  init: () => true;
-  apply: (state: boolean, event: SessionEvent) => boolean;
-  wire: {
-    viewSchema: z.ZodType<boolean, unknown, z.core.$ZodTypeInternals<boolean, unknown>>;
-    view: (state: boolean) => boolean;
-  };
-  stateVersion: number;
-};
-export declare class SessionModes extends Service {
-  private readonly installs;
-  private readonly scope;
-  readonly config: {
-    default: string;
-    modes: Record<string, SessionMode>;
-  };
-  constructor(ctx: Context, config: ResolvedConfig);
-  get defaultId(): string;
-  list(): SessionModeRow[];
-  idsFor(role: SessionModeRole): string[];
-  modesFor(role: SessionModeRole): {
-    id: string;
-    mode: SessionMode;
-  }[];
-  roster(): SessionModeRoster;
-  definition(id?: string): SessionMode;
-  modeOf(session: Session): string;
-  modeOfSession(session: Session): SessionMode;
-  private policyInForce;
-  private decidePolicy;
-  select(sessionId: SessionId, mode: string): Promise<string>;
-  private presetTarget;
-  private presetOfAgent;
-  private presetRegistry;
-  applyTo(agent: Agent, mode: string, options?: {
-    record?: boolean;
-  }): void;
-  private resolveModeId;
-  private presetOf;
-  modeForPreset(preset: string | undefined): string | undefined;
-  private inheritedModeId;
-  private installFor;
-  private installDefaultModel;
-}
-export declare function apply(ctx: Context, config: ResolvedConfig): void;
-//#endregion
-export type { PolicyName, ResolvedConfig, SessionMode, SessionModeModel, SessionModePersona, SessionModeRole, SessionModeRoster, SessionModeRow };

package/dist/rows.d.cts

@@ -1,11 +0,0 @@
-//#region src/rows.d.ts
-export interface PatchRow {
-  readonly insert?: readonly RowEntry[];
-}
-export interface RowEntry {
-  readonly id: string;
-  readonly name: string;
-  readonly config?: Readonly<Record<string, unknown>>;
-}
-export declare function sessionModeRows(): readonly PatchRow[];
-//#endregion