Give Muse Spark its own reasoning effort ladder

muse-spark-1.3-contributor fell through to UNKNOWN_MODEL_EFFORTS, so
`minimal` was unreachable from the picker, the flag, and agent profiles.

Measured against the Go Responses endpoint, reasoning tokens are ~95% of
every completion and scale 6x from minimal to medium with no change in
pass rate on two objectively graded tasks. The gateway accepts minimal
and rejects `none` with HTTP 400, so the rung set is minimal/low/medium/
high and the family default is `low`.

Also pins SOURCE_MAX_TOKENS above the measured truncation floor:
reasoning consumes max_output_tokens before any answer text, so a 512
cap at medium effort returns 3 tokens of answer, not a shorter answer.

CL-7867

Author: TheGreatAxios

src/config.test.ts

@@ -1460,6 +1460,15 @@ describe("buildOpenAISource", () => {
     expect(source.baseURL).toBe("https://fp/v1");
   });
 
+  test("stays above the reasoning truncation floor", () => {
+    // Reasoning tokens consume max_output_tokens before any answer text is
+    // emitted. Measured on muse-spark-1.3-contributor, a 512-token cap at
+    // medium effort spent 397 tokens reasoning and returned 3 tokens of
+    // answer; 1024 was the lowest cap that answered on every rung. 4096 is
+    // the floor we will not drop below. See CL-7867.
+    expect(SOURCE_MAX_TOKENS).toBeGreaterThanOrEqual(4096);
+  });
+
   test("omits reasoning_effort when effort is absent", () => {
     const source = buildOpenAISource({
       id: "fp",

src/provider/reasoning-effort.test.ts

@@ -163,6 +163,28 @@ describe("supportedEfforts", () => {
     expect(supportedEfforts("glm-5.3")).toEqual(["low", "high", "max"]);
     expect(supportedEfforts("glm-5.3-flash")).toEqual(["low", "high", "max"]);
   });
+
+  test("Muse Spark supports minimal through high", () => {
+    expect(supportedEfforts("muse-spark-1.3-contributor")).toEqual([
+      "minimal",
+      "low",
+      "medium",
+      "high",
+    ]);
+    expect(supportedEfforts("muse-spark-1.2-contributor")).toEqual([
+      "minimal",
+      "low",
+      "medium",
+      "high",
+    ]);
+  });
+
+  test("Muse Spark never offers none", () => {
+    // The Go gateway answers HTTP 400 on reasoning.effort: "none".
+    expect(supportedEfforts("muse-spark-1.3-contributor")).not.toContain(
+      "none",
+    );
+  });
 });
 
 describe("validateEffort", () => {
@@ -189,6 +211,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("rejects medium on glm-5.3 family", () => {
     expect(validateEffort("glm-5.3", "medium").ok).toBe(false);
     expect(validateEffort("glm-5.3-flash", "medium").ok).toBe(false);
@@ -472,6 +501,11 @@ describe("defaultEffortForModel", () => {
     expect(defaultEffortForModel("glm-5.3-flash")).toBe("max");
   });
 
+  test("Muse Spark defaults to low", () => {
+    expect(defaultEffortForModel("muse-spark-1.3-contributor")).toBe("low");
+    expect(defaultEffortForModel("muse-spark-1.2-contributor")).toBe("low");
+  });
+
   test("gpt-5 and o-series default to medium", () => {
     expect(defaultEffortForModel("gpt-5")).toBe("medium");
     expect(defaultEffortForModel("o1")).toBe("medium");

src/provider/reasoning-effort.ts

@@ -61,6 +61,20 @@ const UNKNOWN_MODEL_EFFORTS: readonly ReasoningEffort[] = [
   "high",
 ];
 
+// Muse Spark (OpenCode Go, Responses protocol) accepts minimal through high.
+// Not `none` — the Go gateway rejects it with HTTP 400 on `reasoning.effort`.
+// Measured against https://opencode.ai/zen/go/v1/responses; see CL-7867.
+const MUSE_SPARK_EFFORTS: readonly ReasoningEffort[] = [
+  "minimal",
+  "low",
+  "medium",
+  "high",
+];
+const MUSE_SPARK_MODELS: readonly string[] = [
+  "muse-spark-1.3-contributor",
+  "muse-spark-1.2-contributor",
+];
+
 // grok-4.6 accepts xhigh; grok-4.5 and composer stay on the unknown-model subset.
 const GROK_46_EFFORTS: readonly ReasoningEffort[] = [
   "low",
@@ -143,6 +157,9 @@ export function supportedEfforts(
   if (GLM_53_MODELS.includes(model)) {
     return [...GLM_53_EFFORTS];
   }
+  if (MUSE_SPARK_MODELS.includes(model)) {
+    return [...MUSE_SPARK_EFFORTS];
+  }
   return [...UNKNOWN_MODEL_EFFORTS];
 }
 
@@ -196,7 +213,7 @@ export function cycleReasoningEffort(
  * (`defaultEffortForDirector`): this is what the prompt shows and what Shift+Tab
  * advances from when the operator has not picked a level.
  *
- * Family table: grok* → high; glm-5.3* → max; Codex → medium; gpt-5.1 chat (`none` on the
+ * Family table: grok* → high; glm-5.3* → max; muse-spark* → low; Codex → medium; gpt-5.1 chat (`none` on the
  * ladder, not Codex) → none; gpt-5/gpt-6/o1/o3/o4 → medium. Unknown models with a
  * conservative rung set stay undefined so we do not invent a family default.
  */
@@ -210,6 +227,7 @@ export function defaultEffortForModel(
     supported.includes(desired) ? desired : undefined;
   if (model.startsWith("grok")) return pick("high");
   if (GLM_53_MODELS.includes(model)) return pick("max");
+  if (MUSE_SPARK_MODELS.includes(model)) return pick("low");
   if (!isCodex && supported.includes("none")) return "none";
   if (isCodex || isKnownOpenAIReasoningModel(model)) return pick("medium");
   return undefined;