@carljia/omd-dsh 0.1.2 → 0.1.4

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

@@ -0,0 +1,146 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { basename, join } from "node:path";
+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.
+ *
+ * Plan directory convention (hardcoded here and in omd-start-work only):
+ *   <session cwd>/.omd/plans/<slug>-<timestamp>.md
+ * The slug derives from the plan's first markdown heading; a timestamp
+ * suffix keeps repeated interviews from overwriting each other.
+ */
+/** Cordis plugin name. */
+const name = "omd-plan";
+/** No service injection: this row only registers a scoped event listener. */
+const inject = [];
+/** Plan directory segments relative to the session workspace root (cwd). */
+const PLAN_DIR_SEGMENTS = [".omd", "plans"];
+/** The exit tool whose approved plan we persist. */
+const EXIT_PLAN_MODE = "exit_plan_mode";
+/** Maximum slug length (characters). */
+const SLUG_MAX = 48;
+/** The plan's first markdown heading (any level), or undefined when it has none. */
+function firstHeading(plan) {
+    for (const line of plan.split("\n")) {
+        const match = /^#{1,6}\s+(.+?)\s*$/.exec(line);
+        if (match)
+            return match[1];
+    }
+    return undefined;
+}
+/** Derive a filesystem-safe slug from the plan title. */
+function slugify(title) {
+    const slug = String(title)
+        .normalize("NFKD")
+        .toLowerCase()
+        .replace(/[^\p{L}\p{N}]+/gu, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, SLUG_MAX);
+    return slug === "" ? "plan" : slug;
+}
+/** Compact local-ish UTC timestamp for the file name: YYYYMMDD-HHmmss. */
+function timestamp() {
+    const d = new Date();
+    const pad = (n) => String(n).padStart(2, "0");
+    return (d.getUTCFullYear() +
+        pad(d.getUTCMonth() + 1) +
+        pad(d.getUTCDate()) +
+        "-" +
+        pad(d.getUTCHours()) +
+        pad(d.getUTCMinutes()) +
+        pad(d.getUTCSeconds()));
+}
+/** Write the plan into <cwd>/.omd/plans/ and return the absolute file path. */
+async function savePlan(cwd, plan) {
+    const dir = join(cwd, ...PLAN_DIR_SEGMENTS);
+    await mkdir(dir, { recursive: true });
+    const file = join(dir, slugify(firstHeading(plan) ?? "") + "-" + timestamp() + ".md");
+    await writeFile(file, plan, "utf8");
+    return file;
+}
+/** Display path used in result enrichment and messages (forward slashes). */
+function displayPath(saved) {
+    return PLAN_DIR_SEGMENTS.join("/") + "/" + basename(saved);
+}
+/** Subagents never own the plan review -- only the top-level planner does. */
+function isSubagent(agent) {
+    return (agent !== undefined &&
+        agent !== null &&
+        agent.options !== undefined &&
+        agent.options !== null &&
+        typeof agent.options.subagentDepth === "number" &&
+        agent.options.subagentDepth > 0);
+}
+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");
+    }
+    ctx.on("tools/post-execute", async (exec, result, next) => {
+        const decision = await next();
+        if (decision.kind !== "accept" || decision.value !== undefined)
+            return decision;
+        if (exec === undefined || exec.name !== EXIT_PLAN_MODE)
+            return decision;
+        if (result.isError)
+            return decision;
+        const agent = exec.agent;
+        if (agent === undefined || isSubagent(agent))
+            return decision;
+        const args = exec.arguments;
+        const plan = args !== undefined && args !== null && typeof args.plan === "string" ? args.plan : undefined;
+        if (plan === undefined)
+            return decision;
+        const cwd = agent.session !== undefined &&
+            agent.session.header !== undefined &&
+            typeof agent.session.header.cwd === "string"
+            ? agent.session.header.cwd
+            : "";
+        if (cwd === "") {
+            // No workspace root to save into: fail closed but tell the model, so
+            // the planner does not promise a file name it never produced.
+            return withNotice(decision, result, {
+                type: "text",
+                text: "The approved plan could NOT be saved automatically: this session has no workspace directory. Ask the user how to proceed.",
+            });
+        }
+        try {
+            const saved = await savePlan(cwd, plan);
+            return withNotice(decision, result, {
+                type: "text",
+                text: "Plan saved to " +
+                    displayPath(saved) +
+                    ". Start work: run /start-work " +
+                    basename(saved) +
+                    " in an omd-executor session, or switch this session with /mode omd-executor and continue here.",
+            });
+        }
+        catch (error) {
+            return withNotice(decision, result, {
+                type: "text",
+                text: "The approved plan could NOT be saved automatically: " +
+                    (error instanceof Error ? error.message : String(error)) +
+                    ". Ask the user how to proceed.",
+            });
+        }
+    });
+}
+/** Keep the accepted decision, appending one text block to its content. */
+function withNotice(decision, result, block) {
+    const base = Array.isArray(decision.content) ? decision.content : result.content ?? [];
+    return {
+        kind: "accept",
+        content: [...base, block],
+        ...(decision.additionalContexts !== undefined
+            ? { additionalContexts: decision.additionalContexts }
+            : {}),
+    };
+}
+export { apply, inject, name };

package/lib/vendor/omd-start-work.mjs

@@ -0,0 +1,147 @@
+import { access, readFile } from "node:fs/promises";
+import { isAbsolute, join } from "node:path";
+import { scopeOf } from "@deepseek-ai/dsh-scope";
+/**
+ * @module @carljia/omd-dsh/startwork
+ *
+ * omd-start-work: human-facing `/start-work` command -- the "start work"
+ * trigger at the end of the OMD planning workflow. It resolves the named
+ * plan file inside the workspace's plan directory (a fixed, code-level
+ * convention -- never mentioned in any persona/prompt text), arms a goal
+ * whose objective references the plan's absolute path, and goal
+ * auto-continuation then drives the agent to execute the plan without
+ * further input.
+ */
+/** Cordis plugin name. */
+const name = "omd-start-work";
+/** The goal domain is already required by tool-goal in the same preset. */
+const inject = ["goals"];
+/** Plan directory segments relative to the session workspace root (cwd). */
+const PLAN_DIR_SEGMENTS = [".omd", "plans"];
+/** The prefix accepted when a user pastes the full relative plan path. */
+const PLAN_DIR_PREFIX = ".omd/plans/";
+/** Plan directory for one workspace root. */
+function plansDir(cwd) {
+    return join(cwd, ...PLAN_DIR_SEGMENTS);
+}
+/**
+ * Resolve the user's file-name input to a candidate path inside the plan
+ * directory. Accepts a bare file name ("foo.md" / "foo") or the full
+ * relative path (".omd/plans/foo.md"); rejects absolute paths and anything
+ * that would escape the plan directory.
+ */
+function resolveCandidate(cwd, input) {
+    const trimmed = String(input).trim().replace(/\\/g, "/");
+    if (trimmed === "" || isAbsolute(trimmed))
+        return undefined;
+    let name = trimmed.replace(/^\.\//, "");
+    if (name.includes("/")) {
+        if (!name.startsWith(PLAN_DIR_PREFIX))
+            return undefined;
+        name = name.slice(PLAN_DIR_PREFIX.length);
+    }
+    if (name === "" || name.includes("/") || name === "." || name === "..")
+        return undefined;
+    if (name.startsWith("."))
+        return undefined; // no hidden-file tricks
+    return join(plansDir(cwd), name);
+}
+/** One /start-work invocation through the goal domain. */
+async function executeStartWork(ctx, invocation) {
+    const agent = invocation.agent;
+    const cwd = agent !== undefined &&
+        agent.session !== undefined &&
+        agent.session.header !== undefined &&
+        typeof agent.session.header.cwd === "string"
+        ? agent.session.header.cwd
+        : "";
+    if (cwd === "") {
+        return {
+            kind: "error",
+            text: "This session has no workspace directory; /start-work needs one to find the plan file.",
+        };
+    }
+    const candidate = resolveCandidate(cwd, invocation.rawInput);
+    if (candidate === undefined) {
+        return {
+            kind: "error",
+            text: "Usage: /start-work <plan file name> — the file must live inside " + PLAN_DIR_SEGMENTS.join("/") + "/.",
+        };
+    }
+    let file = candidate;
+    const usable = async (path) => {
+        try {
+            await access(path);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    };
+    if (!(await usable(file)) && !file.endsWith(".md") && (await usable(file + ".md"))) {
+        file = file + ".md";
+    }
+    else if (!(await usable(file))) {
+        return {
+            kind: "error",
+            text: "Plan file not found: " + PLAN_DIR_SEGMENTS.join("/") + "/" + file.slice(plansDir(cwd).length + 1),
+        };
+    }
+    let text;
+    try {
+        text = await readFile(file, "utf8");
+    }
+    catch (error) {
+        return {
+            kind: "error",
+            text: "Cannot read the plan file: " + (error instanceof Error ? error.message : String(error)),
+        };
+    }
+    if (text.trim() === "") {
+        return { kind: "error", text: "The plan file is empty." };
+    }
+    try {
+        const current = ctx.goals.get(agent);
+        if (current !== undefined && current.phase !== "complete") {
+            return {
+                kind: "error",
+                text: `A goal is already ${current.phase}. Run /goal clear first, then /start-work <plan file name>.`,
+            };
+        }
+        ctx.goals.create(agent, {
+            objective: "Execute the approved plan file at " +
+                file +
+                ". Read the file in full, then carry out every step autonomously: implement, verify, and iterate until the plan's goal and success criteria are met. Work through goal continuation rounds until done.",
+        });
+        return {
+            kind: "success",
+            text: "Start work armed — executing the plan to completion.\nPlan: " +
+                PLAN_DIR_SEGMENTS.join("/") +
+                "/" +
+                file.slice(plansDir(cwd).length + 1),
+        };
+    }
+    catch (error) {
+        return {
+            kind: "error",
+            text: "start-work failed: " + (error instanceof Error ? error.message : String(error)),
+        };
+    }
+}
+function apply(ctx) {
+    if (scopeOf(ctx) === undefined) {
+        throw new Error("omd-start-work: refusing to mount outside a scoped context; mount this row inside an agent preset");
+    }
+    ctx.inject(["commands"], (commandCtx) => {
+        commandCtx.commands.register({
+            name: "start-work",
+            description: "start work: arm a goal that executes the named plan file to completion",
+            input: {
+                hint: "<plan file name>",
+                images: false,
+            },
+            handler: (invocation) => executeStartWork(ctx, invocation),
+        });
+    });
+}
+export { 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/{omd-matrix.json → omd-matrix.default.json}

@@ -14,10 +14,7 @@
           "hint": "cheap and fast — repetitive investigation, searching, summarising, mechanical work",
           "persona": "You are a FAST worker subagent (快速执行子代理): complete the assigned task efficiently with the tools you have; prefer short, focused answers.",
           "toolFilter": {
-            "deny": [
-              "write",
-              "edit"
-            ],
+            "deny": ["write", "edit"],
             "denyShell": true
           }
         },
@@ -29,7 +26,7 @@
         }
       }
     },
-    "architect": {
+    "ultraworker": {
       "provider": "deepseek-official",
       "model": "deepseek-v4-pro",
       "tiers": {
@@ -39,10 +36,7 @@
           "hint": "cheap and fast — repetitive investigation, searching, summarising, mechanical work",
           "persona": "You are a FAST worker subagent (快速执行子代理): complete the assigned task efficiently with the tools you have; prefer short, focused answers.",
           "toolFilter": {
-            "deny": [
-              "write",
-              "edit"
-            ],
+            "deny": ["write", "edit"],
             "denyShell": true
           }
         },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@carljia/omd-dsh",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "OMD 理念的 DeepSeek Harness 插件：模式能力边界 + 按模式配模型 + tier 差异化子代理委派",
   "keywords": [
     "deepseek-harness",
@@ -43,7 +43,7 @@
   "files": [
     "lib",
     "presets",
-    "omd-matrix.json",
+    "omd-matrix.default.json",
     "README.md",
     "LICENSE"
   ],

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

@@ -8,6 +8,8 @@
 
 # [omd-dsh:mode:start]
 # [omd-dsh:mode:end]
+- id: omd-mode-switch
+  name: '../.omd-vendor/omd-mode-switch.mjs'
 - id: tool-ask-user
   name: '@deepseek-ai/dsh-tool-ask-user'
 

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

@@ -4,10 +4,37 @@
   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. 本模式路由模型：{{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. 本模式路由模型：{{model}}（provider: {{provider}}）。
 
 # [omd-dsh:mode:start]
 # [omd-dsh:mode:end]
+- id: omd-start-work
+  name: '../.omd-vendor/omd-start-work.mjs'
+
+- id: omd-mode-switch
+  name: '../.omd-vendor/omd-mode-switch.mjs'
+
+- id: planning
+  name: cordis:group
+  group: true
+  isolate:
+    planMode: true
+  config:
+    - id: plan-mode
+      name: '@deepseek-ai/dsh-plan-mode'
+      config:
+        section: |
+          You are in plan mode. Stay in plan mode until exit_plan_mode succeeds or the user switches the session mode. Imperative language to implement changes means plan the implementation, not execute it. A user's conversational agreement — including an answer confirming something you asked — approves nothing and does not end plan mode; fold the confirmed decision into the plan and submit it through exit_plan_mode.
+
+          Explore first. Use non-mutating reads, searches, static analysis, and checks to ground the plan in the actual repository. Do not edit or write files, change configuration, run formatters or code generation that rewrites tracked files, commit, or otherwise carry out the plan. Prefer existing functions and patterns over new machinery.
+
+          The tool catalog stays the same across modes for request-cache stability. These plan-mode rules override any later tool description or guidance that suggests using mutation tools; those tools remain listed to keep the tool catalog unchanged. Do not use todo_write to track this planning phase: it tracks implementation after an approved plan, while the plan itself belongs in exit_plan_mode.
+
+          Resolve discoverable facts by inspection. Use ask_user_question only for user-owned choices or material ambiguity that inspection cannot answer. Do not ask the user where code lives or how current behavior works when you can find out.
+
+          Make the plan decision-complete: state the goal and success criteria; group implementation changes by subsystem; identify public API, schema, and data-flow changes; cover edge cases, failure modes, tests, acceptance criteria, and explicit assumptions. Keep it concise enough to review but detailed enough that another engineer can implement it without making design decisions.
+
+          When ready, call exit_plan_mode with the complete plan markdown, starting with a # title. Make exit_plan_mode the only and final tool call in that assistant response: it presents the plan for approval, and implementation begins only in a later step after approval. Do not paste the final plan as a plain reply or ask "should I proceed?" through prose or ask_user_question. If review rejects it, incorporate the feedback and present again. If the review channel is unavailable or aborted, stay in plan mode and ask the user to switch modes manually; do not proceed with implementation.
 - id: agent-instructions
   name: '@deepseek-ai/dsh-agent-instructions'
   config:

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

@@ -8,6 +8,8 @@
 
 # [omd-dsh:mode:start]
 # [omd-dsh:mode:end]
+- id: omd-mode-switch
+  name: '../.omd-vendor/omd-mode-switch.mjs'
 - id: agent-instructions
   name: '@deepseek-ai/dsh-agent-instructions'
   config:

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

@@ -8,6 +8,8 @@
 
 # [omd-dsh:mode:start]
 # [omd-dsh:mode:end]
+- id: omd-mode-switch
+  name: '../.omd-vendor/omd-mode-switch.mjs'
 - id: agent-instructions
   name: '@deepseek-ai/dsh-agent-instructions'
   config:

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

@@ -4,10 +4,15 @@
   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. 本模式路由模型：{{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}}）。
 
 # [omd-dsh:mode:start]
 # [omd-dsh:mode:end]
+- id: omd-plan
+  name: '../.omd-vendor/omd-plan.mjs'
+
+- id: omd-mode-switch
+  name: '../.omd-vendor/omd-mode-switch.mjs'
 - id: agent-instructions
   name: '@deepseek-ai/dsh-agent-instructions'
   config:
@@ -35,6 +40,8 @@
 
           When ready, call exit_plan_mode with the complete plan markdown, starting with a # title. Make exit_plan_mode the only and final tool call in that assistant response: it presents the plan for approval, and implementation begins only in a later step after approval. Do not paste the final plan as a plain reply or ask "should I proceed?" through prose or ask_user_question. If review rejects it, incorporate the feedback and present again. If the review channel is unavailable or aborted, stay in plan mode and ask the user to switch modes manually; do not proceed with implementation.
 
+          Once the plan is approved, the exit_plan_mode result names the automatically saved plan file. Close the conversation with your persona's fixed Start Work final step — this is the last workflow step, always — and never start implementing in this read-only session.
+
 - id: tool-fs
   name: '@deepseek-ai/dsh-tool-fs'
 

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

@@ -8,6 +8,8 @@
 
 # [omd-dsh:mode:start]
 # [omd-dsh:mode:end]
+- id: omd-mode-switch
+  name: '../.omd-vendor/omd-mode-switch.mjs'
 - id: agent-instructions
   name: '@deepseek-ai/dsh-agent-instructions'
   config: