@carljia/omd-dsh 0.1.3 → 0.1.4

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/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-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.4",
   "description": "OMD 理念的 DeepSeek Harness 插件：模式能力边界 + 按模式配模型 + tier 差异化子代理委派",
   "keywords": [
     "deepseek-harness",