sortie-dogs 0.2.6 → 0.2.7

package/README.md

@@ -160,7 +160,7 @@ Optional settings in `.opencode/sortie-dogs.json`:
 - `readOnlyTools` adds host-specific tool names that never change files, such as
   MCP tools. Unknown tools are denied for a bound session by default.
 - `dedicatedWorkerModel` selects the single model every worker role resolves to.
-  It defaults to `openai/gpt-5.6-sol` with variant `medium`; declare your own when
+  It defaults to `openai/gpt-5.6-luna` with variant `max`; declare your own when
   that model is unavailable or when you want a different worker effort. Worker
   roles always resolve to this one target and cannot be routed per role.
 - `continuation` bounds the batch loop. After a terminal unit and its checkpoint,
@@ -180,7 +180,7 @@ Optional settings in `.opencode/sortie-dogs.json`:
   exactly three bounded scouts before implementation begins.
 - **Writes stay inside the assignment.** Exact source or operation manifests
   gate edits and handoffs.
-- **One accountable implementation path.** A dedicated Sol worker handles
+- **One accountable implementation path.** One dedicated worker handles
   implementation, remediation, and blocker resolution.
 - **Evidence before completion.** Canonical validation, risk-based review, and
   terminal evidence gate coordinator-owned completion and commits.
@@ -207,8 +207,8 @@ dog-coordinator: completion evidence accepted
    criteria, a write manifest, and validation requirements.
 2. **Exactly three scouts** — bounded, read-only investigation collects
    complementary evidence without expanding the write scope.
-3. **Dedicated worker** — the Sol worker implements only the approved manifest
-   and also owns scoped remediation or blocker resolution.
+3. **Dedicated worker** — the dedicated worker implements only the approved
+   manifest and also owns scoped remediation or blocker resolution.
 4. **Canonical validation** — the declared test or build command must produce
    acceptable evidence.
 5. **Risk-based review** — high-risk candidates receive independent review;
@@ -258,19 +258,26 @@ untouched.
 
 ## Model routing
 
-`dog-coordinator` and `dog-scout` default to `openai/gpt-5.6-luna` with the
-`xhigh` variant. This is the recommended balance: bounded prompts, concise
-scout evidence, and fewer unnecessary context or tool turns can reduce token
-use while preserving quality. Project-local routing can override either
-default.
+Every default route is one model at a different reasoning effort, because
+published cost curves put a cheap model at high effort above an expensive model
+at mid effort on both solve rate and price. Sortie-dogs therefore buys effort,
+not model tiers, wherever the work allows it.
+
+`dog-coordinator` defaults to `openai/gpt-5.6-luna` with the `max` variant. The
+coordinator produces dispatches rather than code, and one malformed dispatch
+discards an entire worker session, so top effort here costs less than the work it
+protects. `dog-scout` defaults to the same model with the `high` variant, since
+gathering bounded evidence is retrieval rather than reasoning and that tier is
+where the curve gives the most per unit of cost. Project-local routing can
+override either default.
 
 The `implementation`, `remediation`, `blocker-resolution`, and `dog-worker`
-roles always use the dedicated worker target, `openai/gpt-5.6-sol` with the
-`medium` variant. Worker effort is deliberately below review effort: source
-review is mandatory for risky candidates and returns findings the worker must
-remediate, so the loop already re-runs weak implementation work and top-of-range
-first-attempt effort mostly buys accuracy the reviewer supplies anyway. Raise
-`dedicatedWorkerModel` when you would rather pay for it up front. `modelRouting`
+roles always use the dedicated worker target, `openai/gpt-5.6-luna` with the
+`max` variant. Worker effort stays at the top of that model's range while review
+effort stays above it on a stronger model, which is what mandatory source review
+is for. Declare `dedicatedWorkerModel` as `openai/gpt-5.6-sol` when you would
+rather pay for the stronger worker model up front; that target stays in the
+built-in catalog for exactly this reason. `modelRouting`
 cannot replace those routes, and only `dedicatedWorkerModel` moves them. For other explicitly
 routed roles, resolution is deterministic: Sortie-dogs tries the preferred
 target, then ordered fallbacks. Roles without either a built-in default or an
@@ -280,7 +287,9 @@ explicit route keep OpenCode's already selected model.
 review and strategy lose their value when they run on the model that produced
 the candidate. Both default to `anthropic/claude-opus-5` when the catalog
 declares it, and otherwise fall back to `openai/gpt-5.6-sol` with the `xhigh`
-variant, one effort step above the worker target. A host that redeclares
+variant. That fallback stays on the stronger model rather than matching the
+worker target, because review has to be able to reject work the worker just
+produced. A host that redeclares
 `dedicatedWorkerModel` keeps that target as its first fallback, since such a
 host may not serve the shipped model at all. Nothing here requires a particular
 vendor: both roles stay fully configurable, so declare whichever model you can
@@ -290,10 +299,10 @@ actually serve.
 {
   "modelRouting": {
     "dog-coordinator": {
-      "preferred": { "model": "openai/gpt-5.6-luna", "variant": "xhigh" }
+      "preferred": { "model": "openai/gpt-5.6-luna", "variant": "max" }
     },
     "dog-scout": {
-      "preferred": { "model": "openai/gpt-5.6-luna", "variant": "xhigh" }
+      "preferred": { "model": "openai/gpt-5.6-luna", "variant": "high" }
     },
     "dog-reviewer": {
       "preferred": { "model": "anthropic/claude-opus-5" },
@@ -306,7 +315,7 @@ actually serve.
   "modelCatalog": {
     "project": [
       { "model": "openai/gpt-5.6-sol", "variants": ["medium", "xhigh"] },
-      { "model": "openai/gpt-5.6-luna", "variants": ["xhigh"] },
+      { "model": "openai/gpt-5.6-luna", "variants": ["max", "high"] },
       { "model": "anthropic/claude-opus-5" }
     ]
   }

package/dist/plugin/model-routing.d.ts

@@ -7,28 +7,50 @@ export interface RoleModelRoute {
     readonly fallback?: readonly ModelTarget[];
 }
 export type ModelRoutingConfig = Readonly<Record<string, RoleModelRoute>>;
-export declare const DEDICATED_SOL_MODEL = "openai/gpt-5.6-sol";
 /**
- * Worker reasoning effort is deliberately below the review effort. Source review is mandatory and
- * returns findings the worker must remediate, so the loop already re-runs weak implementation work;
- * paying top-of-range effort on the first attempt buys accuracy the reviewer would otherwise supply.
+ * The published DeepSWE cost curve settles the worker target: the cheap model at top reasoning effort
+ * solves more than the expensive model at mid effort while costing a fraction of it, so paying for the
+ * expensive model by default bought a lower solve rate. Worker effort therefore sits at the top of the
+ * cheap model's range, and review effort stays above it on a stronger model, which is what the
+ * mandatory source review is for.
  */
-export declare const DEDICATED_SOL_VARIANT = "medium";
-export declare const DEDICATED_SOL_ROLES: readonly ["implementation", "remediation", "blocker-resolution", "sol-worker-mk2a2", "dog-worker"];
+export declare const DEDICATED_WORKER_MODEL = "openai/gpt-5.6-luna";
+export declare const DEDICATED_WORKER_VARIANT = "max";
+/**
+ * The stronger, far more expensive worker target a host may still select deliberately. It is no longer
+ * a default route: it stays declared so an explicit dedicatedWorkerModel resolves against the catalog
+ * without extra host configuration.
+ */
+export declare const ESCALATION_WORKER_MODEL = "openai/gpt-5.6-sol";
+export declare const ESCALATION_WORKER_VARIANT = "medium";
+export declare const DEDICATED_WORKER_ROLES: readonly ["implementation", "remediation", "blocker-resolution", "sol-worker-mk2a2", "dog-worker"];
 /** Ordered last-resort targets used only when the host proves a policy target unavailable. */
 export declare const DEFAULT_FREE_TIER_FALLBACK_MODELS: readonly string[];
 /** The dedicated worker target this build ships with when a host declares no target of its own. */
 export declare const DEFAULT_DEDICATED_WORKER_TARGET: ModelTarget;
+/** The declared escalation target for a host that chooses to pay for the stronger worker model. */
+export declare const ESCALATION_WORKER_TARGET: ModelTarget;
 /**
  * Fixed worker routes for one dedicated target. Which target is dedicated is a host decision, but
  * every worker role resolves to that single target and never to a fallback.
  */
 export declare function dedicatedWorkerRouting(target?: ModelTarget): ModelRoutingConfig;
-export declare const DEDICATED_SOL_ROUTING: ModelRoutingConfig;
+export declare const DEDICATED_WORKER_ROUTING: ModelRoutingConfig;
 export declare const FIXED_MODEL_ROUTING: ModelRoutingConfig;
 export declare const RECOMMENDED_LUNA_MODEL = "openai/gpt-5.6-luna";
-export declare const RECOMMENDED_LUNA_VARIANT = "xhigh";
-export declare const RECOMMENDED_LUNA_ROLES: readonly ["dog-coordinator", "dog-scout"];
+/**
+ * Dispatch quality, not code output, is what the coordinator spends effort on, and one malformed
+ * dispatch discards an entire worker session, so the coordinator runs at the top of the cheap model's
+ * range where that whole session costs less than the work it protects. Evidence gathering is retrieval
+ * rather than reasoning, so the scout sits one tier lower where the cost curve is steepest per point.
+ */
+export declare const RECOMMENDED_COORDINATOR_VARIANT = "max";
+export declare const RECOMMENDED_SCOUT_VARIANT = "high";
+export declare const RECOMMENDED_LUNA_ROLE_VARIANTS: Readonly<{
+    readonly "dog-coordinator": "max";
+    readonly "dog-scout": "high";
+}>;
+export declare const RECOMMENDED_LUNA_ROLES: readonly string[];
 /** Configurable MkII defaults. Project-local and global configuration may override these routes. */
 export declare const RECOMMENDED_LUNA_ROUTING: ModelRoutingConfig;
 /**
@@ -39,8 +61,12 @@ export declare const RECOMMENDED_LUNA_ROUTING: ModelRoutingConfig;
 export declare const RECOMMENDED_CONSULTATION_MODEL = "anthropic/claude-opus-5";
 export declare const RECOMMENDED_CONSULTATION_ROLES: readonly string[];
 /** Review and advice carry the reasoning effort the worker target intentionally does not spend. */
-export declare const CONSULTATION_SOL_VARIANT = "xhigh";
-/** The shipped consultation fallback; higher effort than the worker target on the same model. */
+export declare const CONSULTATION_FALLBACK_VARIANT = "xhigh";
+/**
+ * The shipped consultation fallback. Review has to be able to reject work the worker just produced, so
+ * it stays on the stronger model even though the worker no longer defaults to it; a fallback equal to
+ * the worker target would review that work with exactly the capability that produced it.
+ */
 export declare const DEFAULT_CONSULTATION_FALLBACK_TARGET: ModelTarget;
 /**
  * Consultation prefers the strongest declared reasoning model. A host that relocated the dedicated
@@ -55,7 +81,7 @@ export declare const RECOMMENDED_CONSULTATION_ROUTING: ModelRoutingConfig;
 /** Every configurable role route this build recommends before host configuration is applied. */
 export declare function recommendedRoleRouting(fallbackTarget?: ModelTarget): ModelRoutingConfig;
 export declare const RECOMMENDED_ROLE_ROUTING: ModelRoutingConfig;
-export declare function isDedicatedSolRole(role: string): boolean;
+export declare function isDedicatedWorkerRole(role: string): boolean;
 export declare function isFixedModelRole(role: string): boolean;
 export interface CatalogModel {
     readonly model: string;

package/dist/plugin/model-routing.js

@@ -1,12 +1,21 @@
 import { CONSULTATION_ROLE_POLICY } from "../core/consultation.js";
-export const DEDICATED_SOL_MODEL = "openai/gpt-5.6-sol";
 /**
- * Worker reasoning effort is deliberately below the review effort. Source review is mandatory and
- * returns findings the worker must remediate, so the loop already re-runs weak implementation work;
- * paying top-of-range effort on the first attempt buys accuracy the reviewer would otherwise supply.
+ * The published DeepSWE cost curve settles the worker target: the cheap model at top reasoning effort
+ * solves more than the expensive model at mid effort while costing a fraction of it, so paying for the
+ * expensive model by default bought a lower solve rate. Worker effort therefore sits at the top of the
+ * cheap model's range, and review effort stays above it on a stronger model, which is what the
+ * mandatory source review is for.
  */
-export const DEDICATED_SOL_VARIANT = "medium";
-export const DEDICATED_SOL_ROLES = [
+export const DEDICATED_WORKER_MODEL = "openai/gpt-5.6-luna";
+export const DEDICATED_WORKER_VARIANT = "max";
+/**
+ * The stronger, far more expensive worker target a host may still select deliberately. It is no longer
+ * a default route: it stays declared so an explicit dedicatedWorkerModel resolves against the catalog
+ * without extra host configuration.
+ */
+export const ESCALATION_WORKER_MODEL = "openai/gpt-5.6-sol";
+export const ESCALATION_WORKER_VARIANT = "medium";
+export const DEDICATED_WORKER_ROLES = [
     "implementation",
     "remediation",
     "blocker-resolution",
@@ -17,34 +26,50 @@ export const DEDICATED_SOL_ROLES = [
 export const DEFAULT_FREE_TIER_FALLBACK_MODELS = Object.freeze([
     "opencode/deepseek-v4-flash-free",
 ]);
-const dedicatedSolRoleSet = new Set(DEDICATED_SOL_ROLES);
+const dedicatedWorkerRoleSet = new Set(DEDICATED_WORKER_ROLES);
 /** The dedicated worker target this build ships with when a host declares no target of its own. */
 export const DEFAULT_DEDICATED_WORKER_TARGET = Object.freeze({
-    model: DEDICATED_SOL_MODEL,
-    variant: DEDICATED_SOL_VARIANT,
+    model: DEDICATED_WORKER_MODEL,
+    variant: DEDICATED_WORKER_VARIANT,
+});
+/** The declared escalation target for a host that chooses to pay for the stronger worker model. */
+export const ESCALATION_WORKER_TARGET = Object.freeze({
+    model: ESCALATION_WORKER_MODEL,
+    variant: ESCALATION_WORKER_VARIANT,
 });
 /**
  * Fixed worker routes for one dedicated target. Which target is dedicated is a host decision, but
  * every worker role resolves to that single target and never to a fallback.
  */
 export function dedicatedWorkerRouting(target = DEFAULT_DEDICATED_WORKER_TARGET) {
-    return Object.freeze(Object.fromEntries(DEDICATED_SOL_ROLES.map((role) => [role, Object.freeze({
+    return Object.freeze(Object.fromEntries(DEDICATED_WORKER_ROLES.map((role) => [role, Object.freeze({
             preferred: Object.freeze(target.variant === undefined
                 ? { model: target.model }
                 : { model: target.model, variant: target.variant }),
         })])));
 }
-export const DEDICATED_SOL_ROUTING = dedicatedWorkerRouting();
-export const FIXED_MODEL_ROUTING = DEDICATED_SOL_ROUTING;
+export const DEDICATED_WORKER_ROUTING = dedicatedWorkerRouting();
+export const FIXED_MODEL_ROUTING = DEDICATED_WORKER_ROUTING;
 const fixedModelRoleSet = new Set(Object.keys(FIXED_MODEL_ROUTING));
 export const RECOMMENDED_LUNA_MODEL = "openai/gpt-5.6-luna";
-export const RECOMMENDED_LUNA_VARIANT = "xhigh";
-export const RECOMMENDED_LUNA_ROLES = ["dog-coordinator", "dog-scout"];
+/**
+ * Dispatch quality, not code output, is what the coordinator spends effort on, and one malformed
+ * dispatch discards an entire worker session, so the coordinator runs at the top of the cheap model's
+ * range where that whole session costs less than the work it protects. Evidence gathering is retrieval
+ * rather than reasoning, so the scout sits one tier lower where the cost curve is steepest per point.
+ */
+export const RECOMMENDED_COORDINATOR_VARIANT = "max";
+export const RECOMMENDED_SCOUT_VARIANT = "high";
+export const RECOMMENDED_LUNA_ROLE_VARIANTS = Object.freeze({
+    "dog-coordinator": RECOMMENDED_COORDINATOR_VARIANT,
+    "dog-scout": RECOMMENDED_SCOUT_VARIANT,
+});
+export const RECOMMENDED_LUNA_ROLES = Object.freeze(Object.keys(RECOMMENDED_LUNA_ROLE_VARIANTS));
 /** Configurable MkII defaults. Project-local and global configuration may override these routes. */
-export const RECOMMENDED_LUNA_ROUTING = Object.freeze(Object.fromEntries(RECOMMENDED_LUNA_ROLES.map((role) => [role, Object.freeze({
+export const RECOMMENDED_LUNA_ROUTING = Object.freeze(Object.fromEntries(Object.entries(RECOMMENDED_LUNA_ROLE_VARIANTS).map(([role, variant]) => [role, Object.freeze({
         preferred: Object.freeze({
             model: RECOMMENDED_LUNA_MODEL,
-            variant: RECOMMENDED_LUNA_VARIANT,
+            variant,
         }),
     })])));
 /**
@@ -55,11 +80,15 @@ export const RECOMMENDED_LUNA_ROUTING = Object.freeze(Object.fromEntries(RECOMME
 export const RECOMMENDED_CONSULTATION_MODEL = "anthropic/claude-opus-5";
 export const RECOMMENDED_CONSULTATION_ROLES = Object.freeze(Object.values(CONSULTATION_ROLE_POLICY));
 /** Review and advice carry the reasoning effort the worker target intentionally does not spend. */
-export const CONSULTATION_SOL_VARIANT = "xhigh";
-/** The shipped consultation fallback; higher effort than the worker target on the same model. */
+export const CONSULTATION_FALLBACK_VARIANT = "xhigh";
+/**
+ * The shipped consultation fallback. Review has to be able to reject work the worker just produced, so
+ * it stays on the stronger model even though the worker no longer defaults to it; a fallback equal to
+ * the worker target would review that work with exactly the capability that produced it.
+ */
 export const DEFAULT_CONSULTATION_FALLBACK_TARGET = Object.freeze({
-    model: DEDICATED_SOL_MODEL,
-    variant: CONSULTATION_SOL_VARIANT,
+    model: ESCALATION_WORKER_MODEL,
+    variant: CONSULTATION_FALLBACK_VARIANT,
 });
 function frozenTarget(target) {
     return Object.freeze(target.variant === undefined
@@ -97,8 +126,8 @@ export function recommendedRoleRouting(fallbackTarget = DEFAULT_DEDICATED_WORKER
     });
 }
 export const RECOMMENDED_ROLE_ROUTING = recommendedRoleRouting();
-export function isDedicatedSolRole(role) {
-    return dedicatedSolRoleSet.has(role);
+export function isDedicatedWorkerRole(role) {
+    return dedicatedWorkerRoleSet.has(role);
 }
 export function isFixedModelRole(role) {
     return fixedModelRoleSet.has(role);
@@ -107,12 +136,16 @@ export function isFixedModelRole(role) {
 export const BUILT_IN_MODEL_CATALOG = Object.freeze({
     global: Object.freeze([
         Object.freeze({
-            model: DEDICATED_SOL_MODEL,
-            variants: Object.freeze([DEDICATED_SOL_VARIANT, CONSULTATION_SOL_VARIANT]),
+            model: DEDICATED_WORKER_MODEL,
+            variants: Object.freeze([
+                DEDICATED_WORKER_VARIANT,
+                RECOMMENDED_COORDINATOR_VARIANT,
+                RECOMMENDED_SCOUT_VARIANT,
+            ].filter((variant, index, all) => all.indexOf(variant) === index)),
         }),
         Object.freeze({
-            model: RECOMMENDED_LUNA_MODEL,
-            variants: Object.freeze([RECOMMENDED_LUNA_VARIANT]),
+            model: ESCALATION_WORKER_MODEL,
+            variants: Object.freeze([ESCALATION_WORKER_VARIANT, CONSULTATION_FALLBACK_VARIANT]),
         }),
     ]),
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sortie-dogs",
-  "version": "0.2.6",
+  "version": "0.2.7",
   "description": "Bounded, validated orchestration loop plugin for OpenCode",
   "keywords": [
     "opencode",