feat(director): give Muse Spark tool-discipline rules

At medium reasoning effort the model does not reliably stop a tool loop:
on a two-file fixture with a bounded fix it re-read files it had already
read and ran out an 8-turn ceiling without finishing. The same run with
three rules appended finished in 3 turns on 4.3x fewer input tokens.

The rules ride at the tail of the system prompt, which is prefix-safe —
tail appends hold a 99.1% cache hit while a head edit drops it to 9%.

Adds a `muse` model family and pins the Responses quirks: the model
batches independent tool calls on its own, and sending
parallel_tool_calls: false would collapse that to one call per turn.

CL-7869

Author: TheGreatAxios

src/agent/director.ts

@@ -499,6 +499,13 @@ class ChatDirectorImpl extends DefaultDirector {
     this.modelFamilyPolicy =
       options.modelFamilyPolicy ??
       resolveModelFamilyPolicy({ providerName: "" });
+    // Family tool-discipline rules go at the tail of the system prompt.
+    // Appending there is prefix-safe: measured on OpenCode Go Responses, tail
+    // appends hold a 99.1% cache hit while an edit at the head drops it to 9%.
+    const rules = this.modelFamilyPolicy.toolDisciplineRules;
+    if (rules !== undefined && rules.length > 0) {
+      this._systemPrompt = `${systemPrompt}\n\n${rules}`;
+    }
     this.retryPolicy = options.retryPolicy ?? createCorbitsRetryPolicy();
     this.getLiveFleetCount = options.getLiveFleetCount;
   }

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

@@ -52,4 +52,19 @@ describe("resolveModelFamilyPolicy", () => {
     expect(kimi.toolOnlyTurnNudgeAt).toBe(base.toolOnlyTurnNudgeAt);
     expect(kimi.subAgentStallTimeoutMs).toBe(base.subAgentStallTimeoutMs);
   });
+
+  test("muse spark carries tool-discipline rules; other families do not", () => {
+    const muse = resolveModelFamilyPolicy({
+      providerName: "opencode-go/abklabs",
+      model: "muse-spark-1.3-contributor",
+    });
+    const base = resolveModelFamilyPolicy({
+      providerName: "anthropic",
+      model: "claude-sonnet-4",
+    });
+    expect(muse.family).toBe("muse");
+    expect(muse.toolDisciplineRules).toContain("Batch independent tool calls");
+    expect(muse.toolDisciplineRules).toContain("Never re-read a file");
+    expect(base.toolDisciplineRules).toBeUndefined();
+  });
 });

src/agent/model-family-policy.ts

@@ -25,6 +25,12 @@ export interface ModelFamilyPolicy {
   subAgentStallTimeoutMs: number;
   /** Grok's finish-bias residual (withhold from orchestrators; see provider-family.ts). */
   applyGrokFinishBias: boolean;
+  /**
+   * Tool-discipline rules appended to the system prompt for families that do
+   * not self-terminate a tool loop. Empty for families that need none. Appended
+   * at the tail so it cannot disturb the cached prompt prefix.
+   */
+  toolDisciplineRules?: string;
 }
 
 const DEFAULT_WRAP_UP_NUDGE_TEXT =
@@ -76,6 +82,23 @@ const GROK_POLICY: Omit<ModelFamilyPolicy, "family"> = {
 // once eval data exists.
 const KIMI_POLICY: Omit<ModelFamilyPolicy, "family"> = { ...DEFAULT_POLICY };
 
+// Muse Spark does not reliably stop a tool loop at medium reasoning effort: on
+// a two-file fixture with a bounded fix it re-read files it had already read
+// and ran out the 8-turn ceiling without finishing. The same run with these
+// three rules appended finished in 3 turns on 4.3x fewer input tokens. At
+// minimal effort it terminates either way, so the rules earn their keep exactly
+// at the rungs where each wasted turn is most expensive. See CL-7869.
+const MUSE_TOOL_DISCIPLINE_RULES =
+  "Tool discipline:\n" +
+  "- Batch independent tool calls into a single turn.\n" +
+  "- Never re-read a file you have already read this session.\n" +
+  "- Do not narrate; act.";
+
+const MUSE_POLICY: Omit<ModelFamilyPolicy, "family"> = {
+  ...DEFAULT_POLICY,
+  toolDisciplineRules: MUSE_TOOL_DISCIPLINE_RULES,
+};
+
 export function resolveModelFamilyPolicy(input: {
   providerName: string;
   model?: string;
@@ -96,6 +119,8 @@ export function resolveModelFamilyPolicy(input: {
     }
     case "kimi":
       return { family, ...KIMI_POLICY };
+    case "muse":
+      return { family, ...MUSE_POLICY };
     default:
       return { family: "default", ...DEFAULT_POLICY };
   }

src/provider/openai-responses.test.ts

@@ -0,0 +1,12 @@
+import { describe, test, expect } from "bun:test";
+import { hostQuirks } from "./openai-responses.js";
+
+describe("OpenCode Go Responses quirks", () => {
+  // Muse Spark batches independent tool calls into one turn by default — three
+  // reads in a single response. Sending parallel_tool_calls: false collapses
+  // that to one call per turn and triples the turn count on a bounded task.
+  // Leaving the quirk unset is what keeps the gateway default. See CL-7869.
+  test("leaves parallel_tool_calls unset so the gateway default stands", () => {
+    expect(hostQuirks.parallelToolCalls).toBeUndefined();
+  });
+});

src/provider/openai-responses.ts

@@ -11,7 +11,7 @@ export const OPENAI_SESSION_ID_OPTION = "openaiSessionId";
 
 // Baked at the host so OpenCode Go Responses does not read source.quirks
 // (package createOpenAIResponsesAdapter would, and that is not the current Go wire).
-const hostQuirks: ResponsesQuirks = {
+export const hostQuirks: ResponsesQuirks = {
   path: "/responses",
   sessionIdOption: OPENAI_SESSION_ID_OPTION,
   headers: {

src/subagent/provider-family.ts

@@ -29,8 +29,16 @@ export function isKimiLeafProvider(input: {
   return false;
 }
 
+/** True when the provider/model is the OpenCode Go Muse Spark family. */
+export function isMuseSparkLeafProvider(input: {
+  providerName: string;
+  model?: string;
+}): boolean {
+  return input.model !== undefined && /^muse-spark/i.test(input.model.trim());
+}
+
 /** Model families the shared directors branch on via ModelFamilyPolicy. */
-export type ModelFamily = "grok" | "kimi" | "default";
+export type ModelFamily = "grok" | "kimi" | "muse" | "default";
 
 /**
  * Resolves a provider/model to a ModelFamily. Generalizes
@@ -44,6 +52,7 @@ export function detectModelFamily(input: {
 }): ModelFamily {
   if (isXaiGrokLeafProvider(input)) return "grok";
   if (isKimiLeafProvider(input)) return "kimi";
+  if (isMuseSparkLeafProvider(input)) return "muse";
   return "default";
 }