sortie-dogs 0.2.7 → 0.2.8

package/README.md

@@ -60,8 +60,9 @@ to the `plugin` array of the OpenCode configuration the agents run under —
 Restart OpenCode afterwards. A `plugin` entry must name the package, not a
 subpath: `sortie-dogs/plugin` is an import specifier, not a plugin specifier.
 
-`dog-coordinator` and `dog-scout` default to `openai/gpt-5.6-luna`. To use a
-different model for both roles, save this as `.opencode/sortie-dogs.json`:
+`dog-coordinator` keeps whichever model you select for the session. `dog-scout`
+defaults to `openai/gpt-5.6-luna`. To pin either role to another model, save this
+as `.opencode/sortie-dogs.json`:
 
 ```json
 {
@@ -263,13 +264,17 @@ 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
+`dog-coordinator` has no built-in route. It is the one agent you drive directly
+and pick a model for in the session, so it keeps the model you selected; a
+shipped default there would silently revert your choice instead of filling an
+absent one. Declare `modelRouting` for `dog-coordinator` if you do want a fixed
+coordinator model.
+
+`dog-scout` defaults to `openai/gpt-5.6-luna` 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.
+where the curve gives the most per unit of cost. Nobody selects a model for a
+session the loop spawns, which is why delegated roles carry defaults and the
+coordinator does not. Project-local routing can override this default.
 
 The `implementation`, `remediation`, `blocker-resolution`, and `dog-worker`
 roles always use the dedicated worker target, `openai/gpt-5.6-luna` with the

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

@@ -39,15 +39,17 @@ 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";
 /**
- * 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.
+ * The coordinator has no built-in route on purpose. It is the one agent the user drives directly and
+ * picks a model for in the session, so a shipped default here does not choose between models for an
+ * undecided user: it silently discards a choice the user already made and cannot see being reverted.
+ * Delegated roles are the opposite, because nobody selects a model for a session the loop spawns.
+ * A host that does want a fixed coordinator model still declares one through modelRouting.
+ *
+ * Evidence gathering is retrieval rather than reasoning, so the scout sits one effort tier below the
+ * worker, where the published cost curve returns the most per unit of cost.
  */
-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[];

package/dist/plugin/model-routing.js

@@ -53,15 +53,17 @@ 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";
 /**
- * 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.
+ * The coordinator has no built-in route on purpose. It is the one agent the user drives directly and
+ * picks a model for in the session, so a shipped default here does not choose between models for an
+ * undecided user: it silently discards a choice the user already made and cannot see being reverted.
+ * Delegated roles are the opposite, because nobody selects a model for a session the loop spawns.
+ * A host that does want a fixed coordinator model still declares one through modelRouting.
+ *
+ * Evidence gathering is retrieval rather than reasoning, so the scout sits one effort tier below the
+ * worker, where the published cost curve returns the most per unit of cost.
  */
-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));
@@ -137,11 +139,8 @@ export const BUILT_IN_MODEL_CATALOG = Object.freeze({
     global: Object.freeze([
         Object.freeze({
             model: DEDICATED_WORKER_MODEL,
-            variants: Object.freeze([
-                DEDICATED_WORKER_VARIANT,
-                RECOMMENDED_COORDINATOR_VARIANT,
-                RECOMMENDED_SCOUT_VARIANT,
-            ].filter((variant, index, all) => all.indexOf(variant) === index)),
+            variants: Object.freeze([DEDICATED_WORKER_VARIANT, RECOMMENDED_SCOUT_VARIANT]
+                .filter((variant, index, all) => all.indexOf(variant) === index)),
         }),
         Object.freeze({
             model: ESCALATION_WORKER_MODEL,

package/package.json

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