@carljia/omd-dsh 0.1.3 → 0.1.5

package/README.md

@@ -15,7 +15,14 @@ OMD 理念的 DSH 插件：两个 cordis 行 + 7 个模式 preset + 同步 CLI
 
 机制：监听 system-prompt/assemble（注入 {{provider}}/{{model}} 提示词变量）与 agent/request（next() 后覆盖路由），两处均 prepend，保证覆盖入口的会话级选择。
 
-模型体验：persona 文本每次请求固定携带该模式模型声明；模式模型路由在 agent 生命周期内稳定（KV 前缀稳定）。
+**与 UI 模型切换的优先级**：矩阵模型是模式的默认路由，但用户在 UI 显式切换模型后，本次任务的顶层路由（与 persona 展示）跟随用户选择。判定规则（依据请求瀑布流解析出的入口选择）：
+
+1. 入口选择 == 矩阵模型 → 钉住矩阵模型（无操作）；
+2. 会话尚无任何请求（blank）且入口选择 == 挂载时的部署默认模型 → 视为未选择，钉住矩阵模型；
+3. 会话已跑过请求且刚发生 preset 切换（/mode 或 UI 选择，日志中 agent-preset/selected 在最后一次 request/header 之后）且入口选择 == 切换前的路由 → 新模式认领矩阵模型；
+4. 其余情况 → 入口选择与矩阵模型不同 = 用户显式切换：请求与 persona 变量均保持用户选择，本行在作用域 ctx 上记录 `omdModeOverride`（provider/model），omd-task 行据此把 deep tier 路由到用户选择的模型。
+
+模型体验：persona 文本每次请求固定携带实际路由模型的声明；模式模型路由在 agent 生命周期内稳定（KV 前缀稳定）。
 
 ## 行：omd-task
 
@@ -32,6 +39,8 @@ tier 差异化子代理委派（等价 OMD 的 task(category=…)）。仅限 pr
 
 模型可见参数：description（展示名）、prompt、tier（枚举见工具描述）、run_in_background（仅 continuable 模式）。工具描述枚举各 tier 的 hint 与模型，模型据此选型。
 
+**deep tier 与用户模型覆盖**：用户在 UI 显式切换模型后（omd-mode 让路并记录 `ctx.omdModeOverride`），名为 `deep` 的 tier 改用用户选择的模型（provider/model 整体替换），其余 tier 保持矩阵配置。
+
 ## CLI：omd-dsh
 
 ```
@@ -62,7 +71,8 @@ npm pack        # prepack 自动重建，产出 tgz
 ### 子代理透传语义
 
 omd-mode 对 subagentDepth > 0 的子代理一律透传（不覆盖 provider/model/变量）：
-omd-task 的 tier 模型通过显式 agentOptions 生效；顶层 agent 才被钉到模式模型。
+omd-task 的 tier 模型通过显式 agentOptions 生效；顶层 agent 才被钉到模式模型
+（除非用户显式切换模型——此时顶层跟随用户选择，deep tier 通过 `ctx.omdModeOverride` 同步）。
 这保证「强模型顶层 + tier 差异化子代理」的优先级正确。
 
 ### toolFilter 注意

package/lib/index.d.ts

@@ -9,9 +9,28 @@
  * model and provider template variables), and overrides provider/model
  * on the agent/request waterfall after next(), dropping any inherited
  * reasoningEffort. Both listeners register with prepend: true so this
- * row sits OUTSIDE the entry point per-session selection listener and
- * its override wins deterministically -- that is the mechanism behind
- * "each mode pins its own model".
+ * row sits OUTSIDE the entry point per-session selection listener.
+ *
+ * Precedence vs. the UI model switch: the matrix model is the preset's
+ * DEFAULT route, but an explicit user selection wins for the task.
+ * The entry selection (installModelSelection) is invisible to this row
+ * (it is owned by the host entry point), so the decision is derived
+ * from what the waterfall actually resolved:
+ *
+ *   - entry selection == matrix model            -> pin (no-op);
+ *   - entry selection missing                    -> pin (claim the mode);
+ *   - session still blank (no request/header)
+ *     and entry selection == the deployment
+ *     default captured at mount                  -> pin (fallback, no pick);
+ *   - a preset switch (agent-preset/selected)
+ *     happened after the last request/header and
+ *     entry selection == the route the session
+ *     was running before the switch              -> pin (new mode claims);
+ *   - otherwise the user explicitly picked a
+ *     different model                            -> yield: the request and
+ *       the persona variables keep the user's selection, and the row
+ *       records it on the scoped context as `omdModeOverride` so the
+ *       omd-task row can route the "deep" tier to the user's model.
  *
  * When provider/model are not configured the row passes everything
  * through and only serves the persona banner variables (inheriting the

package/lib/index.js

@@ -11,9 +11,28 @@ import { scopeOf } from "@deepseek-ai/dsh-scope";
  * model and provider template variables), and overrides provider/model
  * on the agent/request waterfall after next(), dropping any inherited
  * reasoningEffort. Both listeners register with prepend: true so this
- * row sits OUTSIDE the entry point per-session selection listener and
- * its override wins deterministically -- that is the mechanism behind
- * "each mode pins its own model".
+ * row sits OUTSIDE the entry point per-session selection listener.
+ *
+ * Precedence vs. the UI model switch: the matrix model is the preset's
+ * DEFAULT route, but an explicit user selection wins for the task.
+ * The entry selection (installModelSelection) is invisible to this row
+ * (it is owned by the host entry point), so the decision is derived
+ * from what the waterfall actually resolved:
+ *
+ *   - entry selection == matrix model            -> pin (no-op);
+ *   - entry selection missing                    -> pin (claim the mode);
+ *   - session still blank (no request/header)
+ *     and entry selection == the deployment
+ *     default captured at mount                  -> pin (fallback, no pick);
+ *   - a preset switch (agent-preset/selected)
+ *     happened after the last request/header and
+ *     entry selection == the route the session
+ *     was running before the switch              -> pin (new mode claims);
+ *   - otherwise the user explicitly picked a
+ *     different model                            -> yield: the request and
+ *       the persona variables keep the user's selection, and the row
+ *       records it on the scoped context as `omdModeOverride` so the
+ *       omd-task row can route the "deep" tier to the user's model.
  *
  * When provider/model are not configured the row passes everything
  * through and only serves the persona banner variables (inheriting the
@@ -30,6 +49,36 @@ const Config = z.object({
     model: z.string(),
     reasoningEffort: z.string(),
 });
+/**
+ * 子代理（subagentDepth > 0）透传：omd-task 的 tier 模型通过显式 agentOptions
+ * 落到子代理的 AgentOptions 上，本行若再覆盖会压回模式模型、破坏差异化委派。
+ * 无显式 agentOptions 的子代理按 DSH 原生语义继承父级入口选择。
+ */
+function isSubagent(agent) {
+    return agent !== undefined && agent !== null && agent.options !== undefined && agent.options !== null
+        && typeof agent.options.subagentDepth === "number" && agent.options.subagentDepth > 0;
+}
+/**
+ * 最近一次 request/header 之后是否发生过 agent-preset/selected（UI 预设选择或 /mode 切换）。
+ * 切换事件由 api-proxy 与 omd-mode-switch 在 recompose 完成之后追加，因此必须每次实时计算——
+ * 本行挂载时事件尚未入日志，挂载时快照会漏判。
+ */
+function presetSwitchedAfterLastRequest(session) {
+    const events = session === undefined || session === null ? undefined : session.events;
+    if (events === undefined)
+        return false;
+    let lastHeader = -1;
+    let lastSwitch = -1;
+    for (const event of events) {
+        if (event === undefined || event === null || typeof event.seq !== "number")
+            continue;
+        if (event.type === "request/header")
+            lastHeader = event.seq;
+        else if (event.type === "agent-preset/selected")
+            lastSwitch = event.seq;
+    }
+    return lastSwitch > lastHeader;
+}
 function apply(ctx, config) {
     if (scopeOf(ctx) === undefined) {
         throw new Error("omd-mode: refusing to mount outside a scoped context (mode '" + config.mode + "'). " +
@@ -41,42 +90,94 @@ function apply(ctx, config) {
             model: config.model,
         }
         : undefined;
-    // 子代理（subagentDepth > 0）透传：omd-task 的 tier 模型通过显式 agentOptions
-    // 落到子代理的 AgentOptions 上，本行若再覆盖会压回模式模型、破坏差异化委派。
-    // 无显式 agentOptions 的子代理按 DSH 原生语义继承父级入口选择。
-    const isSubagent = (agent) => agent !== undefined && agent !== null && agent.options !== undefined && agent.options !== null
-        && typeof agent.options.subagentDepth === "number" && agent.options.subagentDepth > 0;
     if (config.reasoningEffort !== undefined && pinned !== undefined) {
         pinned.reasoningEffort = config.reasoningEffort;
     }
+    // 挂载时快照部署默认模型（d0）。blank 会话的入口选择 == d0 视为「未显式选择」。
+    // 必须静态快照：session.selectModel 每次都会把用户选择写回全局默认，动态读取会把
+    // 用户选择误判为默认值。
+    let d0;
+    try {
+        const def = ctx.get("agentDefaultModel");
+        const current = def !== undefined && def !== null ? def.currentSelection() : undefined;
+        if (current !== undefined && current !== null && typeof current.provider === "string" && typeof current.model === "string") {
+            d0 = { provider: current.provider, model: current.model };
+        }
+    }
+    catch { /* 读不到默认时退化为仅 entry == pinned 判定 */ }
+    // 供同 preset 内的 omd-task 行读取：用户显式切换模型后（本行让路），deep tier 沿用用户选择。
+    ctx.omdModeOverride = undefined;
+    /**
+     * 判定一次入口选择是否应钉到模式模型（true），还是让路给用户选择（false）。
+     * @param agent - 顶层 agent（子代理已由调用方过滤）。
+     * @param entry - 入口选择 { provider, model }；provider/model 缺失 = 无入口选择。
+     */
+    function shouldPin(agent, entry) {
+        if (pinned === undefined)
+            return false;
+        if (entry === undefined || entry.provider === undefined || entry.model === undefined)
+            return true;
+        if (entry.provider === pinned.provider && entry.model === pinned.model)
+            return true;
+        const session = agent !== undefined && agent !== null ? agent.session : undefined;
+        const logged = session === undefined ? undefined : session.requestHeader();
+        if (logged === undefined) {
+            // 会话尚无任何请求：入口选择要么是部署默认（未选择），要么是首请求前的显式选择。
+            // 只有默认值视为「未选择」；其余一律视为用户选择。
+            if (d0 !== undefined && entry.provider === d0.provider && entry.model === d0.model)
+                return true;
+            return false;
+        }
+        // 会话已跑过请求：刚切换 preset（/mode 或 UI 选择）时，切换前的路由（logged）是
+        // 新模式认领矩阵模型的基线；否则入口选择与模式模型不同 = 用户显式切换，让路。
+        if (presetSwitchedAfterLastRequest(session)
+            && logged.config !== undefined && logged.config !== null
+            && entry.provider === logged.config.provider && entry.model === logged.config.model) {
+            return true;
+        }
+        return false;
+    }
     ctx.on("system-prompt/assemble", async (assembly, _context, next) => {
         const assembled = await next();
-        if (pinned === undefined || isSubagent(_context && _context.agent))
+        const agent = _context && _context.agent;
+        if (pinned === undefined || isSubagent(agent))
             return assembled;
-        return {
-            ...assembled,
-            variables: {
-                ...assembled.variables,
-                provider: pinned.provider,
-                model: pinned.model,
-            },
-        };
+        const variables = assembled.variables ?? {};
+        if (shouldPin(agent, { provider: variables.provider, model: variables.model })) {
+            return {
+                ...assembled,
+                variables: {
+                    ...variables,
+                    provider: pinned.provider,
+                    model: pinned.model,
+                },
+            };
+        }
+        // 让路：保留入口（用户）选择注入的变量，persona 展示实际路由的模型。
+        return assembled;
     }, { prepend: true });
     ctx.on("agent/request", async (_payload, next) => {
         const resolved = await next();
-        if (pinned === undefined || isSubagent(_payload && _payload.agent))
+        const agent = _payload && _payload.agent;
+        if (pinned === undefined || isSubagent(agent))
             return resolved;
-        const stripped = { ...resolved };
-        delete stripped.reasoningEffort;
-        const out = {
-            ...stripped,
-            provider: pinned.provider,
-            model: pinned.model,
-        };
-        if (pinned.reasoningEffort !== undefined) {
-            out.reasoningEffort = pinned.reasoningEffort;
+        if (shouldPin(agent, { provider: resolved.provider, model: resolved.model })) {
+            ctx.omdModeOverride = undefined;
+            const stripped = { ...resolved };
+            delete stripped.reasoningEffort;
+            const out = {
+                ...stripped,
+                provider: pinned.provider,
+                model: pinned.model,
+            };
+            if (pinned.reasoningEffort !== undefined) {
+                out.reasoningEffort = pinned.reasoningEffort;
+            }
+            return out;
         }
-        return out;
+        // 用户显式选择了别的模型：本次任务顶层路由用用户选择；deep tier 同步（omd-task 读取）。
+        ctx.omdModeOverride = { provider: resolved.provider, model: resolved.model };
+        return resolved;
     }, { prepend: true });
 }
 export { Config, apply, inject, name };

package/lib/plan.d.ts

@@ -1,13 +1,19 @@
 /**
  * @module @carljia/omd-dsh/plan
  *
- * omd-plan: plan persistence for the OMD planner mode. It wraps the
- * `tools/post-execute` waterfall and intercepts a successful
- * `exit_plan_mode` approval: the approved plan text is written into the
- * workspace's plan directory (a fixed, code-level convention -- never
- * mentioned in any persona/prompt text), and the tool result content is
- * enriched with the saved file name so the planner's fixed Start Work
- * final step can hand it to the user.
+ * omd-plan: plan persistence + plan-mode activation + write scope for the OMD
+ * planner mode. Three jobs, all scoped to the planner preset:
+ *   1. auto-activate plan mode for the top-level agent, so the plan:policy
+ *      section renders and exit_plan_mode works (DSH leaves plan state
+ *      inactive until /plan or a programmatic set);
+ *   2. enforce a .md-only write guard so the planner stays read-only except
+ *      for markdown files;
+ *   3. wrap `tools/post-execute` and intercept a successful `exit_plan_mode`
+ *      approval: the approved plan text is written into the workspace's plan
+ *      directory (a fixed, code-level convention -- never mentioned in any
+ *      persona/prompt text), and the tool result content is enriched with the
+ *      saved file name so the planner's fixed Start Work final step can hand
+ *      it to the user.
  *
  * Plan directory convention (hardcoded here and in omd-start-work only):
  *   <session cwd>/.omd/plans/<slug>-<timestamp>.md
@@ -16,7 +22,7 @@
  */
 /** Cordis plugin name. */
 declare const name = "omd-plan";
-/** No service injection: this row only registers a scoped event listener. */
+/** No service injection: this row only registers scoped event listeners. */
 declare const inject: never[];
 declare function apply(ctx: any): void;
 export { apply, inject, name };

package/lib/plan.js

@@ -4,13 +4,19 @@ import { scopeOf } from "@deepseek-ai/dsh-scope";
 /**
  * @module @carljia/omd-dsh/plan
  *
- * omd-plan: plan persistence for the OMD planner mode. It wraps the
- * `tools/post-execute` waterfall and intercepts a successful
- * `exit_plan_mode` approval: the approved plan text is written into the
- * workspace's plan directory (a fixed, code-level convention -- never
- * mentioned in any persona/prompt text), and the tool result content is
- * enriched with the saved file name so the planner's fixed Start Work
- * final step can hand it to the user.
+ * omd-plan: plan persistence + plan-mode activation + write scope for the OMD
+ * planner mode. Three jobs, all scoped to the planner preset:
+ *   1. auto-activate plan mode for the top-level agent, so the plan:policy
+ *      section renders and exit_plan_mode works (DSH leaves plan state
+ *      inactive until /plan or a programmatic set);
+ *   2. enforce a .md-only write guard so the planner stays read-only except
+ *      for markdown files;
+ *   3. wrap `tools/post-execute` and intercept a successful `exit_plan_mode`
+ *      approval: the approved plan text is written into the workspace's plan
+ *      directory (a fixed, code-level convention -- never mentioned in any
+ *      persona/prompt text), and the tool result content is enriched with the
+ *      saved file name so the planner's fixed Start Work final step can hand
+ *      it to the user.
  *
  * Plan directory convention (hardcoded here and in omd-start-work only):
  *   <session cwd>/.omd/plans/<slug>-<timestamp>.md
@@ -19,7 +25,7 @@ import { scopeOf } from "@deepseek-ai/dsh-scope";
  */
 /** Cordis plugin name. */
 const name = "omd-plan";
-/** No service injection: this row only registers a scoped event listener. */
+/** No service injection: this row only registers scoped event listeners. */
 const inject = [];
 /** Plan directory segments relative to the session workspace root (cwd). */
 const PLAN_DIR_SEGMENTS = [".omd", "plans"];
@@ -79,10 +85,57 @@ function isSubagent(agent) {
         typeof agent.options.subagentDepth === "number" &&
         agent.options.subagentDepth > 0);
 }
+/** Fold the session's plan/mode events (last one wins); mirror mode.ts. */
+function planModeActive(events) {
+    let active = false;
+    for (const event of events ?? []) {
+        if (event !== undefined && event.type === "plan/mode") {
+            active = event.data !== undefined && event.data !== null && event.data.active === true;
+        }
+    }
+    return active;
+}
 function apply(ctx) {
     if (scopeOf(ctx) === undefined) {
         throw new Error("omd-plan: refusing to mount outside a scoped context; mount this row inside an agent preset");
     }
+    // Scoped .md-only write guard: the planner may write/edit only markdown
+    // files, keeping it read-only for every other path. The plan file itself is
+    // written by this row via node:fs (not through the model's write/edit tools),
+    // so plan persistence is unaffected by the guard. Implemented on the
+    // tools/pre-execute gate (the row's existing ctx.on style) so no service
+    // injection is required.
+    ctx.on("tools/pre-execute", async (exec, next) => {
+        const toolName = exec !== undefined && exec !== null ? exec.name : undefined;
+        if (toolName !== "write" && toolName !== "edit")
+            return await next();
+        const filePath = exec.arguments !== undefined &&
+            exec.arguments !== null &&
+            typeof exec.arguments.file_path === "string"
+            ? exec.arguments.file_path
+            : undefined;
+        if (filePath !== undefined && filePath.toLowerCase().endsWith(".md"))
+            return await next();
+        return {
+            kind: "deny",
+            reason: "omd-plan: the planner preset may write or edit only .md files (refusing " +
+                toolName +
+                " on a non-.md path)",
+        };
+    });
+    // Auto-activate plan mode for the top-level planner agent. DSH leaves plan
+    // state inactive until /plan or a programmatic set, so without this the
+    // plan:policy section never renders and exit_plan_mode fails with "only
+    // available in plan mode". Mirror mode.ts's direct log append (no narration)
+    // so the planner session is in plan mode from its first request onward.
+    ctx.on("agent/pre-step", async ({ agent }, next) => {
+        if (agent !== undefined && agent !== null && !isSubagent(agent) && agent.session !== undefined && agent.session !== null) {
+            if (!planModeActive(agent.session.events)) {
+                agent.session.append("plan/mode", { active: true });
+            }
+        }
+        return await next();
+    });
     ctx.on("tools/post-execute", async (exec, result, next) => {
         const decision = await next();
         if (decision.kind !== "accept" || decision.value !== undefined)

package/lib/task.js

@@ -211,7 +211,14 @@ function apply(ctx, config) {
                 if (!parent)
                     throw new Error("omd_task requires a calling agent (exec.agent was undefined)");
                 const tierName = resolveTier(config, args.tier);
-                const tier = config.tiers[tierName];
+                let tier = config.tiers[tierName];
+                // 用户显式切换模型后（omd-mode 在 agent/request 让路并在作用域 ctx 上记录
+                // omdModeOverride），deep tier 改用用户选择的模型；其余 tier 保持矩阵配置。
+                const override = ctx.omdModeOverride;
+                if (tierName === "deep" && override !== undefined
+                    && typeof override.provider === "string" && typeof override.model === "string") {
+                    tier = { ...tier, provider: override.provider, model: override.model };
+                }
                 const maxDepth = typeof config.maxDepth === "number" ? config.maxDepth : undefined;
                 const request = {
                     label: args.description,

package/lib/vendor/omd-mode.mjs

@@ -11,9 +11,28 @@ import { scopeOf } from "@deepseek-ai/dsh-scope";
  * model and provider template variables), and overrides provider/model
  * on the agent/request waterfall after next(), dropping any inherited
  * reasoningEffort. Both listeners register with prepend: true so this
- * row sits OUTSIDE the entry point per-session selection listener and
- * its override wins deterministically -- that is the mechanism behind
- * "each mode pins its own model".
+ * row sits OUTSIDE the entry point per-session selection listener.
+ *
+ * Precedence vs. the UI model switch: the matrix model is the preset's
+ * DEFAULT route, but an explicit user selection wins for the task.
+ * The entry selection (installModelSelection) is invisible to this row
+ * (it is owned by the host entry point), so the decision is derived
+ * from what the waterfall actually resolved:
+ *
+ *   - entry selection == matrix model            -> pin (no-op);
+ *   - entry selection missing                    -> pin (claim the mode);
+ *   - session still blank (no request/header)
+ *     and entry selection == the deployment
+ *     default captured at mount                  -> pin (fallback, no pick);
+ *   - a preset switch (agent-preset/selected)
+ *     happened after the last request/header and
+ *     entry selection == the route the session
+ *     was running before the switch              -> pin (new mode claims);
+ *   - otherwise the user explicitly picked a
+ *     different model                            -> yield: the request and
+ *       the persona variables keep the user's selection, and the row
+ *       records it on the scoped context as `omdModeOverride` so the
+ *       omd-task row can route the "deep" tier to the user's model.
  *
  * When provider/model are not configured the row passes everything
  * through and only serves the persona banner variables (inheriting the
@@ -30,6 +49,36 @@ const Config = z.object({
     model: z.string(),
     reasoningEffort: z.string(),
 });
+/**
+ * 子代理（subagentDepth > 0）透传：omd-task 的 tier 模型通过显式 agentOptions
+ * 落到子代理的 AgentOptions 上，本行若再覆盖会压回模式模型、破坏差异化委派。
+ * 无显式 agentOptions 的子代理按 DSH 原生语义继承父级入口选择。
+ */
+function isSubagent(agent) {
+    return agent !== undefined && agent !== null && agent.options !== undefined && agent.options !== null
+        && typeof agent.options.subagentDepth === "number" && agent.options.subagentDepth > 0;
+}
+/**
+ * 最近一次 request/header 之后是否发生过 agent-preset/selected（UI 预设选择或 /mode 切换）。
+ * 切换事件由 api-proxy 与 omd-mode-switch 在 recompose 完成之后追加，因此必须每次实时计算——
+ * 本行挂载时事件尚未入日志，挂载时快照会漏判。
+ */
+function presetSwitchedAfterLastRequest(session) {
+    const events = session === undefined || session === null ? undefined : session.events;
+    if (events === undefined)
+        return false;
+    let lastHeader = -1;
+    let lastSwitch = -1;
+    for (const event of events) {
+        if (event === undefined || event === null || typeof event.seq !== "number")
+            continue;
+        if (event.type === "request/header")
+            lastHeader = event.seq;
+        else if (event.type === "agent-preset/selected")
+            lastSwitch = event.seq;
+    }
+    return lastSwitch > lastHeader;
+}
 function apply(ctx, config) {
     if (scopeOf(ctx) === undefined) {
         throw new Error("omd-mode: refusing to mount outside a scoped context (mode '" + config.mode + "'). " +
@@ -41,42 +90,94 @@ function apply(ctx, config) {
             model: config.model,
         }
         : undefined;
-    // 子代理（subagentDepth > 0）透传：omd-task 的 tier 模型通过显式 agentOptions
-    // 落到子代理的 AgentOptions 上，本行若再覆盖会压回模式模型、破坏差异化委派。
-    // 无显式 agentOptions 的子代理按 DSH 原生语义继承父级入口选择。
-    const isSubagent = (agent) => agent !== undefined && agent !== null && agent.options !== undefined && agent.options !== null
-        && typeof agent.options.subagentDepth === "number" && agent.options.subagentDepth > 0;
     if (config.reasoningEffort !== undefined && pinned !== undefined) {
         pinned.reasoningEffort = config.reasoningEffort;
     }
+    // 挂载时快照部署默认模型（d0）。blank 会话的入口选择 == d0 视为「未显式选择」。
+    // 必须静态快照：session.selectModel 每次都会把用户选择写回全局默认，动态读取会把
+    // 用户选择误判为默认值。
+    let d0;
+    try {
+        const def = ctx.get("agentDefaultModel");
+        const current = def !== undefined && def !== null ? def.currentSelection() : undefined;
+        if (current !== undefined && current !== null && typeof current.provider === "string" && typeof current.model === "string") {
+            d0 = { provider: current.provider, model: current.model };
+        }
+    }
+    catch { /* 读不到默认时退化为仅 entry == pinned 判定 */ }
+    // 供同 preset 内的 omd-task 行读取：用户显式切换模型后（本行让路），deep tier 沿用用户选择。
+    ctx.omdModeOverride = undefined;
+    /**
+     * 判定一次入口选择是否应钉到模式模型（true），还是让路给用户选择（false）。
+     * @param agent - 顶层 agent（子代理已由调用方过滤）。
+     * @param entry - 入口选择 { provider, model }；provider/model 缺失 = 无入口选择。
+     */
+    function shouldPin(agent, entry) {
+        if (pinned === undefined)
+            return false;
+        if (entry === undefined || entry.provider === undefined || entry.model === undefined)
+            return true;
+        if (entry.provider === pinned.provider && entry.model === pinned.model)
+            return true;
+        const session = agent !== undefined && agent !== null ? agent.session : undefined;
+        const logged = session === undefined ? undefined : session.requestHeader();
+        if (logged === undefined) {
+            // 会话尚无任何请求：入口选择要么是部署默认（未选择），要么是首请求前的显式选择。
+            // 只有默认值视为「未选择」；其余一律视为用户选择。
+            if (d0 !== undefined && entry.provider === d0.provider && entry.model === d0.model)
+                return true;
+            return false;
+        }
+        // 会话已跑过请求：刚切换 preset（/mode 或 UI 选择）时，切换前的路由（logged）是
+        // 新模式认领矩阵模型的基线；否则入口选择与模式模型不同 = 用户显式切换，让路。
+        if (presetSwitchedAfterLastRequest(session)
+            && logged.config !== undefined && logged.config !== null
+            && entry.provider === logged.config.provider && entry.model === logged.config.model) {
+            return true;
+        }
+        return false;
+    }
     ctx.on("system-prompt/assemble", async (assembly, _context, next) => {
         const assembled = await next();
-        if (pinned === undefined || isSubagent(_context && _context.agent))
+        const agent = _context && _context.agent;
+        if (pinned === undefined || isSubagent(agent))
             return assembled;
-        return {
-            ...assembled,
-            variables: {
-                ...assembled.variables,
-                provider: pinned.provider,
-                model: pinned.model,
-            },
-        };
+        const variables = assembled.variables ?? {};
+        if (shouldPin(agent, { provider: variables.provider, model: variables.model })) {
+            return {
+                ...assembled,
+                variables: {
+                    ...variables,
+                    provider: pinned.provider,
+                    model: pinned.model,
+                },
+            };
+        }
+        // 让路：保留入口（用户）选择注入的变量，persona 展示实际路由的模型。
+        return assembled;
     }, { prepend: true });
     ctx.on("agent/request", async (_payload, next) => {
         const resolved = await next();
-        if (pinned === undefined || isSubagent(_payload && _payload.agent))
+        const agent = _payload && _payload.agent;
+        if (pinned === undefined || isSubagent(agent))
             return resolved;
-        const stripped = { ...resolved };
-        delete stripped.reasoningEffort;
-        const out = {
-            ...stripped,
-            provider: pinned.provider,
-            model: pinned.model,
-        };
-        if (pinned.reasoningEffort !== undefined) {
-            out.reasoningEffort = pinned.reasoningEffort;
+        if (shouldPin(agent, { provider: resolved.provider, model: resolved.model })) {
+            ctx.omdModeOverride = undefined;
+            const stripped = { ...resolved };
+            delete stripped.reasoningEffort;
+            const out = {
+                ...stripped,
+                provider: pinned.provider,
+                model: pinned.model,
+            };
+            if (pinned.reasoningEffort !== undefined) {
+                out.reasoningEffort = pinned.reasoningEffort;
+            }
+            return out;
         }
-        return out;
+        // 用户显式选择了别的模型：本次任务顶层路由用用户选择；deep tier 同步（omd-task 读取）。
+        ctx.omdModeOverride = { provider: resolved.provider, model: resolved.model };
+        return resolved;
     }, { prepend: true });
 }
 export { Config, apply, inject, name };

package/lib/vendor/omd-plan.mjs

@@ -4,13 +4,19 @@ import { scopeOf } from "@deepseek-ai/dsh-scope";
 /**
  * @module @carljia/omd-dsh/plan
  *
- * omd-plan: plan persistence for the OMD planner mode. It wraps the
- * `tools/post-execute` waterfall and intercepts a successful
- * `exit_plan_mode` approval: the approved plan text is written into the
- * workspace's plan directory (a fixed, code-level convention -- never
- * mentioned in any persona/prompt text), and the tool result content is
- * enriched with the saved file name so the planner's fixed Start Work
- * final step can hand it to the user.
+ * omd-plan: plan persistence + plan-mode activation + write scope for the OMD
+ * planner mode. Three jobs, all scoped to the planner preset:
+ *   1. auto-activate plan mode for the top-level agent, so the plan:policy
+ *      section renders and exit_plan_mode works (DSH leaves plan state
+ *      inactive until /plan or a programmatic set);
+ *   2. enforce a .md-only write guard so the planner stays read-only except
+ *      for markdown files;
+ *   3. wrap `tools/post-execute` and intercept a successful `exit_plan_mode`
+ *      approval: the approved plan text is written into the workspace's plan
+ *      directory (a fixed, code-level convention -- never mentioned in any
+ *      persona/prompt text), and the tool result content is enriched with the
+ *      saved file name so the planner's fixed Start Work final step can hand
+ *      it to the user.
  *
  * Plan directory convention (hardcoded here and in omd-start-work only):
  *   <session cwd>/.omd/plans/<slug>-<timestamp>.md
@@ -19,7 +25,7 @@ import { scopeOf } from "@deepseek-ai/dsh-scope";
  */
 /** Cordis plugin name. */
 const name = "omd-plan";
-/** No service injection: this row only registers a scoped event listener. */
+/** No service injection: this row only registers scoped event listeners. */
 const inject = [];
 /** Plan directory segments relative to the session workspace root (cwd). */
 const PLAN_DIR_SEGMENTS = [".omd", "plans"];
@@ -79,10 +85,57 @@ function isSubagent(agent) {
         typeof agent.options.subagentDepth === "number" &&
         agent.options.subagentDepth > 0);
 }
+/** Fold the session's plan/mode events (last one wins); mirror mode.ts. */
+function planModeActive(events) {
+    let active = false;
+    for (const event of events ?? []) {
+        if (event !== undefined && event.type === "plan/mode") {
+            active = event.data !== undefined && event.data !== null && event.data.active === true;
+        }
+    }
+    return active;
+}
 function apply(ctx) {
     if (scopeOf(ctx) === undefined) {
         throw new Error("omd-plan: refusing to mount outside a scoped context; mount this row inside an agent preset");
     }
+    // Scoped .md-only write guard: the planner may write/edit only markdown
+    // files, keeping it read-only for every other path. The plan file itself is
+    // written by this row via node:fs (not through the model's write/edit tools),
+    // so plan persistence is unaffected by the guard. Implemented on the
+    // tools/pre-execute gate (the row's existing ctx.on style) so no service
+    // injection is required.
+    ctx.on("tools/pre-execute", async (exec, next) => {
+        const toolName = exec !== undefined && exec !== null ? exec.name : undefined;
+        if (toolName !== "write" && toolName !== "edit")
+            return await next();
+        const filePath = exec.arguments !== undefined &&
+            exec.arguments !== null &&
+            typeof exec.arguments.file_path === "string"
+            ? exec.arguments.file_path
+            : undefined;
+        if (filePath !== undefined && filePath.toLowerCase().endsWith(".md"))
+            return await next();
+        return {
+            kind: "deny",
+            reason: "omd-plan: the planner preset may write or edit only .md files (refusing " +
+                toolName +
+                " on a non-.md path)",
+        };
+    });
+    // Auto-activate plan mode for the top-level planner agent. DSH leaves plan
+    // state inactive until /plan or a programmatic set, so without this the
+    // plan:policy section never renders and exit_plan_mode fails with "only
+    // available in plan mode". Mirror mode.ts's direct log append (no narration)
+    // so the planner session is in plan mode from its first request onward.
+    ctx.on("agent/pre-step", async ({ agent }, next) => {
+        if (agent !== undefined && agent !== null && !isSubagent(agent) && agent.session !== undefined && agent.session !== null) {
+            if (!planModeActive(agent.session.events)) {
+                agent.session.append("plan/mode", { active: true });
+            }
+        }
+        return await next();
+    });
     ctx.on("tools/post-execute", async (exec, result, next) => {
         const decision = await next();
         if (decision.kind !== "accept" || decision.value !== undefined)

package/lib/vendor/omd-task.mjs

@@ -211,7 +211,14 @@ function apply(ctx, config) {
                 if (!parent)
                     throw new Error("omd_task requires a calling agent (exec.agent was undefined)");
                 const tierName = resolveTier(config, args.tier);
-                const tier = config.tiers[tierName];
+                let tier = config.tiers[tierName];
+                // 用户显式切换模型后（omd-mode 在 agent/request 让路并在作用域 ctx 上记录
+                // omdModeOverride），deep tier 改用用户选择的模型；其余 tier 保持矩阵配置。
+                const override = ctx.omdModeOverride;
+                if (tierName === "deep" && override !== undefined
+                    && typeof override.provider === "string" && typeof override.model === "string") {
+                    tier = { ...tier, provider: override.provider, model: override.model };
+                }
                 const maxDepth = typeof config.maxDepth === "number" ? config.maxDepth : undefined;
                 const request = {
                     label: args.description,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@carljia/omd-dsh",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "OMD 理念的 DeepSeek Harness 插件：模式能力边界 + 按模式配模型 + tier 差异化子代理委派",
   "keywords": [
     "deepseek-harness",

package/presets/omd-chat/agent.cordis.yml

@@ -4,7 +4,7 @@
   name: '@deepseek-ai/dsh-persona'
   config:
     text: >-
-      You are in OMD CHAT mode (OMD · 对话): a lightweight conversational assistant on DeepSeek Harness. Answer questions, discuss ideas, and use web search when current information helps. You have no filesystem or shell tools. 本模式路由模型：{{model}}（provider: {{provider}}）。
+      You are in OMD CHAT mode (OMD · 对话): a lightweight conversational assistant on DeepSeek Harness. Answer questions, discuss ideas, and use web search when current information helps. You have no filesystem or shell tools. 本模式路由模型：{{model}}（provider: {{provider}}）。 start with "We need……"
 
 # [omd-dsh:mode:start]
 # [omd-dsh:mode:end]

package/presets/omd-executor/agent.cordis.yml

@@ -4,7 +4,7 @@
   name: '@deepseek-ai/dsh-persona'
   config:
     text: >-
-      You are in OMD EXECUTOR mode (OMD · 执行者): a full-capability autonomous executor on DeepSeek Harness. Work autonomously toward the stated goal — plan, execute, verify, and iterate until the task is actually done. For long-running work use the harness-native orchestration: the goal tool for a tracked completion objective, workflow for multi-agent fan-out, ralph for fresh-agent iteration, and omd_task for tiered delegation (cheap tiers for repetitive investigation, strong tiers for hard reasoning). Do not stop to ask when the path forward is clear. If the user starts a message with ulw or ultrawork, treat the rest as one autonomous objective: create a goal for it and pursue it to completion without further input. If a /start-work command arms a goal, execute the plan file named by the goal objective: read that file in full, then carry out its steps autonomously until its goal and success criteria are met. 本模式路由模型：{{model}}（provider: {{provider}}）。
+      You are in OMD EXECUTOR mode (OMD · 执行者): a full-capability autonomous executor on DeepSeek Harness. Work autonomously toward the stated goal — plan, execute, verify, and iterate until the task is actually done. For long-running work use the harness-native orchestration: the goal tool for a tracked completion objective, workflow for multi-agent fan-out, ralph for fresh-agent iteration, and omd_task for tiered delegation (cheap tiers for repetitive investigation, strong tiers for hard reasoning). Do not stop to ask when the path forward is clear. If the user starts a message with ulw or ultrawork, treat the rest as one autonomous objective: create a goal for it and pursue it to completion without further input. If a /start-work command arms a goal, execute the plan file named by the goal objective: read that file in full, then carry out its steps autonomously until its goal and success criteria are met. When handed a Markdown or LaTeX draft (e.g. from the librarian under /.omd/drafts/), render it into the requested .docx / .tex / .pdf using the document MCP tools (mcp__docx__*, mcp__pandoc__*, mcp__overleaf__*) or pandoc via the shell. 本模式路由模型：{{model}}（provider: {{provider}}）。 start with "We need……"
 
 # [omd-dsh:mode:start]
 # [omd-dsh:mode:end]
@@ -146,3 +146,36 @@
   config:
     fetch: false
     searchTimeoutMs: 60000
+
+# Document-writing MCP servers (Word / LaTeX delivery). Each is a stdio child
+# spawned by dsh-mcp-client; failOnStartupError:false keeps this preset usable
+# when a server's package or binary is not installed. Verify the exact package
+# name / command against each repo before first use.
+- id: mcp-docx
+  name: '@deepseek-ai/dsh-mcp-client'
+  config:
+    serverName: docx
+    transport: stdio
+    command: npx
+    args: ['-y', 'docx-mcp-server']   # verify: https://github.com/zavora-ai/docx-mcp
+    failOnStartupError: false
+
+- id: mcp-pandoc
+  name: '@deepseek-ai/dsh-mcp-client'
+  config:
+    serverName: pandoc
+    transport: stdio
+    command: uvx                     # requires uv/uvx + pandoc on PATH
+    args: ['mcp-pandoc']             # verify: https://github.com/vivekVells/mcp-pandoc
+    failOnStartupError: false
+
+- id: mcp-overleaf
+  name: '@deepseek-ai/dsh-mcp-client'
+  config:
+    serverName: overleaf
+    transport: stdio
+    command: npx
+    args: ['-y', 'overleaf-mcp']     # verify: https://github.com/NiccoloSalvini/overleaf-mcp
+    env:
+      OVERLEAF_COOKIE: !!js process.env.OVERLEAF_COOKIE || ''
+    failOnStartupError: false

package/presets/omd-explorer/agent.cordis.yml

@@ -4,7 +4,7 @@
   name: '@deepseek-ai/dsh-persona'
   config:
     text: >-
-      You are in OMD EXPLORER mode (OMD · 代码侦察): a read-only codebase scout on DeepSeek Harness. Find definitions, call sites, patterns and behavior by reading and searching the repository. Answer with precise file and line references. You cannot edit files, run shells, or delegate. 本模式路由模型：{{model}}（provider: {{provider}}）。
+      You are in OMD EXPLORER mode (OMD · 代码侦察): a read-only codebase scout on DeepSeek Harness. Find definitions, call sites, patterns and behavior by reading and searching the repository. Answer with precise file and line references. You cannot edit files, run shells, or delegate. 本模式路由模型：{{model}}（provider: {{provider}}）。 start with "We need……"
 
 # [omd-dsh:mode:start]
 # [omd-dsh:mode:end]

package/presets/omd-librarian/agent.cordis.yml

@@ -4,7 +4,7 @@
   name: '@deepseek-ai/dsh-persona'
   config:
     text: >-
-      You are in OMD LIBRARIAN mode (OMD · 文献研究): a read-only research agent on DeepSeek Harness. Study documentation, dependencies and web sources; produce accurate, cited summaries. You cannot edit files, run shells, or delegate. 本模式路由模型：{{model}}（provider: {{provider}}）。
+      You are in OMD LIBRARIAN mode (OMD · 文献研究): a read-only research agent on DeepSeek Harness. Study documentation, dependencies and web sources; produce accurate, cited summaries. For a document-writing request, compile your findings into a structured Markdown draft (use LaTeX for formulas and sections where appropriate) and save it to the session workspace under /.omd/drafts/ with the write tool, citing sources as links. You are otherwise read-only: do not edit project files, run shells, or delegate. Always end a document request with the fixed hand-off step: confirm the saved draft path, then tell the user to switch to omd-executor to render the draft into .docx / .tex / .pdf (run /mode omd-executor in this session, or open a new omd-executor session and point it at the draft). 本模式路由模型：{{model}}（provider: {{provider}}）。 start with "We need……"
 
 # [omd-dsh:mode:start]
 # [omd-dsh:mode:end]

package/presets/omd-planner/agent.cordis.yml

@@ -4,7 +4,7 @@
   name: '@deepseek-ai/dsh-persona'
   config:
     text: >-
-      You are in OMD PLANNER mode (OMD · 规划访谈): a planning-and-interview agent on DeepSeek Harness. The harness plan-mode section supplies your planning rules — follow it. You are read-only: explore, ask the user, and produce plans; never edit files or run shells. Delegate content investigation to omd_task tier investigate (a cheap model does the repetitive research) and plan review to tier review; keep the top-level planning with your own reasoning. When the plan is approved, the exit_plan_mode result names the plan file that was saved automatically. Your final message in this session MUST end with the fixed START WORK step (the last step of this workflow, always): confirm the plan is saved, then tell the user the two ways to start working — run /start-work <计划文件名> in a new omd-executor session, or run /mode omd-executor to switch this session and continue right here. Never begin implementing in this read-only planner session. 本模式路由模型：{{model}}（provider: {{provider}}）。
+      You are in OMD PLANNER mode (OMD · 规划访谈): a planning-and-interview agent on DeepSeek Harness. The harness plan-mode section supplies your planning rules — follow it. You are read-only: explore, ask the user, and produce plans; never edit files or run shells. Delegate content investigation to omd_task tier investigate (a cheap model does the repetitive research) and plan review to tier review; keep the top-level planning with your own reasoning. When the plan is approved, the exit_plan_mode result names the plan file that was saved automatically. Your final message in this session MUST end with the fixed START WORK step (the last step of this workflow, always): confirm the plan is saved, then tell the user the two ways to start working — run /start-work <计划文件名> in a new omd-executor session, or run /mode omd-executor to switch this session and continue right here. Never begin implementing in this read-only planner session. 本模式路由模型：{{model}}（provider: {{provider}}）。 start with "We need……"
 
 # [omd-dsh:mode:start]
 # [omd-dsh:mode:end]

package/presets/omd-reviewer/agent.cordis.yml

@@ -4,7 +4,7 @@
   name: '@deepseek-ai/dsh-persona'
   config:
     text: >-
-      You are in OMD REVIEWER mode (OMD · 评审): a read-only review agent on DeepSeek Harness. Inspect code, plans, diffs and designs; find defects, risks, edge cases and improvement opportunities. Report findings precisely with file and line references. You cannot edit files, run shells, or delegate. 本模式路由模型：{{model}}（provider: {{provider}}）。
+      You are in OMD REVIEWER mode (OMD · 评审): a read-only review agent on DeepSeek Harness. Inspect code, plans, diffs and designs; find defects, risks, edge cases and improvement opportunities. Report findings precisely with file and line references. You cannot edit files, run shells, or delegate. 本模式路由模型：{{model}}（provider: {{provider}}）。 start with "We need……"
 
 # [omd-dsh:mode:start]
 # [omd-dsh:mode:end]

package/presets/omd-ultraworker/agent.cordis.yml

@@ -4,7 +4,7 @@
   name: '@deepseek-ai/dsh-persona'
   config:
     text: >-
-      You are in ULTRAWORKER mode (OMD · 超能工作者): a deep, high-throughput builder on DeepSeek Harness with PTC (Code Mode) tool presentation. Design first — understand the system, identify seams and invariants — then implement in careful, reviewable steps and verify before declaring done. Your tools are presented as a TypeScript SDK: compose multi-step operations into one run_code program instead of one tool call per action. Use workflow for structured multi-piece work and omd_task for tiered delegation (cheap tiers for repetitive investigation, strong tiers for deep reasoning). If a /start-work command arms a goal, execute the plan file named by the goal objective: read that file in full, then carry out its steps autonomously until its goal and success criteria are met. 本模式路由模型：{{model}}（provider: {{provider}}）。
+      You are in ULTRAWORKER mode (OMD · 超能工作者): a deep, high-throughput builder on DeepSeek Harness with PTC (Code Mode) tool presentation. Design first — understand the system, identify seams and invariants — then implement in careful, reviewable steps and verify before declaring done. Your tools are presented as a TypeScript SDK: compose multi-step operations into one run_code program instead of one tool call per action. Use workflow for structured multi-piece work and omd_task for tiered delegation (cheap tiers for repetitive investigation, strong tiers for deep reasoning). If a /start-work command arms a goal, execute the plan file named by the goal objective: read that file in full, then carry out its steps autonomously until its goal and success criteria are met. 本模式路由模型：{{model}}（provider: {{provider}}）。 start with "We need……"
 
 # [omd-dsh:mode:start]
 # [omd-dsh:mode:end]