Add @razroo/iso-route — one model policy, every harness

Declare a default model + named roles once; iso-route compiles that
policy into each harness's native config: .claude/settings.json,
.codex/config.toml (with per-role profiles), opencode.json (with
per-agent overrides), and an advisory README note for Cursor. Emits a
resolved role map alongside the Claude settings so iso-harness can
stamp per-subagent frontmatter consistently.

Honest about ceilings: warns when a harness can't bind models
programmatically (Cursor) or lacks runtime fallback (everywhere).
Fallback chains are recorded in the resolved map but not encoded into
harness config — runtime routing belongs in proxy layers (OpenRouter,
LiteLLM), not a build-time transpiler.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: AceGreenman

README.md

@@ -25,8 +25,10 @@ Today, writing agent instructions is fragmented on two axes:
 
 Three core packages compose into a build pipeline that fixes both,
 [`@razroo/iso`](./packages/iso) runs the whole chain as one command,
-[`@razroo/iso-eval`](./packages/iso-eval) scores whether the resulting
-agent actually completes real tasks, and
+[`@razroo/iso-route`](./packages/iso-route) compiles one model policy
+into each harness's config so you can swap models everywhere with a
+single edit, [`@razroo/iso-eval`](./packages/iso-eval) scores whether
+the resulting agent actually completes real tasks, and
 [`@razroo/iso-trace`](./packages/iso-trace) parses production transcripts
 so you can see what your agent *really* does in the wild:
 
@@ -87,6 +89,15 @@ project that exercises the wrapper end-to-end.
   MCP servers into `CLAUDE.md`, `AGENTS.md`, `.cursor/rules/*.mdc`,
   `.opencode/agents/*.md`, etc., so all four harnesses stay in lockstep.
 
+- **[`packages/iso-route`](./packages/iso-route)** — [`@razroo/iso-route`](https://www.npmjs.com/package/@razroo/iso-route)
+  One model policy, every harness. Declare a default model plus named
+  roles (`planner`, `fast-edit`, `reviewer`, …) in a single
+  `models.yaml`; iso-route compiles that into `.claude/settings.json`,
+  `.codex/config.toml`, `opencode.json`, and a resolved role map that
+  `iso-harness` consumes when stamping per-subagent frontmatter. Honest
+  about ceilings — warns loudly where a harness (e.g. Cursor) can't bind
+  models programmatically.
+
 - **[`packages/iso-eval`](./packages/iso-eval)** — [`@razroo/iso-eval`](https://www.npmjs.com/package/@razroo/iso-eval)
   Behavioral eval runner for the produced harness. Snapshots a workspace
   per task, hands it to a runner with the task prompt, then scores the
@@ -117,6 +128,7 @@ iso/
     ├── isolint/          # portable prose
     ├── iso-harness/      # one source, every harness
     ├── iso/              # one command for the whole pipeline
+    ├── iso-route/        # one model policy → per-harness config
     ├── iso-eval/         # behavioral eval on the produced harness
     └── iso-trace/        # parse + query real agent transcripts (observability)
 ```

package-lock.json

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Razroo
+
+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.

packages/iso-route/LICENSE

@@ -0,0 +1,124 @@
+# @razroo/iso-route
+
+**One model policy, every harness.**
+
+`agentmd`, `isolint`, and `iso-harness` get your *prompts* to every coding
+agent. `@razroo/iso-route` does the same thing for your *model choices*:
+you declare a default model plus named roles once, and iso-route compiles
+that policy into the config file each harness actually reads —
+`.claude/settings.json`, `.codex/config.toml`, `opencode.json` — plus a
+README note for Cursor (which has no file-based model binding).
+
+Use it to swap Opus for Sonnet everywhere with a single edit, pin a
+cheaper model to a `fast-edit` role, or send a `reviewer` role to a
+different provider entirely.
+
+> **v0.1 scope:** emits config files for Claude Code, Codex, and OpenCode,
+> and a resolved role map (`iso-route.resolved.json`) that `iso-harness`
+> consumes when it stamps per-subagent frontmatter. Fallback chains are
+> recorded in the resolved map but *not* encoded into any harness config
+> — runtime routing lives in proxy layers (OpenRouter, LiteLLM), not
+> iso-route.
+
+## Install
+
+```bash
+npm install -D @razroo/iso-route
+```
+
+## Policy shape
+
+```yaml
+# models.yaml
+default:
+  provider: anthropic
+  model: claude-sonnet-4-6
+
+roles:
+  planner:
+    provider: anthropic
+    model: claude-opus-4-7
+    reasoning: high
+
+  fast-edit:
+    provider: anthropic
+    model: claude-haiku-4-5
+
+  reviewer:
+    provider: openai
+    model: gpt-5
+    fallback:
+      - { provider: anthropic, model: claude-sonnet-4-6 }
+```
+
+Valid providers: `anthropic`, `openai`, `google`, `xai`, `deepseek`,
+`mistral`, `groq`, `ollama`, `openrouter`, `local`.
+Valid `reasoning` levels: `low`, `medium`, `high`.
+
+## Fan-out mapping
+
+| Field                     | Claude Code                          | Codex                                                | OpenCode                               | Cursor                           |
+| ------------------------- | ------------------------------------ | ---------------------------------------------------- | -------------------------------------- | -------------------------------- |
+| `default.model`           | `.claude/settings.json` `model`      | `.codex/config.toml` `model`                         | `opencode.json` top-level `model`      | README note only                 |
+| `roles.<name>.model`      | resolved map (iso-harness stamps)    | `[profiles.<name>]` in `config.toml`                 | `agent.<name>.model` in `opencode.json`| advisory row in README note      |
+| `reasoning`               | closest model tier                   | `model_reasoning_effort`                             | provider-specific                      | advisory                         |
+| `fallback[]`              | resolved map only (runtime unsupported) | resolved map only                                 | resolved map only                      | resolved map only                |
+| provider auth             | env var convention                   | `[model_providers.<name>]` block                     | `provider` block with `npm` package    | —                                |
+
+Cursor has no programmatic way to bind a model to a rule or chat, so
+iso-route emits a README note at `.cursor/iso-route.md` and warns at build
+time. Everything else gets a real config file.
+
+## CLI
+
+```bash
+iso-route build models.yaml --out .
+iso-route build models.yaml --targets claude,codex --dry-run
+iso-route plan  models.yaml
+```
+
+`build` writes per-harness files under `--out` (defaults to `.`). Add
+`--dry-run` to preview without touching disk. `plan` prints the resolved
+role table so you can eyeball what each harness will see.
+
+## Library API
+
+```ts
+import { build, loadPolicy } from "@razroo/iso-route";
+
+const result = build({ source: "./models.yaml", out: "./.out", dryRun: true });
+for (const w of result.warnings) console.warn(w);
+```
+
+Individual emitters are exported too (`emitClaude`, `emitCodex`,
+`emitOpenCode`, `emitCursor`) if you only need one target.
+
+## How this fits the rest of the pipeline
+
+```
+agent.md  →  agentmd lint  →  agentmd render  →  isolint lint  →  iso-harness build
+                                                                         +
+                                        models.yaml  →  iso-route build  ┘
+                                                                         │
+                                                                         ▼
+                                                          project with CLAUDE.md, settings.json,
+                                                          config.toml, opencode.json, …
+```
+
+`iso-harness` owns *what the agent reads*. `iso-route` owns *which model
+reads it*. They share one output directory and are designed to be run
+back-to-back — the `@razroo/iso` wrapper will compose them for you.
+
+## What iso-route is NOT
+
+- **Not a request-level router.** Picking a cheaper model per-request
+  based on prompt complexity belongs in a proxy (OpenRouter, LiteLLM,
+  Portkey, Not Diamond). iso-route is a build-time transpiler, not an
+  inference-path component.
+- **Not a model catalog.** It validates provider names, not model IDs.
+  If you type a model name your provider doesn't recognize, you'll find
+  out at runtime. A catalog package may land in v0.2.
+
+## License
+
+MIT — see [LICENSE](./LICENSE).

packages/iso-route/README.md

@@ -0,0 +1,33 @@
+# Example iso-route policy.
+#
+# The shape is intentionally small: one default model every harness falls back
+# to, plus named roles that harness-specific machinery (Claude Code subagents,
+# Codex profiles, OpenCode agents) can bind to.
+#
+# iso-route ONLY handles model selection. Prompts, rules, and subagent bodies
+# are owned by agentmd + iso-harness. Everything here compiles to *config*,
+# not prose.
+
+default:
+  provider: anthropic
+  model: claude-sonnet-4-6
+
+roles:
+  planner:
+    provider: anthropic
+    model: claude-opus-4-7
+    reasoning: high
+
+  fast-edit:
+    provider: anthropic
+    model: claude-haiku-4-5
+
+  reviewer:
+    provider: openai
+    model: gpt-5
+    fallback:
+      - { provider: anthropic, model: claude-sonnet-4-6 }
+
+  local-smoke:
+    provider: ollama
+    model: qwen2.5-coder:7b

packages/iso-route/examples/models.yaml

@@ -0,0 +1,65 @@
+{
+  "name": "@razroo/iso-route",
+  "version": "0.1.0",
+  "description": "Author one model policy; fan out to every harness that supports it. Translates role-based model selection into settings.json, config.toml, opencode.json, and a machine-readable resolved map.",
+  "license": "MIT",
+  "type": "module",
+  "sideEffects": false,
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "iso-route": "dist/cli.js"
+  },
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "examples",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "clean": "rm -rf dist",
+    "dev": "tsc -p tsconfig.json --watch",
+    "test": "node --test --import tsx tests/*.test.ts",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "example": "tsx src/cli.ts build examples/models.yaml --out examples/out --dry-run",
+    "ci": "npm run typecheck && npm test",
+    "prepublishOnly": "npm run clean && npm run build && npm test"
+  },
+  "dependencies": {
+    "yaml": "^2.6.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.0",
+    "tsx": "^4.19.1",
+    "typescript": "^5.6.2"
+  },
+  "engines": {
+    "node": ">=20.6.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/razroo/iso.git",
+    "directory": "packages/iso-route"
+  },
+  "homepage": "https://github.com/razroo/iso/tree/main/packages/iso-route#readme",
+  "bugs": {
+    "url": "https://github.com/razroo/iso/issues"
+  },
+  "keywords": [
+    "agent",
+    "routing",
+    "model",
+    "harness",
+    "ai",
+    "coding-agent",
+    "claude-code",
+    "cursor",
+    "codex",
+    "opencode"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}

packages/iso-route/package.json

@@ -0,0 +1,51 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { loadPolicy } from "./parser.js";
+import { emitClaude } from "./targets/claude.js";
+import { emitCodex } from "./targets/codex.js";
+import { emitCursor } from "./targets/cursor.js";
+import { emitOpenCode } from "./targets/opencode.js";
+import type { BuildResult, EmitResult, HarnessTarget, ModelPolicy } from "./types.js";
+
+export const ALL_TARGETS: HarnessTarget[] = ["claude", "codex", "opencode", "cursor"];
+
+export interface BuildOptions {
+  source: string;
+  out: string;
+  targets?: HarnessTarget[];
+  dryRun?: boolean;
+}
+
+export function build(opts: BuildOptions): BuildResult {
+  const policy = loadPolicy(opts.source);
+  const targets = opts.targets ?? ALL_TARGETS;
+  const outDir = resolve(opts.out);
+  const emits: EmitResult[] = [];
+  for (const t of targets) emits.push(emitFor(t, policy));
+
+  if (!opts.dryRun) {
+    for (const e of emits) {
+      for (const f of e.files) {
+        const full = resolve(outDir, f.path);
+        mkdirSync(dirname(full), { recursive: true });
+        writeFileSync(full, f.contents);
+      }
+    }
+  }
+
+  const warnings = emits.flatMap((e) => e.warnings);
+  return { policy, emits, warnings };
+}
+
+function emitFor(target: HarnessTarget, policy: ModelPolicy): EmitResult {
+  switch (target) {
+    case "claude":
+      return emitClaude(policy);
+    case "codex":
+      return emitCodex(policy);
+    case "opencode":
+      return emitOpenCode(policy);
+    case "cursor":
+      return emitCursor(policy);
+  }
+}