Restore the system prompt after context compaction

Compaction resume inferred without the constructor prompt, so Codex requests dropped instructions. Default systemPrompt at the infer rewrite layer so the operating prompt survives; explicit values still win.

Author: TheGreatAxios

CHANGELOG.md

@@ -11,6 +11,13 @@ matching `## [X.Y.Z]` section (plus install instructions). Do not maintain
 parallel copies under `docs/` or `scripts/notes/`. At cut time: rename
 `## [Unreleased]` to `## [X.Y.Z] - YYYY-MM-DD`, then run the release script.
 
+## [Unreleased]
+
+### Fixed
+
+- After context compaction, ChatGPT Codex requests keep the operating prompt as
+  instructions.
+
 ## [0.3.18] - 2026-09-08
 
 ### Added

src/agent/director.ts

@@ -526,6 +526,7 @@ class ChatDirectorImpl extends DefaultDirector {
         ...action.options,
         tools,
         retryPolicy: action.options?.retryPolicy ?? this.retryPolicy,
+        systemPrompt: action.options?.systemPrompt ?? this._systemPrompt,
       };
       if (this.inactivityTimeoutMs !== undefined)
         options.inactivityTimeoutMs = this.inactivityTimeoutMs;

src/director.test.ts

@@ -518,7 +518,10 @@ describe("chatDirector compaction", () => {
   }
 
   test("compacts at the tool.done pause once over threshold", async () => {
-    const director = chatDirectorWithContinuation();
+    const director = createChatDirector("Corbits operating prompt", [], {
+      onTasksChange: () => {},
+      requestContinuation: () => {},
+    });
     await director.decide(overThresholdToolTurn(), longState, mockCapabilities);
     const actions = actionsArray(
       await director.decide(makeToolDoneEvent("t1"), longState, mockCapabilities),
@@ -535,6 +538,10 @@ describe("chatDirector compaction", () => {
       await director.decide(messageReceived(""), longState, mockCapabilities),
     );
     expect(resumed.some((a) => a.type === "infer")).toBe(true);
+    const infer = resumed.find((a) => a.type === "infer");
+    const options: ExtendedInferenceOptions | undefined =
+      infer?.type === "infer" ? infer.options : undefined;
+    expect(options?.systemPrompt).toBe("Corbits operating prompt");
   });
 
   // CL-6910: `timeout`/`retryable` are owned entirely by the harness's own
@@ -602,7 +609,10 @@ describe("chatDirector compaction", () => {
 
   test("a context_overflow inference error triggers compact-and-retry, not a terminal reply", async () => {
     let continuations = 0;
-    const director = chatDirectorWithContinuation(() => continuations++);
+    const director = createChatDirector("Corbits operating prompt", [], {
+      onTasksChange: () => {},
+      requestContinuation: () => continuations++,
+    });
     const actions = actionsArray(
       await director.decide(overflowError(), longState, mockCapabilities),
     );
@@ -615,6 +625,10 @@ describe("chatDirector compaction", () => {
       await director.decide(messageReceived(""), longState, mockCapabilities),
     );
     expect(resumed.some((a) => a.type === "infer")).toBe(true);
+    const infer = resumed.find((a) => a.type === "infer");
+    const options: ExtendedInferenceOptions | undefined =
+      infer?.type === "infer" ? infer.options : undefined;
+    expect(options?.systemPrompt).toBe("Corbits operating prompt");
   });
 
   test("overflow recovery is bounded so an incompressible history cannot loop forever", async () => {
@@ -1038,7 +1052,7 @@ describe("transient nudges", () => {
       source: "test",
     }) as unknown as ReactorInboundEvent;
 
-  test("open-task nudge uses ephemeralTurns, not systemPrompt", async () => {
+  test("open-task nudge uses ephemeralTurns and keeps the stable system prompt", async () => {
     const director = createChatDirector("stable-base", [], { onTasksChange: () => {} });
     await director.decide(manageTasksEvent("doing"), mockState, mockCapabilities);
     const actions = actionsArray(await director.decide(textTurn(), mockState, mockCapabilities));
@@ -1050,6 +1064,6 @@ describe("transient nudges", () => {
     expect(options?.ephemeralTurns?.length ?? 0).toBeGreaterThan(0);
     const nudgeText = options?.ephemeralTurns?.[0]?.content?.find((b) => b.type === "text");
     expect(nudgeText?.type === "text" ? nudgeText.text : "").toContain("tasks are still open");
-    expect(options?.systemPrompt).toBeUndefined();
+    expect(options?.systemPrompt).toBe("stable-base");
   });
 });

src/subagent/nudge-director.test.ts

@@ -194,6 +194,7 @@ describe("SubAgentDirector tool failure recovery", () => {
 
     const resumed = inferAction(await director.decide(messageReceived(""), longState, caps));
     const resumedTexts = ephemeralTexts(resumed);
+    expect(resumed.options?.systemPrompt).toBe("system");
     expect(resumedTexts).toHaveLength(1);
     expect(resumedTexts?.[0]).toContain("A tool call failed");
 
@@ -260,6 +261,7 @@ describe("SubAgentDirector tool failure recovery", () => {
 
     const resumed = inferAction(await director.decide(messageReceived(""), state, caps));
     const resumedTexts = ephemeralTexts(resumed);
+    expect(resumed.options?.systemPrompt).toBe("system");
     expect(resumedTexts).toHaveLength(1);
     expect(resumedTexts?.[0]).toContain("A tool call failed");
 
@@ -298,6 +300,7 @@ describe("SubAgentDirector tool failure recovery", () => {
     expect(continuations).toBe(1);
 
     const resumed = inferAction(await director.decide(messageReceived(""), state, caps));
+    expect(resumed.options?.systemPrompt).toBe("system");
     expect(ephemeralTexts(resumed)).toBeUndefined();
   });
 });

src/subagent/nudge-director.ts

@@ -86,6 +86,7 @@ function isNonEmptyParentMessage(event: ReactorInboundEvent): boolean {
 export class SubAgentDirector extends DefaultDirector {
   private readonly compaction: CompactionGovernor;
   private readonly retryPolicy: RetryPolicy;
+  private readonly _systemPrompt: string;
   /** When true (CritiqueDirector), empty readCounts is not a successful complete. */
   private readonly requireEvidence: boolean;
   private turnsCompleted = 0;
@@ -177,6 +178,7 @@ export class SubAgentDirector extends DefaultDirector {
     retryPolicy: RetryPolicy = createCorbitsRetryPolicy(),
   ) {
     super(systemPrompt, toolDefinitions, {});
+    this._systemPrompt = systemPrompt;
     this.compaction = createCompactionGovernor(requestContinuation, systemPrompt, toolDefinitions);
     this.stallTimeoutMs = stallTimeoutMs;
     this.now = now;
@@ -197,6 +199,7 @@ export class SubAgentDirector extends DefaultDirector {
         infer({
           ...(options ?? {}),
           retryPolicy: options?.retryPolicy ?? this.retryPolicy,
+          systemPrompt: options?.systemPrompt ?? this._systemPrompt,
         }),
     };
     // A real parent follow-up re-opens the brief; empty continuations do not.

tests/unit/codex-responses-adapter.test.ts

@@ -8,6 +8,7 @@ import {
   CODEX_RESPONSES_PROVIDER,
 } from "../../src/provider/codex-responses-adapter.js";
 import { GROK_RESPONSES_PROVIDER } from "../../src/provider/grok-responses-adapter.js";
+import { COMPACTED_PREFIX } from "../../src/session/compactor.js";
 import { BEARER_CREDENTIAL_SENTINEL } from "@intx/inference";
 import type { ConversationTurn, InferenceOptions, LastCycleSource } from "@intx/types/runtime";
 
@@ -87,6 +88,32 @@ describe("codex-responses buildRequest", () => {
     expect(body["tool_choice"]).toBe("auto");
   });
 
+  test("sends compacted history with the system prompt as instructions and no developer item", () => {
+    const systemPrompt = "Corbits operating prompt";
+    const turns: ConversationTurn[] = [
+      userTurn(`${COMPACTED_PREFIX}\nPrior work summarized.`),
+      { role: "assistant", timestamp: 0, content: [{ type: "text", text: "ok" }] },
+      userTurn("continue"),
+    ];
+    const body = JSON.parse(
+      adapter().buildRequest(turns, "gpt-5-codex", { ...baseOptions, systemPrompt }).body,
+    ) as Record<string, unknown>;
+    expect(body["instructions"]).toBe(systemPrompt);
+    const input = body["input"] as {
+      role?: string;
+      content?: { text?: string }[];
+    }[];
+    expect(input).toHaveLength(3);
+    expect(input[0]?.role).toBe("user");
+    expect(input[1]?.role).toBe("assistant");
+    expect(input[2]?.role).toBe("user");
+    expect(input[0]?.content?.[0]?.text?.startsWith(COMPACTED_PREFIX)).toBe(true);
+    expect(input.every((item) => item.role !== "developer")).toBe(true);
+    expect(input.some((item) => item.content?.some((block) => block.text === systemPrompt))).toBe(
+      false,
+    );
+  });
+
   test.each([undefined, "", "Corbits operating prompt"])(
     "preserves conversation order and system turns with systemPrompt %j",
     (systemPrompt) => {