Send the tool-discipline rules instead of only composing them

The rules were appended to the director's own copy of the system prompt
after calling super(). The base director keeps its own copy and sets
options.systemPrompt from it on every ordinary turn, so withCurrentTools'
`?? this._systemPrompt` fallback never fired and the composed prompt was
built but never sent. A Muse Spark session received the base prompt
verbatim: the whole change was a no-op, and every existing test passed.

Compose before super() so the base director holds the composed prompt,
and give the compaction governor the same text it will actually be
estimating.

Sub-agent leaves get the rules too. They are the case the ticket names —
a spawned worker running to its turn budget — and SubAgentDirector never
received them at all.

Adds the test that would have caught this: assert the prompt on the
emitted infer action, not the prompt the director was constructed with.

CL-7869

Author: TheGreatAxios

src/agent/director.ts

@@ -482,8 +482,23 @@ class ChatDirectorImpl extends DefaultDirector {
     toolDefinitions: ToolDefinition[],
     options: ChatDirectorImplOptions,
   ) {
-    super(systemPrompt, toolDefinitions, {});
-    this._systemPrompt = systemPrompt;
+    // Compose before super(). The base director keeps its own copy of the
+    // system prompt and sets options.systemPrompt from it on every ordinary
+    // turn, so withCurrentTools' `?? this._systemPrompt` fallback never fires
+    // and anything appended after super() is built but never sent.
+    const familyPolicy =
+      options.modelFamilyPolicy ??
+      resolveModelFamilyPolicy({ providerName: "" });
+    const disciplineRules = familyPolicy.toolDisciplineRules;
+    // Family tool-discipline rules go at the tail. 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 composedPrompt =
+      disciplineRules !== undefined && disciplineRules.length > 0
+        ? `${systemPrompt}\n\n${disciplineRules}`
+        : systemPrompt;
+    super(composedPrompt, toolDefinitions, {});
+    this._systemPrompt = composedPrompt;
     this._toolDefinitions = toolDefinitions;
     this.inactivityTimeoutMs = options.inactivityTimeoutMs;
     this.totalTimeoutMs = options.totalTimeoutMs;
@@ -493,19 +508,10 @@ class ChatDirectorImpl extends DefaultDirector {
     this.onTasksChange = options.onTasksChange;
     this.compaction = createCompactionGovernor(
       options.requestContinuation,
-      systemPrompt,
+      composedPrompt,
       toolDefinitions,
     );
-    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.modelFamilyPolicy = familyPolicy;
     this.retryPolicy = options.retryPolicy ?? createCorbitsRetryPolicy();
     this.getLiveFleetCount = options.getLiveFleetCount;
   }

src/director.test.ts

@@ -1661,3 +1661,43 @@ describe("chatDirector spacer echo", () => {
     expect(exhausted.some((a) => a.type === "reply")).toBe(true);
   });
 });
+
+// The rules are only worth anything if they reach the model. An earlier cut of
+// this change appended them to the director's own copy of the system prompt
+// AFTER calling super(), so the base director kept sending the original and
+// the whole feature was a no-op that every existing test passed.
+describe("tool-discipline rules on the wire", () => {
+  async function promptSentFor(model: string): Promise<string | undefined> {
+    const director = createChatDirector("BASE PROMPT", [], {
+      onTasksChange: () => undefined,
+      provider: { providerName: "opencode-go", model },
+    });
+    const event = {
+      type: "message.received",
+      message: { role: "user", content: "hi" },
+    } as unknown as ReactorInboundEvent;
+    const actions = actionsArray(
+      await director.decide(event, mockState, mockCapabilities),
+    );
+    const infer = actions.find((a) => a.type === "infer") as
+      | { options?: ExtendedInferenceOptions }
+      | undefined;
+    return infer?.options?.systemPrompt;
+  }
+
+  test("a Muse Spark session sends the rules, not just the base prompt", async () => {
+    const prompt = await promptSentFor("muse-spark-1.3-contributor");
+    expect(prompt).toContain("BASE PROMPT");
+    expect(prompt).toContain("Batch independent tool calls");
+    expect(prompt).toContain("Never re-read a file");
+  });
+
+  test("the rules ride at the tail, where they cannot disturb the cache prefix", async () => {
+    const prompt = await promptSentFor("muse-spark-1.3-contributor");
+    expect(prompt?.startsWith("BASE PROMPT")).toBe(true);
+  });
+
+  test("a family with no rules sends the prompt untouched", async () => {
+    expect(await promptSentFor("claude-sonnet-4")).toBe("BASE PROMPT");
+  });
+});

src/subagent/nudge-director.ts

@@ -234,12 +234,20 @@ export class SubAgentDirector extends DefaultDirector {
     requireEvidence = false,
     requirePlanSubstance = false,
     retryPolicy: RetryPolicy = createCorbitsRetryPolicy(),
+    toolDisciplineRules?: string,
   ) {
-    super(systemPrompt, toolDefinitions, {});
-    this._systemPrompt = systemPrompt;
+    // Composed before super() for the same reason as ChatDirectorImpl: the base
+    // director keeps its own copy and sends that, so anything appended after
+    // super() is never on the wire.
+    const composedPrompt =
+      toolDisciplineRules !== undefined && toolDisciplineRules.length > 0
+        ? `${systemPrompt}\n\n${toolDisciplineRules}`
+        : systemPrompt;
+    super(composedPrompt, toolDefinitions, {});
+    this._systemPrompt = composedPrompt;
     this.compaction = createCompactionGovernor(
       requestContinuation,
-      systemPrompt,
+      composedPrompt,
       toolDefinitions,
     );
     this.stallTimeoutMs = stallTimeoutMs;

src/subagent/run.ts

@@ -995,6 +995,7 @@ async function runSubAgentInner(
             providerId: params.provider.providerName,
             admission: params.admission ?? getProcessAdmissionQueue(),
           }),
+          modelFamilyPolicy.toolDisciplineRules,
         );
         director.observeForcedStop((reason) => {
           directorForcedStopReason = reason;