dsh-model-router 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 dsh-model-router contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,94 @@
+# dsh-model-router
+
+A small plugin for the [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness) that stops treating every model call the same. It splits your session into two roles:
+
+- **The planner** — your main agent — always runs on `deepseek-v4-pro`. That's where the thinking happens: understanding what you want, designing the approach, reviewing results, writing the final answer.
+- **The executors** — every subagent it delegates to — always run on `deepseek-v4-flash`. That's where the work happens: writing code, running commands, iterating on builds.
+
+The idea is simple: pro is the better thinker, flash is fast and cheap at grinding through implementation. You get the careful planning of the big model without paying pro prices for every single tool call.
+
+## Install
+
+Add it to a profile (this installs into the `web` profile; change the name for another one):
+
+```bash
+dsh plugin --profile web add git+https://github.com/thedeveloper256/dsh-model-router
+```
+
+That's a git install, so pnpm clones the repo and builds it on the spot. pnpm guards build scripts by default, though — it'll print an `allowBuilds` key you need to add to the profile's `pnpm-workspace.yaml`, then re-run the same `dsh plugin` command. It's a one-time thing:
+
+```yaml
+allowBuilds:
+  dsh-model-router@git+https://github.com/thedeveloper256/dsh-model-router#<commit>: true
+```
+
+Once it's in, restart the profile. You should see the row under `model-router` in `dsh web --dump-config`.
+
+## What it actually does
+
+Three small surfaces, one rule:
+
+1. **Request routing** — every model request gets stamped with a role. Root agents get `deepseek-v4-pro`; delegation children (`subagent`, `subagent_fork`, workflow workers, ralph rounds) get `deepseek-v4-flash`. The rewrite sits at the outermost layer of the request pipeline, so it wins — even over the harness's own default model (which is `deepseek-v4-flash` out of the box) and over whatever model you pick in the UI for the session. That's intentional: it's the "enforce" knob.
+2. **A prompt section** — a short note that renders before the agent's persona, telling the planner: you're the thinker, delegate the implementation. Without this, the model tends to just do everything itself.
+3. **A skill** — the `pro-flash-routing` skill shows up in the session's skill catalog and spells out the working rhythm: plan, delegate, review, report. Same convention, but loadable on demand when the agent wants details.
+
+## How the roles are decided
+
+An agent is an *executor* if it carries either of the markers the harness stamps on delegation children:
+
+- `options.subagentDepth >= 1`, or
+- `session.header.origin === "subagent"`
+
+Everything else is a planner. That logic lives in `src/policy.ts` as a plain function, so it's easy to reason about and test.
+
+### A behavior worth knowing
+
+The router only overrides the model (`provider` + `model`), not the rest of the request. So reasoning effort and the other sampling settings still come from your session's selection — pick "max effort" and you get pro/flash doing max effort, just not a different model. It's "which model runs" that's enforced, not "how hard it thinks".
+
+## Tuning
+
+All configuration lives on the plugin row. If you want different models, or you'd rather the prompt section or skill not be registered, patch the row in the profile's `cordis.patch.yml`:
+
+```yaml
+- patch:
+    - id: model-router
+      config:
+        planner:            # root-agent route
+          provider: deepseek-official
+          model: deepseek-v4-pro
+        executor:           # subagent route
+          provider: deepseek-official
+          model: deepseek-v4-flash
+        promptSection: true # register the always-on routing section
+        skill: true         # register the pro-flash-routing skill
+```
+
+The defaults are exactly the table at the top of this page. To switch the router off for a session, disable the row (`disabled: true`) or remove the plugin — `dsh plugin --profile web remove dsh-model-router`.
+
+## Does it work?
+
+I verified it against a real session log. Run a task that makes the agent plan and delegate, then check which models actually made the requests:
+
+```bash
+zstd -d -c "$DSH_HOME"/sessions/<workspace>/<session>/session.jsonl.zstd \
+  | grep -o '"model":"deepseek-v4-[a-z]*"' | sort | uniq -c
+```
+
+Planner messages come back as `deepseek-v4-pro`; subagent messages as `deepseek-v4-flash`. In my test: 9 pro requests in the planner's session, 6 flash in the subagent's.
+
+## Development
+
+It's a normal small TypeScript package — no framework magic:
+
+```bash
+npm install
+npm run typecheck
+npm test
+npm run build
+```
+
+The `prepare` script builds `lib/` automatically, which is what makes the git install work without shipping build artifacts in the repo. The `dsh.bundle` field in `package.json` is what tells `dsh plugin` how to compose the plugin into a profile.
+
+## License
+
+MIT

package/cordis.patch.yml

@@ -0,0 +1,23 @@
+# dsh-model-router bundle patch.
+#
+# Inserted after the shipped bundle layers of the profile it is installed
+# into, so it overrides nothing but adds one row: the router itself. All
+# routing decisions live in the plugin's config here — there are no other
+# rows to patch because the `agent/request` rewrite applies to every agent
+# regardless of which preset or mode mounts the delegation tools.
+- insert:
+    - id: model-router
+      name: 'dsh-model-router'
+      config:
+        # The session's root agent: planning, design, review, synthesis.
+        planner:
+          provider: deepseek-official
+          model: deepseek-v4-pro
+        # Every delegated subagent: code writing and execution.
+        executor:
+          provider: deepseek-official
+          model: deepseek-v4-flash
+        # Publish the always-on routing convention prompt section.
+        promptSection: true
+        # Register the `pro-flash-routing` skill in the session catalog.
+        skill: true

package/lib/index.d.ts

@@ -0,0 +1,113 @@
+import { Service, Context } from '@deepseek-ai/cordis';
+import z from '@deepseek-ai/schemastery';
+
+/**
+ * Pure routing policy for dsh-model-router: which model each agent role gets.
+ * Kept free of Cordis imports so the policy is trivially unit-testable.
+ * @module dsh-model-router/policy
+ */
+/** One route: a provider/model pair stamped onto an agent request. */
+interface ModelRoute {
+    provider: string;
+    model: string;
+}
+/** The two roles the router distinguishes. */
+type AgentRole = "planner" | "executor";
+/** Resolved router configuration: one route per role. */
+interface RouterConfig {
+    planner: ModelRoute;
+    executor: ModelRoute;
+    promptSection: boolean;
+    skill: boolean;
+}
+/**
+ * Classify an agent as planner or executor.
+ *
+ * The main (root) agent of a session is the planner. Every agent created as a
+ * delegation child — `subagent`, `subagent_fork`, workflow workers, ralph
+ * rounds — is an executor. The harness stamps two durable facts on children:
+ * `options.subagentDepth` (>= 1) and the session header `origin: "subagent"`.
+ *
+ * @param agent - the live agent (any subset of the runtime shape).
+ * @returns the role the agent should be routed as.
+ */
+declare function roleFor(agent: unknown): AgentRole;
+/**
+ * Resolve the route for one agent.
+ * @param agent - the live agent.
+ * @param config - the resolved router configuration.
+ * @returns the model route to stamp, or `undefined` to leave the request alone.
+ */
+declare function routeFor(agent: unknown, config: RouterConfig): ModelRoute | undefined;
+
+/**
+ * dsh-model-router: role-based model routing for the DeepSeek Harness.
+ *
+ * The planner (the session's root agent) runs on `deepseek-v4-pro`; delegated
+ * executor subagents run on `deepseek-v4-flash`. Enforcement is a per-agent
+ * `agent/request` rewrite registered when the agent is created, so it applies
+ * in every mode (web / headless / tui) and every agent preset, including
+ * subagents the delegation tools create.
+ *
+ * The plugin also publishes:
+ *  - a system-prompt section stating the planner/executor convention, and
+ *  - the `pro-flash-routing` skill teaching the agent to plan itself and
+ *    delegate code execution to flash subagents.
+ *
+ * @module dsh-model-router
+ */
+
+/** Plugin row id; the bundle patch inserts it under this id. */
+declare const name = "model-router";
+/** The plugin's public config, validated at row load. */
+declare const Config: z<Schemastery.ObjectS<{
+    planner: z<Schemastery.ObjectS<{
+        provider: z<string, string>;
+        model: z<string, string>;
+    }>, Schemastery.ObjectT<{
+        provider: z<string, string>;
+        model: z<string, string>;
+    }>>;
+    executor: z<Schemastery.ObjectS<{
+        provider: z<string, string>;
+        model: z<string, string>;
+    }>, Schemastery.ObjectT<{
+        provider: z<string, string>;
+        model: z<string, string>;
+    }>>;
+    promptSection: z<boolean, boolean>;
+    skill: z<boolean, boolean>;
+}>, Schemastery.ObjectT<{
+    planner: z<Schemastery.ObjectS<{
+        provider: z<string, string>;
+        model: z<string, string>;
+    }>, Schemastery.ObjectT<{
+        provider: z<string, string>;
+        model: z<string, string>;
+    }>>;
+    executor: z<Schemastery.ObjectS<{
+        provider: z<string, string>;
+        model: z<string, string>;
+    }>, Schemastery.ObjectT<{
+        provider: z<string, string>;
+        model: z<string, string>;
+    }>>;
+    promptSection: z<boolean, boolean>;
+    skill: z<boolean, boolean>;
+}>>;
+declare const SKILL_NAME = "pro-flash-routing";
+declare const SKILL_DESCRIPTION = "Route planning and code execution across models: plan on the pro planner agent, delegate implementation to flash executor subagents.";
+declare const SKILL_WHEN_TO_USE = "Use when a task combines planning and implementation: before writing code, after a plan is approved, when delegating execution work, or when the user asks about the pro/flash routing convention.";
+declare const SKILL_CONTENT = "# Pro planner / Flash executor routing\n\nThis session routes models by role:\n\n- **Planner (this agent)** \u2014 `deepseek-v4-pro`. Planning, design decisions, reviewing delegated output, and user-facing synthesis happen here.\n- **Executors (every subagent)** \u2014 `deepseek-v4-flash`. Implementation work happens there: writing code, running commands, builds, and tests. The harness forces the model automatically; you do not select it.\n\n## Working rhythm\n\n1. **Plan here.** Explore, decide the approach, and (when plan mode is on) submit the plan with `exit_plan_mode`. The plan stays on this agent.\n2. **Delegate the execution.** Once a plan is approved, hand each self-contained chunk of implementation to a subagent with a complete prompt: exact files to touch, the change to make, and how to verify. Subagents are automatically routed to `deepseek-v4-flash`, so keep them execution-focused: give them the decision, not the decision to make.\n3. **Review here.** Read the subagent's result on this agent, verify it yourself (tests, diffs, logs), and iterate with follow-up messages to the same subagent when available.\n4. **Report here.** Summaries, plans, and answers to the user come from this agent.\n\n## Delegation guidelines\n\n- Start independent delegations together in one assistant message and continue useful work while they run (background mode by default).\n- Prefer `subagent` for self-contained work and `workflow` when many independent pieces need fan-out; their workers run on flash as well.\n- Do not delegate design: subagents execute decisions already made.\n- If a subagent's task grows into design work, pull it back to this agent and re-delegate the narrowed execution.\n\n## Verification\n\n- Executor output was produced by `deepseek-v4-flash`; planner output by `deepseek-v4-pro`. If you need to confirm, check the session log's model metadata.\n- If routing ever looks wrong, the `model-router` plugin row in the profile composition is the single place that owns it.";
+/** The plugin row id the bundle patch must insert. */
+declare const ROW_ID = "model-router";
+/**
+ * Cordis service: per-agent request routing plus the convention surface.
+ */
+declare class ModelRouter extends Service {
+    static inject: string[];
+    config: RouterConfig;
+    constructor(ctx: Context, rawConfig?: unknown);
+}
+
+export { type AgentRole, Config, type ModelRoute, ModelRouter, ROW_ID, type RouterConfig, SKILL_CONTENT, SKILL_DESCRIPTION, SKILL_NAME, SKILL_WHEN_TO_USE, ModelRouter as default, name, roleFor, routeFor };

package/lib/index.js

@@ -0,0 +1,133 @@
+// src/index.ts
+import { Service } from "@deepseek-ai/cordis";
+import z from "@deepseek-ai/schemastery";
+
+// src/policy.ts
+function roleFor(agent) {
+  const options = agent?.options;
+  const depth = options?.subagentDepth;
+  if (typeof depth === "number" && depth >= 1) return "executor";
+  const session = agent?.session;
+  const origin = session?.header ? session.header.origin : void 0;
+  if (origin === "subagent") return "executor";
+  return "planner";
+}
+function routeFor(agent, config) {
+  return config[roleFor(agent)];
+}
+
+// src/index.ts
+var name = "model-router";
+var ModelRouteSchema = z.object({
+  provider: z.string().min(1),
+  model: z.string().min(1)
+});
+var Config = z.object({
+  planner: ModelRouteSchema.default({
+    provider: "deepseek-official",
+    model: "deepseek-v4-pro"
+  }),
+  executor: ModelRouteSchema.default({
+    provider: "deepseek-official",
+    model: "deepseek-v4-flash"
+  }),
+  promptSection: z.boolean().default(true),
+  skill: z.boolean().default(true)
+});
+function resolveConfig(raw) {
+  const parsed = Config(raw ?? {});
+  return {
+    planner: parsed.planner,
+    executor: parsed.executor,
+    promptSection: parsed.promptSection,
+    skill: parsed.skill
+  };
+}
+var SECTION_ORDER = -50;
+var SECTION_TEXT = `Model routing is role-based in this session. You are the planner and run on {PLANNER_MODEL}. Do your own planning, design, review of delegated output, and user-facing synthesis on this agent. Code execution runs on {EXECUTOR_MODEL}: after a plan is approved, delegate implementation work \u2014 writing code, running commands, builds, and tests \u2014 to subagents, which are automatically routed to {EXECUTOR_MODEL}. Give each subagent a complete, self-contained prompt and prefer background delegation for independent work. Do not hand-write large amounts of code or run long executions on this planner agent; delegate instead.`;
+var SKILL_NAME = "pro-flash-routing";
+var SKILL_DESCRIPTION = "Route planning and code execution across models: plan on the pro planner agent, delegate implementation to flash executor subagents.";
+var SKILL_WHEN_TO_USE = `Use when a task combines planning and implementation: before writing code, after a plan is approved, when delegating execution work, or when the user asks about the pro/flash routing convention.`;
+var SKILL_CONTENT = `# Pro planner / Flash executor routing
+
+This session routes models by role:
+
+- **Planner (this agent)** \u2014 \`deepseek-v4-pro\`. Planning, design decisions, reviewing delegated output, and user-facing synthesis happen here.
+- **Executors (every subagent)** \u2014 \`deepseek-v4-flash\`. Implementation work happens there: writing code, running commands, builds, and tests. The harness forces the model automatically; you do not select it.
+
+## Working rhythm
+
+1. **Plan here.** Explore, decide the approach, and (when plan mode is on) submit the plan with \`exit_plan_mode\`. The plan stays on this agent.
+2. **Delegate the execution.** Once a plan is approved, hand each self-contained chunk of implementation to a subagent with a complete prompt: exact files to touch, the change to make, and how to verify. Subagents are automatically routed to \`deepseek-v4-flash\`, so keep them execution-focused: give them the decision, not the decision to make.
+3. **Review here.** Read the subagent's result on this agent, verify it yourself (tests, diffs, logs), and iterate with follow-up messages to the same subagent when available.
+4. **Report here.** Summaries, plans, and answers to the user come from this agent.
+
+## Delegation guidelines
+
+- Start independent delegations together in one assistant message and continue useful work while they run (background mode by default).
+- Prefer \`subagent\` for self-contained work and \`workflow\` when many independent pieces need fan-out; their workers run on flash as well.
+- Do not delegate design: subagents execute decisions already made.
+- If a subagent's task grows into design work, pull it back to this agent and re-delegate the narrowed execution.
+
+## Verification
+
+- Executor output was produced by \`deepseek-v4-flash\`; planner output by \`deepseek-v4-pro\`. If you need to confirm, check the session log's model metadata.
+- If routing ever looks wrong, the \`model-router\` plugin row in the profile composition is the single place that owns it.`;
+var ROW_ID = "model-router";
+var ModelRouter = class extends Service {
+  static inject = ["skills", "systemPrompt"];
+  config;
+  constructor(ctx, rawConfig = {}) {
+    super(ctx, "modelRouter");
+    this.config = resolveConfig(rawConfig);
+    const harness = ctx;
+    harness.on("agent/created", ({ agent }) => {
+      const dispose = agent.ctx.on(
+        "agent/request",
+        async (payload, next) => {
+          const resolved = await next();
+          const route = routeFor(agent, this.config);
+          if (route === void 0) return resolved;
+          return { ...resolved, provider: route.provider, model: route.model };
+        },
+        { prepend: true }
+      );
+      harness.on("agent/disposed", (disposed) => {
+        if (disposed === agent) dispose();
+      });
+    });
+    if (this.config.promptSection) {
+      harness.systemPrompt.section({
+        name: ROW_ID,
+        order: SECTION_ORDER,
+        text: SECTION_TEXT.replaceAll("{PLANNER_MODEL}", this.config.planner.model).replaceAll(
+          "{EXECUTOR_MODEL}",
+          this.config.executor.model
+        )
+      });
+    }
+    if (this.config.skill) {
+      harness.skills.register({
+        name: SKILL_NAME,
+        description: SKILL_DESCRIPTION,
+        whenToUse: SKILL_WHEN_TO_USE,
+        content: SKILL_CONTENT,
+        source: "runtime"
+      });
+    }
+  }
+};
+export {
+  Config,
+  ModelRouter,
+  ROW_ID,
+  SKILL_CONTENT,
+  SKILL_DESCRIPTION,
+  SKILL_NAME,
+  SKILL_WHEN_TO_USE,
+  ModelRouter as default,
+  name,
+  roleFor,
+  routeFor
+};
+//# sourceMappingURL=index.js.map

package/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/policy.ts"],"sourcesContent":["/**\n * dsh-model-router: role-based model routing for the DeepSeek Harness.\n *\n * The planner (the session's root agent) runs on `deepseek-v4-pro`; delegated\n * executor subagents run on `deepseek-v4-flash`. Enforcement is a per-agent\n * `agent/request` rewrite registered when the agent is created, so it applies\n * in every mode (web / headless / tui) and every agent preset, including\n * subagents the delegation tools create.\n *\n * The plugin also publishes:\n *  - a system-prompt section stating the planner/executor convention, and\n *  - the `pro-flash-routing` skill teaching the agent to plan itself and\n *    delegate code execution to flash subagents.\n *\n * @module dsh-model-router\n */\nimport { Context, Service } from \"@deepseek-ai/cordis\";\nimport z from \"@deepseek-ai/schemastery\";\nimport { roleFor, routeFor, type RouterConfig } from \"./policy.js\";\n\n/** Plugin row id; the bundle patch inserts it under this id. */\nconst name = \"model-router\";\n\n/** One provider/model pair, with defaults. */\nconst ModelRouteSchema = z.object({\n  provider: z.string().min(1),\n  model: z.string().min(1),\n});\n\n/** The plugin's public config, validated at row load. */\nconst Config = z.object({\n  planner: ModelRouteSchema.default({\n    provider: \"deepseek-official\",\n    model: \"deepseek-v4-pro\",\n  }),\n  executor: ModelRouteSchema.default({\n    provider: \"deepseek-official\",\n    model: \"deepseek-v4-flash\",\n  }),\n  promptSection: z.boolean().default(true),\n  skill: z.boolean().default(true),\n});\n\n/**\n * Resolve raw row config into the internal shape, failing loud on garbage.\n * Schemastery schemas are callable: invoking validates and applies defaults.\n * @param raw - the row's config object.\n * @returns the validated RouterConfig.\n */\nfunction resolveConfig(raw: unknown): RouterConfig {\n  const parsed = Config(raw ?? {});\n  return {\n    planner: parsed.planner,\n    executor: parsed.executor,\n    promptSection: parsed.promptSection,\n    skill: parsed.skill,\n  };\n}\n\n/**\n * Always-on guidance section. Negative order renders before the persona, so\n * the convention is established before the agent's identity line.\n */\nconst SECTION_ORDER = -50;\n\nconst SECTION_TEXT = `Model routing is role-based in this session. You are the planner and run on {PLANNER_MODEL}. Do your own planning, design, review of delegated output, and user-facing synthesis on this agent. Code execution runs on {EXECUTOR_MODEL}: after a plan is approved, delegate implementation work — writing code, running commands, builds, and tests — to subagents, which are automatically routed to {EXECUTOR_MODEL}. Give each subagent a complete, self-contained prompt and prefer background delegation for independent work. Do not hand-write large amounts of code or run long executions on this planner agent; delegate instead.`;\n\nconst SKILL_NAME = \"pro-flash-routing\";\n\nconst SKILL_DESCRIPTION =\n  \"Route planning and code execution across models: plan on the pro planner agent, delegate implementation to flash executor subagents.\";\n\nconst SKILL_WHEN_TO_USE = `Use when a task combines planning and implementation: before writing code, after a plan is approved, when delegating execution work, or when the user asks about the pro/flash routing convention.`;\n\nconst SKILL_CONTENT = `# Pro planner / Flash executor routing\n\nThis session routes models by role:\n\n- **Planner (this agent)** — \\`deepseek-v4-pro\\`. Planning, design decisions, reviewing delegated output, and user-facing synthesis happen here.\n- **Executors (every subagent)** — \\`deepseek-v4-flash\\`. Implementation work happens there: writing code, running commands, builds, and tests. The harness forces the model automatically; you do not select it.\n\n## Working rhythm\n\n1. **Plan here.** Explore, decide the approach, and (when plan mode is on) submit the plan with \\`exit_plan_mode\\`. The plan stays on this agent.\n2. **Delegate the execution.** Once a plan is approved, hand each self-contained chunk of implementation to a subagent with a complete prompt: exact files to touch, the change to make, and how to verify. Subagents are automatically routed to \\`deepseek-v4-flash\\`, so keep them execution-focused: give them the decision, not the decision to make.\n3. **Review here.** Read the subagent's result on this agent, verify it yourself (tests, diffs, logs), and iterate with follow-up messages to the same subagent when available.\n4. **Report here.** Summaries, plans, and answers to the user come from this agent.\n\n## Delegation guidelines\n\n- Start independent delegations together in one assistant message and continue useful work while they run (background mode by default).\n- Prefer \\`subagent\\` for self-contained work and \\`workflow\\` when many independent pieces need fan-out; their workers run on flash as well.\n- Do not delegate design: subagents execute decisions already made.\n- If a subagent's task grows into design work, pull it back to this agent and re-delegate the narrowed execution.\n\n## Verification\n\n- Executor output was produced by \\`deepseek-v4-flash\\`; planner output by \\`deepseek-v4-pro\\`. If you need to confirm, check the session log's model metadata.\n- If routing ever looks wrong, the \\`model-router\\` plugin row in the profile composition is the single place that owns it.`;\n\n/** The plugin row id the bundle patch must insert. */\nconst ROW_ID = \"model-router\";\n\n/** Minimal structural view of the live agent object the router reads. */\ninterface AgentLike {\n  ctx: AgentScopedContext;\n  options?: { subagentDepth?: number };\n  session?: { header?: { origin?: string } };\n}\n\n/** The agent-scoped context's waterfall surface the router uses. */\ninterface AgentScopedContext {\n  on(\n    event: \"agent/request\",\n    listener: (\n      payload: Record<string, unknown>,\n      next: () => Promise<Record<string, unknown>>,\n    ) => Promise<Record<string, unknown>>,\n    options?: { prepend?: boolean },\n  ): () => void;\n}\n\n/** Host-plane surface the router consumes (events, prompt registry, skills). */\ninterface HarnessContext {\n  on(\n    event: \"agent/created\",\n    listener: (payload: { agent: AgentLike }) => void,\n  ): () => void;\n  on(event: \"agent/disposed\", listener: (agent: unknown) => void): () => void;\n  systemPrompt: {\n    section(section: { name: string; order: number; text: string }): unknown;\n  };\n  skills: {\n    register(skill: {\n      name: string;\n      description: string;\n      whenToUse?: string;\n      content: string;\n      source: string;\n    }): unknown;\n  };\n}\n\n/**\n * Cordis service: per-agent request routing plus the convention surface.\n */\nclass ModelRouter extends Service {\n  static inject = [\"skills\", \"systemPrompt\"];\n\n  config: RouterConfig;\n\n  constructor(ctx: Context, rawConfig: unknown = {}) {\n    super(ctx, \"modelRouter\");\n    this.config = resolveConfig(rawConfig);\n    const harness = ctx as unknown as HarnessContext;\n\n    // Every agent that gets created — root sessions, delegation children,\n    // workflow workers, ralph rounds — passes through here.\n    harness.on(\"agent/created\", ({ agent }) => {\n      // `prepend` puts this listener OUTERMOST in the `agent/request`\n      // waterfall: the harness's model-selection listener runs inside it, so\n      // this rewrite is applied LAST and wins over the session's selected\n      // model (which dsh-base defaults to deepseek-v4-flash and the user\n      // settings or UI can change).\n      const dispose = agent.ctx.on(\n        \"agent/request\",\n        async (payload, next) => {\n          const resolved = await next();\n          const route = routeFor(agent, this.config);\n          if (route === undefined) return resolved;\n          return { ...resolved, provider: route.provider, model: route.model };\n        },\n        { prepend: true },\n      );\n      harness.on(\"agent/disposed\", (disposed) => {\n        if (disposed === agent) dispose();\n      });\n    });\n\n    if (this.config.promptSection) {\n      harness.systemPrompt.section({\n        name: ROW_ID,\n        order: SECTION_ORDER,\n        text: SECTION_TEXT.replaceAll(\"{PLANNER_MODEL}\", this.config.planner.model).replaceAll(\n          \"{EXECUTOR_MODEL}\",\n          this.config.executor.model,\n        ),\n      });\n    }\n\n    if (this.config.skill) {\n      harness.skills.register({\n        name: SKILL_NAME,\n        description: SKILL_DESCRIPTION,\n        whenToUse: SKILL_WHEN_TO_USE,\n        content: SKILL_CONTENT,\n        source: \"runtime\",\n      });\n    }\n  }\n}\n\nexport {\n  Config,\n  ModelRouter,\n  ModelRouter as default,\n  name,\n  ROW_ID,\n  SKILL_CONTENT,\n  SKILL_DESCRIPTION,\n  SKILL_NAME,\n  SKILL_WHEN_TO_USE,\n  roleFor,\n  routeFor,\n};\nexport type { AgentRole, ModelRoute, RouterConfig } from \"./policy.js\";\n","/**\n * Pure routing policy for dsh-model-router: which model each agent role gets.\n * Kept free of Cordis imports so the policy is trivially unit-testable.\n * @module dsh-model-router/policy\n */\n\n/** One route: a provider/model pair stamped onto an agent request. */\nexport interface ModelRoute {\n  provider: string;\n  model: string;\n}\n\n/** The two roles the router distinguishes. */\nexport type AgentRole = \"planner\" | \"executor\";\n\n/** Resolved router configuration: one route per role. */\nexport interface RouterConfig {\n  planner: ModelRoute;\n  executor: ModelRoute;\n  promptSection: boolean;\n  skill: boolean;\n}\n\n/**\n * Classify an agent as planner or executor.\n *\n * The main (root) agent of a session is the planner. Every agent created as a\n * delegation child — `subagent`, `subagent_fork`, workflow workers, ralph\n * rounds — is an executor. The harness stamps two durable facts on children:\n * `options.subagentDepth` (>= 1) and the session header `origin: \"subagent\"`.\n *\n * @param agent - the live agent (any subset of the runtime shape).\n * @returns the role the agent should be routed as.\n */\nexport function roleFor(agent: unknown): AgentRole {\n  const options = (agent as { options?: unknown })?.options;\n  const depth = (options as { subagentDepth?: unknown })?.subagentDepth;\n  if (typeof depth === \"number\" && depth >= 1) return \"executor\";\n  const session = (agent as { session?: unknown })?.session;\n  const origin = (session as { header?: unknown })?.header\n    ? ((session as { header: { origin?: unknown } }).header.origin)\n    : undefined;\n  if (origin === \"subagent\") return \"executor\";\n  return \"planner\";\n}\n\n/**\n * Resolve the route for one agent.\n * @param agent - the live agent.\n * @param config - the resolved router configuration.\n * @returns the model route to stamp, or `undefined` to leave the request alone.\n */\nexport function routeFor(agent: unknown, config: RouterConfig): ModelRoute | undefined {\n  return config[roleFor(agent)];\n}\n"],"mappings":"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","names":[]}

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "dsh-model-router",
+  "description": "DeepSeek Harness plugin: role-based model routing — the planner agent runs on deepseek-v4-pro, delegated executor subagents run on deepseek-v4-flash.",
+  "version": "0.1.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib",
+    "cordis.patch.yml",
+    "skills"
+  ],
+  "license": "MIT",
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    }
+  },
+  "scripts": {
+    "build": "tsup",
+    "prepare": "npm run build",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/schemastery": "^3.18.1"
+  },
+  "devDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/schemastery": "^3.18.1",
+    "@types/node": "^22.10.0",
+    "tsup": "^8.3.5",
+    "typescript": "^5.7.2",
+    "vitest": "^2.1.8"
+  },
+  "keywords": [
+    "deepseek",
+    "harness",
+    "dsh",
+    "cordis",
+    "model-routing",
+    "plugin"
+  ]
+}

package/skills/pro-flash-routing/SKILL.md

@@ -0,0 +1,31 @@
+---
+name: pro-flash-routing
+description: Route planning and code execution across models: plan on the pro planner agent, delegate implementation to flash executor subagents.
+whenToUse: Use when a task combines planning and implementation: before writing code, after a plan is approved, when delegating execution work, or when the user asks about the pro/flash routing convention.
+---
+
+# Pro planner / Flash executor routing
+
+This session routes models by role:
+
+- **Planner (the root agent)** — `deepseek-v4-pro`. Planning, design decisions, reviewing delegated output, and user-facing synthesis happen here.
+- **Executors (every subagent)** — `deepseek-v4-flash`. Implementation work happens there: writing code, running commands, builds, and tests. The harness forces the model automatically; you do not select it.
+
+## Working rhythm
+
+1. **Plan here.** Explore, decide the approach, and (when plan mode is on) submit the plan with `exit_plan_mode`. The plan stays on this agent.
+2. **Delegate the execution.** Once a plan is approved, hand each self-contained chunk of implementation to a subagent with a complete prompt: exact files to touch, the change to make, and how to verify. Subagents are automatically routed to `deepseek-v4-flash`, so keep them execution-focused: give them the decision, not the decision to make.
+3. **Review here.** Read the subagent's result on this agent, verify it yourself (tests, diffs, logs), and iterate with follow-up messages to the same subagent when available.
+4. **Report here.** Summaries, plans, and answers to the user come from this agent.
+
+## Delegation guidelines
+
+- Start independent delegations together in one assistant message and continue useful work while they run (background mode by default).
+- Prefer `subagent` for self-contained work and `workflow` when many independent pieces need fan-out; their workers run on flash as well.
+- Do not delegate design: subagents execute decisions already made.
+- If a subagent's task grows into design work, pull it back to this agent and re-delegate the narrowed execution.
+
+## Verification
+
+- Executor output was produced by `deepseek-v4-flash`; planner output by `deepseek-v4-pro`. If you need to confirm, check the session log's model metadata.
+- If routing ever looks wrong, the `model-router` plugin row in the profile composition is the single place that owns it.