fix(agent): match muse-wonder models and scope muse rules to leaves

Author: TheGreatAxios

src/agent/model-family-policy.test.ts

@@ -90,17 +90,30 @@ describe("resolveModelFamilyPolicy", () => {
     }
   });
 
-  test("muse spark carries tool-discipline rules; other families do not", () => {
-    const muse = resolveModelFamilyPolicy({
-      providerName: "opencode-go/acme",
-      model: "muse-spark-1.3-contributor",
-    });
+  test("muse leaves carry tool-discipline rules; muse orchestrators and other families do not", () => {
+    for (const model of [
+      "muse-spark-1.3-contributor",
+      "muse-wonder-1.0",
+    ] as const) {
+      const leaf = resolveModelFamilyPolicy({
+        providerName: "meta-api",
+        model,
+        orchestrator: false,
+      });
+      const orchestrator = resolveModelFamilyPolicy({
+        providerName: "meta-api",
+        model,
+        orchestrator: true,
+      });
+      expect(leaf.family).toBe("muse");
+      expect(leaf.toolDisciplineRules?.length).toBeGreaterThan(0);
+      expect(orchestrator.family).toBe("muse");
+      expect(orchestrator.toolDisciplineRules).toBeUndefined();
+    }
     const base = resolveModelFamilyPolicy({
       providerName: "anthropic",
       model: "claude-sonnet-4",
     });
-    expect(muse.family).toBe("muse");
-    expect(muse.toolDisciplineRules?.length).toBeGreaterThan(0);
     expect(base.toolDisciplineRules).toBeUndefined();
   });
 

src/agent/model-family-policy.ts

@@ -38,7 +38,7 @@ export interface ModelFamilyPolicy {
    * not self-terminate a tool loop. Appended at the tail to keep the cached
    * prompt prefix intact.
    */
-  toolDisciplineRules?: string;
+  toolDisciplineRules?: string | undefined;
   /**
    * Provider-family residual appended once to the leaf system prompt
    * (tool-budget text for grok, XML task_guidance for claude, narrate
@@ -224,7 +224,13 @@ export function resolveModelFamilyPolicy(input: {
         ...KIMI_POLICY,
       };
     case "muse":
-      return { family, ...MUSE_POLICY };
+      return {
+        family,
+        ...MUSE_POLICY,
+        toolDisciplineRules: orchestrator
+          ? undefined
+          : MUSE_POLICY.toolDisciplineRules,
+      };
     case "claude":
       // Like grok's finish-bias, task_guidance only makes sense on leaf
       // workers — orchestrators get the permissive default.

src/provider/reasoning-effort.test.ts

@@ -127,27 +127,33 @@ describe("supportedEfforts", () => {
     expect(supportedEfforts("deepseek-v3")).toEqual(["low", "medium", "high"]);
   });
 
-  // Every catalog Muse Spark id reaches supportedEfforts unnormalized; two
-  // ids pin the family rule.
-  test.each(["muse-spark-1.3-contributor", "muse-spark-1.3-contributor-free"])(
-    "Muse Spark id %s supports minimal through high",
-    (model) => {
-      expect(supportedEfforts(model)).toEqual([
-        "minimal",
-        "low",
-        "medium",
-        "high",
-      ]);
-      expect(defaultEffortForModel(model)).toBe("low");
-    },
-  );
+  // Every catalog Muse id reaches supportedEfforts unnormalized; spark and
+  // wonder ids pin the family rule.
+  test.each([
+    "muse-spark-1.3-contributor",
+    "muse-spark-1.3-contributor-free",
+    "muse-wonder-1.0",
+  ])("Muse id %s supports minimal through high", (model) => {
+    expect(supportedEfforts(model)).toEqual([
+      "minimal",
+      "low",
+      "medium",
+      "high",
+    ]);
+    expect(defaultEffortForModel(model)).toBe("low");
+  });
 
-  test("a model merely containing muse-spark is not matched", () => {
+  test("a model merely containing muse- is not matched", () => {
     expect(supportedEfforts("not-muse-spark-1.3")).toEqual([
       "low",
       "medium",
       "high",
     ]);
+    expect(supportedEfforts("not-muse-wonder-1.0")).toEqual([
+      "low",
+      "medium",
+      "high",
+    ]);
   });
 });
 
@@ -175,11 +181,13 @@ describe("validateEffort", () => {
     expect(validateEffort("grok-4.5", "xhigh").ok).toBe(false);
   });
 
-  test("accepts minimal on Muse Spark and rejects none", () => {
-    expect(validateEffort("muse-spark-1.3-contributor", "minimal")).toEqual({
-      ok: true,
-    });
-    expect(validateEffort("muse-spark-1.3-contributor", "none").ok).toBe(false);
+  test("accepts minimal on Muse models and rejects none", () => {
+    for (const model of ["muse-spark-1.3-contributor", "muse-wonder-1.0"]) {
+      expect(validateEffort(model, "minimal")).toEqual({
+        ok: true,
+      });
+      expect(validateEffort(model, "none").ok).toBe(false);
+    }
   });
 
   test("rejects medium on glm-5.3 family", () => {

src/provider/reasoning-effort.ts

@@ -88,7 +88,7 @@ const MUSE_SPARK_EFFORTS: readonly ReasoningEffort[] = DEFAULT_EFFORTS;
 // and nothing normalizes the model string first. Mirrors the grok/kimi checks
 // in src/subagent/provider-family.ts.
 function isMuseSparkModel(model: string): boolean {
-  return /^muse-spark/i.test(model.trim());
+  return /^muse-/i.test(model.trim());
 }
 
 // grok-4.6/4.7 accept xhigh (CODEX_EFFORTS); grok-4.5 and composer stay on

src/subagent/provider-family.test.ts

@@ -6,6 +6,7 @@ import {
   isDeepSeekLeafProvider,
   isGptProvider,
   isKimiLeafProvider,
+  isMuseSparkLeafProvider,
   isXaiGrokLeafProvider,
   shouldApplyGrokAntiThrash,
 } from "./provider-family.js";
@@ -67,13 +68,33 @@ describe("isKimiLeafProvider", () => {
   );
 });
 
+describe("isMuseSparkLeafProvider", () => {
+  test.each<[ProviderRow, boolean]>([
+    [
+      { providerName: "opencode-go", model: "muse-spark-1.3-contributor" },
+      true,
+    ],
+    [{ providerName: "meta-api", model: "muse-wonder-1.0" }, true],
+    [{ providerName: "meta/default", model: "MUSE-WONDER-1.0" }, true],
+    [{ providerName: "meta-api", model: "not-muse-wonder-1.0" }, false],
+    [{ providerName: "meta-api" }, false],
+  ])("matches %j -> %s", (row, expected) => {
+    expect(isMuseSparkLeafProvider(row)).toBe(expected);
+  });
+});
+
 describe("detectModelFamily", () => {
   test.each<[ProviderRow, ReturnType<typeof detectModelFamily>]>([
     [{ providerName: "xai/default", model: "grok-4.5" }, "grok"],
     [{ providerName: "xai/default", model: "grok-4.6" }, "grok"],
     [{ providerName: "xai/default", model: "grok-4.7" }, "grok"],
     [{ providerName: "moonshot", model: "kimi-k2" }, "kimi"],
     [{ providerName: "opencode-go", model: "kimi-k3" }, "kimi"],
+    [
+      { providerName: "opencode-go", model: "muse-spark-1.3-contributor" },
+      "muse",
+    ],
+    [{ providerName: "meta-api", model: "muse-wonder-1.0" }, "muse"],
     [{ providerName: "anthropic", model: "claude-sonnet-4" }, "claude"],
     [{ providerName: "openai-compat", model: "claude-opus-4-6" }, "claude"],
     [{ providerName: "openai", model: "gpt-5.6" }, "gpt"],

src/subagent/provider-family.ts

@@ -43,12 +43,12 @@ export function isKimiLeafProvider(input: {
   return false;
 }
 
-/** True when the provider/model is the OpenCode Go Muse Spark family. */
+/** True when the provider/model is the Meta Muse family (muse-spark, muse-wonder). */
 export function isMuseSparkLeafProvider(input: {
   providerName: string;
   model?: string;
 }): boolean {
-  return input.model !== undefined && /^muse-spark/i.test(input.model.trim());
+  return input.model !== undefined && /^muse-/i.test(input.model.trim());
 }
 
 /** True when the provider/model is Anthropic's Claude family. */