codex-model-router 1.1.0 → 2.0.0

package/MAINTAINERS.md

@@ -0,0 +1,92 @@
+# Maintainer Guide
+
+## First npm publication bootstrap
+
+The first publication of a new npm package cannot use Trusted Publishing because the npm package settings do not exist yet. Use the Release workflow's explicit `bootstrap` publication mode exactly once.
+
+The bootstrap token must be a granular npm access token with package read/write access and non-interactive publishing permission. Store it only as the GitHub Actions repository secret named `NPM_TOKEN`; never commit it to the repository or write it into workflow logs.
+
+For the first publication:
+
+1. Open **Actions → Release → Run workflow**.
+2. Keep the workflow definition branch on `main`.
+3. Enter the exact version tag required by `package.json`, for example `v1.2.0`.
+4. Select `bootstrap` for `publish_mode`.
+5. Run the workflow.
+
+The tag may already exist. When it does, the workflow checks out that exact tag and verifies that it is reachable from `main`.
+
+When the tag does not yet exist, a manual bootstrap run starts from the exact current `origin/main` commit, verifies the requested tag matches `v<package.json version>`, runs all tests, validates the release metadata and current Changelog entry, and only then creates and pushes the tag. Normal mode and tag-triggered runs are never allowed to create a missing tag.
+
+Bootstrap mode is rejected when the npm package or exact version already exists. The token is exposed only to the guarded bootstrap step. Tag-triggered releases and manual runs in `normal` mode never receive `NPM_TOKEN`.
+
+After the first version is published, configure Trusted Publishing as described below. Once a later release succeeds through OIDC, delete the `NPM_TOKEN` repository secret.
+
+## npm Trusted Publishing setup
+
+This one-time npm account configuration cannot be committed to the repository.
+
+On the npm package settings page for `codex-model-router`, add a GitHub Actions trusted publisher with:
+
+```text
+Organization or user: Honguan
+Repository: codex-model-router
+Workflow filename: release.yml
+Environment: leave empty unless the workflow is updated to use one
+```
+
+The same relationship can be configured by an authenticated maintainer with npm 11.15.0 or newer:
+
+```sh
+npm trust github codex-model-router \
+  --repo Honguan/codex-model-router \
+  --file release.yml \
+  --allow-publish \
+  --yes
+npm trust list codex-model-router
+```
+
+Normal releases use only `contents: write` and `id-token: write` and publish with provenance.
+
+## Release checklist
+
+1. Verify all Issues and pull-request checks are complete.
+2. Update `package.json`, `CHANGELOG.md`, README version examples, and the shared manifest behavior together.
+3. Run `npm run check`, `npm test`, `npm run test:package`, and `npm pack --dry-run`.
+4. Confirm CI passes on Windows, Linux, and macOS with Node.js 18, 20, 22, and 24.
+5. Confirm actionlint and ShellCheck pass.
+6. For normal releases, create and push the exact tag `v<package.json version>` from `main`.
+7. For the first package publication only, the manual bootstrap flow may create the missing exact tag after all validations pass.
+8. Verify the Release workflow publishes with npm provenance.
+9. Verify the clean public npm end-to-end step passes before the GitHub Release appears.
+10. Confirm `npm view codex-model-router version` and `npx --yes codex-model-router@<version> --version`.
+
+## Manual release retry
+
+Open **Actions → Release → Run workflow**, keep the workflow definition on `main`, and enter the exact version tag in the required `tag` field.
+
+Select publication mode as follows:
+
+- `bootstrap`: only for the first creation of the npm package; it may safely create the missing exact version tag from current `main` after validation.
+- `normal`: every later version and every idempotent retry after the package exists; the tag must already exist.
+
+The branch selector chooses which workflow definition to run; it is not the release target. For an existing tag, the workflow checks out that tag, verifies that its commit is reachable from `main`, validates that the tag matches `package.json`, and then resumes the npm and GitHub Release checks.
+
+Never enter a branch name in the `tag` field. Never reuse a package version that already exists on npm. Never use bootstrap mode for later versions.
+
+## Compatibility update checklist
+
+For every release that changes generated paths, TOML fields, models, or Codex integration:
+
+1. Review the official Codex subagent, skill, and configuration references.
+2. Record the exact Codex CLI version used as the compatibility baseline.
+3. Run the compatibility smoke check in CI.
+4. Update README paths and minimum version claims.
+5. Test project and global scope separately.
+6. Preserve Windows junction, POSIX symlink, LF/CRLF, and user-modification tests.
+
+## Recovery
+
+A failed npm publication does not create a GitHub Release. For an unpublished package, verify the `NPM_TOKEN` bootstrap secret and run the exact version with `publish_mode=bootstrap`; the workflow can create the missing tag safely when necessary. For an existing package, fix the Trusted Publisher relationship and retry the existing exact tag with `publish_mode=normal`.
+
+Delete or recreate a tag manually only when npm does not contain that version and the existing tag is demonstrably wrong. Published npm versions are immutable and must never be reused.

package/README.md

@@ -1,156 +1,145 @@
 # codex-model-router
 
-A small Node.js CLI that installs a Codex skill and two custom subagents without replacing unrelated user configuration.
+A small Node.js CLI that safely installs adaptive Codex subagent routing for Terra, Luna, and Sol without replacing unrelated user configuration or the user's selected primary model.
 
-Routing is advisory: Terra reads the skill and decides when to delegate. This package does not intercept prompts or guarantee a hard model switch.
+> Routing is advisory. Codex reads the installed skills and decides when to delegate. This package does not intercept prompts, guarantee a hard model switch, or modify AGENTS.md.
 
-## Requirements
+## Routing model
 
-- Node.js 18 or newer
-- A current Codex release with custom agents and local skills
+The normal installation uses free mode:
 
-## Install
+- The user-selected primary model handles conversation, clarification, follow-ups, final replies, and trivial work.
+- Terra/high investigates, produces implementation-ready plans, verifies results, debugs, and replans.
+- Luna/max performs most clear, bounded, repetitive, or independently verifiable implementation work.
+- Sol/medium is read-only and used only when Terra still cannot resolve core logic after focused investigation and one materially revised plan, or when the user explicitly requests Sol.
+- Existing built-in and custom agents remain available and take precedence when they are a better match.
 
-From npm after publication:
+A normal workflow is Terra -> Luna -> Terra. Implementation errors return to Luna as focused corrections. Plan or logic errors return to Terra for a revised plan before Luna continues. Sol is not a routine reviewer.
 
-```sh
-npx codex-model-router install
-```
+## Quick start
 
-From GitHub:
+Preview without changing files:
 
 ```sh
-npm install -g https://github.com/Honguan/codex-model-router/archive/refs/tags/v1.1.0.tar.gz
-codex-model-router install
+npx codex-model-router install --dry-run
 ```
 
-Project scope is the default. Use `--global` only when the setup should apply to every project:
+Install free-mode routing and verify it:
 
 ```sh
-codex-model-router install --global
+npx codex-model-router install
+npx codex-model-router doctor
 ```
 
-A normal install preserves an existing main model. To explicitly set Terra/high and make the change reversible:
+Remove only unchanged package-managed files and settings:
 
 ```sh
-codex-model-router install --set-default
+npx codex-model-router uninstall
 ```
 
-Preview without writing anything:
+## Optional Terra default
+
+A normal install does not add or change top-level model settings. Users remain free to select any primary model through Codex.
+
+To explicitly set and track Terra/high as the selected scope's default:
 
 ```sh
-codex-model-router install --set-default --dry-run
-codex-model-router uninstall --dry-run
+codex-model-router install --set-default
 ```
 
-## What is changed
+Running a later plain `install` returns package-managed default settings to free mode. User-modified model settings are preserved.
 
-Project scope manages only:
+## Install
 
-```text
-.codex/config.toml
-.codex/agents/luna.toml
-.codex/agents/sol.toml
-.agents/skills/model-router/SKILL.md
+Run from npm:
+
+```sh
+npx codex-model-router install
 ```
 
-Global scope uses `$CODEX_HOME` or `~/.codex` for Codex files and `~/.agents/skills/model-router/` for the skill.
+Install the command globally:
 
-A plain install adds Terra/high only when the top-level values are absent. Existing values are preserved. `--set-default` replaces only `model` and `model_reasoning_effort`, records the exact prior values, and restores them during uninstall only when the user has not changed them afterward.
+```sh
+npm install -g codex-model-router
+codex-model-router install
+```
 
-Existing Luna, Sol, or skill files are never overwritten. Uninstall removes only unchanged package-owned files. Unrelated TOML settings, comments, BOM, ordering, and LF/CRLF line endings are preserved.
+Installing the CLI globally only makes the command available system-wide. Use `install --global` to install routing for the current user's Codex configuration.
 
-## Installed routing
+Install a specific GitHub release:
 
-- Terra/high: normal questions, coding, debugging, fixes, tests, and implementation
-- Luna/high: deterministic repeated edits, bulk patterns, searches, formatting, counting, extraction, and summaries
-- Sol/medium/workspace-write: security-sensitive or high-regression-risk review and implementation
-- Sol normally reviews first; it may edit files when Terra explicitly delegates implementation or a confirmed fix
-- Simple questions do not spawn a subagent
+```sh
+npm install -g https://github.com/Honguan/codex-model-router/archive/refs/tags/v2.0.0.tar.gz
+codex-model-router install
+```
 
-Users may edit model names, reasoning levels, and `sandbox_mode` directly in the generated TOML files. Later installs preserve those manual edits and `doctor` reports them as user-modified.
+## Managed files
 
-## Commands
+Project scope is the default and manages only:
 
 ```text
-codex-model-router install [--global] [--set-default] [--dry-run]
-codex-model-router uninstall [--global] [--dry-run]
-codex-model-router doctor [--global]
-codex-model-router --version
+.codex/config.toml                              # only with --set-default or a managed migration
+.codex/agents/terra.toml
+.codex/agents/luna.toml
+.codex/agents/sol.toml
+.codex/model-router-state.json
+.codex/config.toml.codex-model-router.bak       # only when needed
+.agents/skills/model-router/SKILL.md
+.agents/skills/implementation-planning/SKILL.md
 ```
 
-`doctor` is read-only. Exit code `0` means healthy; exit code `1` reports missing, invalid, user-modified, overridden, or unsafe state.
-
-## Automatic npm publication
+Use global scope with:
 
-Create a GitHub Actions repository secret named `NPM_TOKEN`:
-
-```text
-Repository Settings
-→ Secrets and variables
-→ Actions
-→ New repository secret
+```sh
+codex-model-router install --global
+codex-model-router doctor --global
 ```
 
-Paste the npm access token as the secret value. Never place the real token in this repository or in the workflow YAML.
+Global scope stores agents under `$CODEX_HOME/agents` and skills under `~/.agents/skills`. When `CODEX_HOME` is unset, it defaults to `~/.codex`.
 
-The `Release` workflow runs after a pull request is merged into `main`, or when started manually. It:
+Existing files at managed paths are never overwritten. Later manual edits are preserved and reported by `doctor`.
 
-1. Runs syntax checks, tests, and the packed-package smoke test.
-2. Reads the name and version from `package.json`.
-3. Creates the matching GitHub release when missing.
-4. Checks whether that exact version already exists on npm.
-5. Publishes only a version that is not already present.
+## Prompt and cache efficiency
 
-Before merging a new release, update `package.json` and `CHANGELOG.md` to the new version. Merges without a version change do not republish the package.
+The installed model-router skill is intentionally short. Detailed planning rules live in the separate implementation-planning skill and are loaded only for nontrivial or uncertain changes.
 
-The npm token must have package read/write permission and must be permitted to publish without an interactive OTP when the account or package requires 2FA.
+Within the same agent thread, accepted state is kept and concise deltas are appended. A new agent thread receives the latest self-contained snapshot. After three deltas or a material contract or logic change, Terra produces a new snapshot.
 
-To publish the current version after adding the secret, open `Actions → Release → Run workflow`.
+Prompt-cache reuse is best effort: genuinely new information cannot be a cache hit on first use. Stable wording and ordering improve repeated-prefix reuse, but correctness takes priority over cache behavior.
 
-## Manual npm publication
+## Planning rules
 
-The package name is unscoped and public. Before the first publish, confirm the name is available and sign in:
+For nontrivial changes, Terra identifies only applicable correctness-critical details, including exact files and symbols, names, contracts, parameter flow, callers, ordered logic, invariants, fixed decisions, safe local choices, return conditions, and acceptance criteria.
 
-```sh
-npm view codex-model-router
-npm login
-npm whoami
-```
+Information is marked as CONFIRMED, PROPOSED, or UNKNOWN. Luna does not begin implementation while an UNKNOWN can materially change behavior, targets, contracts, parameter flow, control flow, or compatibility.
 
-Review exactly what will be uploaded:
+Terra verifies separately whether implementation matches the plan and whether the plan plus implementation satisfy the original requirement. After three cycles without new evidence or a changed decision, the workflow stops instead of repeating the same approach.
 
-```sh
-npm run check
-npm test
-npm run test:package
-npm pack --dry-run
-npm publish --dry-run
-```
-
-Publish from the package root:
+## Commands
 
-```sh
-npm publish
+```text
+codex-model-router install [--global] [--set-default] [--dry-run]
+codex-model-router uninstall [--global] [--dry-run]
+codex-model-router doctor [--global]
+codex-model-router --version
 ```
 
-After publication, verify:
+`doctor` is read-only. Exit code 0 means healthy; exit code 1 means action is required.
 
-```sh
-npm view codex-model-router version
-npx codex-model-router --version
-```
+## Safety behavior
 
-For maximum security, npm Trusted Publishing can replace the long-lived token later.
+- Preserves unrelated TOML settings, comments, BOM, ordering, and LF/CRLF line endings.
+- Rejects malformed, non-UTF-8, duplicate, or unsafe configuration before writing.
+- Rejects symlinks and Windows junctions in managed paths.
+- Uses scope-level locking, atomic transactions, rollback, and conflict-safe recovery.
+- Never overwrites post-interruption user changes.
+- Dry-run creates no files, directories, backups, locks, journals, or state.
+- Never modifies AGENTS.md, shell profiles, editor settings, hooks, MCP servers, telemetry, accounts, or environment variables.
 
-## Safety behavior
+## Compatibility
 
-- Refuses malformed or unsafe configuration before writing
-- Uses atomic file replacement and rolls back failed multi-file upgrades where possible
-- Stores a small package-owned state file and one backup only when an existing config is changed
-- Never modifies `AGENTS.md`, shell profiles, editor settings, hooks, MCP servers, telemetry, or environment variables
-- Dry-run creates no files, directories, backups, or temporary state
+Compatibility is tested on Node.js 18, 20, 22, and 24 across Windows, Linux, and macOS runners. The selected Codex account must have access to gpt-5.6-terra, gpt-5.6-luna, and gpt-5.6-sol.
 
-Restart Codex if newly installed agents or skills are not immediately visible.
+Restart Codex after installation so new agents and skills are discovered. Use `doctor` for missing, user-modified, unsafe-state, lock, or interrupted-transaction reports.
 
-Codex references: [Subagents](https://developers.openai.com/codex/subagents), [Build skills](https://developers.openai.com/codex/build-skills), and [Configuration reference](https://developers.openai.com/codex/config-reference).
+Security vulnerabilities should be reported privately according to [SECURITY.md](SECURITY.md). Maintainer setup and release steps are documented in [MAINTAINERS.md](MAINTAINERS.md).

package/SECURITY.md

@@ -0,0 +1,21 @@
+# Security Policy
+
+## Supported versions
+
+Only the latest stable release receives security fixes.
+
+## Reporting a vulnerability
+
+Do not report security vulnerabilities through a public Issue.
+
+Use GitHub's private security advisory feature for this repository and include:
+
+- affected version and operating system
+- selected project or global scope
+- minimal reproduction steps
+- files or paths affected
+- expected and observed behavior
+
+Do not include npm tokens, OpenAI credentials, private Codex configuration, or unrelated project source code.
+
+Reports involving path escape, unsafe uninstall, transaction recovery, release provenance, or package publication are treated as security-sensitive.

package/lib/manifest.js

@@ -0,0 +1,207 @@
+import { createRequire } from "node:module";
+
+const require = createRequire(import.meta.url);
+const packageJson = require("../package.json");
+
+export const VERSION = packageJson.version;
+
+// Explicit opt-in only. A normal install leaves the user's primary model unchanged.
+export const DEFAULTS = Object.freeze({
+  model: "gpt-5.6-terra",
+  model_reasoning_effort: "high"
+});
+
+const legacyLunaV12 = `name = "luna"
+description = "Low-risk helper for repeated edits, searches, formatting, extraction, counting, and summaries."
+model = "gpt-5.6-luna"
+model_reasoning_effort = "high"
+developer_instructions = """
+Handle only deterministic, low-risk work delegated by Terra.
+Follow the assigned pattern exactly and return a concise result.
+Escalate ambiguous, security-sensitive, or logic-heavy decisions to Terra.
+"""
+`;
+
+const legacySolWorkspaceWrite = `name = "sol"
+description = "High-capability specialist for security-sensitive or high-regression-risk work."
+model = "gpt-5.6-sol"
+model_reasoning_effort = "medium"
+sandbox_mode = "workspace-write"
+developer_instructions = """
+Review or implement only when explicitly delegated by Terra.
+For review-only tasks, report concrete findings without changing files.
+For implementation tasks, make focused changes, run relevant checks, and report the result to Terra.
+Focus on security, authentication, permissions, secrets, destructive actions, financial logic, SQL writes, concurrency, complex state, and regression risk.
+Do not expand the scope beyond the delegated task.
+"""
+`;
+
+const legacySolReadOnly = `name = "sol"
+description = "Read-only reviewer for security-sensitive or high-regression-risk logic."
+model = "gpt-5.6-sol"
+model_reasoning_effort = "medium"
+sandbox_mode = "read-only"
+developer_instructions = """
+Review only. Focus on security, authentication, permissions, secrets, destructive actions, financial logic, SQL writes, concurrency, complex state, and regression risk.
+Report concrete findings to Terra; do not apply fixes.
+"""
+`;
+
+const legacySkillWorkspaceWrite = `---
+name: model-router
+description: Route Codex work between Terra, Luna, and Sol with the fewest required agents.
+---
+
+Terra handles ordinary questions, coding, debugging, fixes, testing, and implementation. Never create a Terra subagent.
+Use Luna only for deterministic low-risk repeated edits, bulk patterns, read-heavy searches, formatting, counting, extraction, or summaries; prefer Luna when the same clear operation repeats at least three times.
+Use Sol for security, authentication, authorization, permissions, secrets, destructive actions, financial logic, SQL writes, concurrency, complex state changes, high-regression-risk logic, or an explicit review. Prefer review-only delegation first; when implementation or a confirmed fix is explicitly required, Sol may edit files in workspace-write mode and run relevant checks.
+Do not spawn a subagent for a simple question. Use the minimum number of agents and run Luna with Sol only when both independent tasks are required.
+`;
+
+const legacySkillReadOnly = `---
+name: model-router
+description: Route Codex work between Terra, Luna, and Sol with the fewest required agents.
+---
+
+Terra handles ordinary questions, coding, debugging, fixes, testing, and implementation. Never create a Terra subagent.
+Use Luna only for deterministic low-risk repeated edits, bulk patterns, read-heavy searches, formatting, counting, extraction, or summaries; prefer Luna when the same clear operation repeats at least three times.
+Use Sol only as a read-only reviewer for security, authentication, authorization, permissions, secrets, destructive actions, financial logic, SQL writes, concurrency, complex state changes, high-regression-risk logic, or an explicit review. Terra applies fixes.
+Do not spawn a subagent for a simple question. Use the minimum number of agents and run Luna with Sol only when both independent tasks are required.
+`;
+
+const terra = `name = "terra"
+description = "Investigates, plans, verifies, debugs, and replans nontrivial code changes."
+model = "gpt-5.6-terra"
+model_reasoning_effort = "high"
+sandbox_mode = "read-only"
+developer_instructions = """
+Own focused investigation, compact implementation-ready planning, verification, debugging, and replanning.
+Use the implementation-planning skill only for nontrivial or uncertain changes.
+Never invent repository facts; preserve valid work and revise only affected parts.
+Verify both plan conformance and whether the plan plus implementation satisfy the user's requirement.
+Use Sol only when focused investigation and one materially revised plan still leave the core logic unresolved.
+Return only the artifact required by the current stage.
+"""
+`;
+
+const luna = `name = "luna"
+description = "Implements clear, bounded work from an approved plan."
+model = "gpt-5.6-luna"
+model_reasoning_effort = "max"
+sandbox_mode = "workspace-write"
+developer_instructions = """
+Implement the current approved plan with the smallest coherent change.
+Preserve fixed behavior, contracts, scope, parameter flow, control flow, callers, and invariants.
+Use local choice only for equivalent implementation details.
+Return to Terra when the plan conflicts with current code, is stale, omits a required target or caller, or needs a new correctness-affecting decision.
+Report the plan version, changed files and symbols, deviations, logical checks, and remaining uncertainty.
+Do not self-approve.
+"""
+`;
+
+const sol = `name = "sol"
+description = "Last-resort advisor for core logic Terra cannot resolve."
+model = "gpt-5.6-sol"
+model_reasoning_effort = "medium"
+sandbox_mode = "read-only"
+developer_instructions = """
+Analyze only the unresolved logical conflict.
+Identify unsupported assumptions, the likely root cause, required invariants, viable correction directions, and remaining uncertainty.
+Do not perform routine planning, implementation, verification, or final review.
+Return findings to Terra; do not manage Luna.
+"""
+`;
+
+const skill = `---
+name: model-router
+description: Adaptively route code planning and implementation while preserving the selected primary model and existing agents.
+---
+
+Preserve repository rules and existing specialized agents. Explicit user instructions win.
+The selected primary model handles conversation, clarification, follow-ups, final replies, and trivial work.
+For code changes: ask the user when expected behavior is unclear; use Terra to investigate, plan, verify, debug, and replan; use Luna for clear bounded implementation; use Sol only when Terra still cannot resolve core logic after focused investigation and one materially revised plan, or when the user explicitly requests Sol.
+Use the implementation-planning skill for nontrivial or uncertain changes.
+Luna may choose equivalent local details only; approved behavior, contracts, scope, parameter flow, control flow, and invariants remain fixed.
+Terra verifies both plan conformance and requirement correctness. Preserve verified work and revise only affected parts.
+Stop after three cycles without new evidence or a changed decision. Use the fewest agents needed.
+Within one agent thread append concise deltas; a new thread receives the latest self-contained snapshot.
+`;
+
+const planning = `---
+name: implementation-planning
+description: Create or revise a compact implementation-ready plan for nontrivial code changes involving multiple symbols, contracts, parameters, callers, control flow, or uncertain targets.
+---
+
+Inspect only enough code to confirm correctness-critical facts. Mark information as CONFIRMED, PROPOSED, or UNKNOWN. Do not implement while an UNKNOWN can change behavior, targets, contracts, parameter flow, control flow, or compatibility.
+
+Produce one compact current snapshot using only applicable fields:
+
+- TASK, REQUIREMENT_VERSION, PLAN_VERSION
+- OBJECTIVE: observable result
+- TARGETS: exact files, symbols, and change type
+- SYMBOLS: exact new names and naming basis
+- CONTRACTS: current and proposed signatures, parameters, defaults, returns, and failure behavior
+- FLOW: source -> caller -> parameter -> transformation -> use -> destination
+- LOGIC: ordered steps and branches
+- CALLERS: affected callers and argument changes
+- INVARIANTS: behavior that must remain true
+- FIXED: decisions Luna cannot change
+- LOCAL_CHOICE: safe implementation freedom
+- RETURN_REQUIRED: conditions requiring Terra
+- DONE_WHEN: acceptance conditions
+
+Omit irrelevant fields and vague instructions. Preserve verified work, revise only affected sections, and identify superseded decisions. Create a new snapshot after three deltas or any material contract or logic change.
+
+Verification answers separately: did implementation match the plan, and did the plan plus implementation satisfy the request? Use PASS, IMPLEMENTATION_FIX, PLAN_REVISION, EVIDENCE_GAP, or REQUIREMENT_CLARIFICATION.
+`;
+
+export const TEMPLATES = Object.freeze({
+  terra: Object.freeze({ relative: ["agents", "terra.toml"], content: terra }),
+  luna: Object.freeze({ relative: ["agents", "luna.toml"], content: luna }),
+  sol: Object.freeze({ relative: ["agents", "sol.toml"], content: sol }),
+  skill: Object.freeze({ relative: ["model-router", "SKILL.md"], content: skill }),
+  planning: Object.freeze({ relative: ["implementation-planning", "SKILL.md"], content: planning })
+});
+
+export const MANAGED_FILE_NAMES = Object.freeze(["terra", "luna", "sol", "skill", "planning"]);
+export const AGENT_NAMES = Object.freeze(["terra", "luna", "sol"]);
+
+export const LEGACY_TEMPLATES = Object.freeze({
+  terra: Object.freeze([]),
+  luna: Object.freeze([legacyLunaV12]),
+  sol: Object.freeze([legacySolWorkspaceWrite, legacySolReadOnly]),
+  skill: Object.freeze([legacySkillWorkspaceWrite, legacySkillReadOnly]),
+  planning: Object.freeze([])
+});
+
+export const AGENT_EXPECTATIONS = Object.freeze({
+  terra: Object.freeze({
+    name: "terra",
+    model: "gpt-5.6-terra",
+    model_reasoning_effort: "high",
+    sandbox_mode: "read-only"
+  }),
+  luna: Object.freeze({
+    name: "luna",
+    model: "gpt-5.6-luna",
+    model_reasoning_effort: "max",
+    sandbox_mode: "workspace-write"
+  }),
+  sol: Object.freeze({
+    name: "sol",
+    model: "gpt-5.6-sol",
+    model_reasoning_effort: "medium",
+    sandbox_mode: "read-only"
+  })
+});
+
+export const SKILL_EXPECTATIONS = Object.freeze({
+  skill: Object.freeze({
+    name: "model-router",
+    required: Object.freeze(["primary model", "Terra", "Luna", "Sol", "three cycles"])
+  }),
+  planning: Object.freeze({
+    name: "implementation-planning",
+    required: Object.freeze(["CONFIRMED", "PROPOSED", "UNKNOWN", "FIXED", "LOCAL_CHOICE", "RETURN_REQUIRED", "PLAN_REVISION"])
+  })
+});