fix: include codex system prompt on initial turn

saltbo · saltbo · commit ff50412a9675 · 2026-05-03T12:13:31.000-04:00
diff --git a/packages/cli/src/daemon/resumer.ts b/packages/cli/src/daemon/resumer.ts
@@ -20,6 +20,10 @@ import type { RuntimePool } from "./runtimePool.js";
 
 const logger = createLogger("resumer");
 
+function buildResumeTaskContext(message: string): string {
+  return `This is a resume of an already claimed task. The task is already assigned to you and in_progress; do not run \`ak task claim\` again. Continue from the message below.\n\n${message}`;
+}
+
 /**
  * Resume a saved session (rate-limited or rejected). Returns true on success.
  */
@@ -76,7 +80,7 @@ export async function resumeSession(session: SessionFile, message: string, clien
     sessionId: session.sessionId,
     resumeToken: session.providerResumeToken,
     cwd: workspace.cwd,
-    taskContext: message,
+    taskContext: buildResumeTaskContext(message),
     agentClient,
     agentEnv,
     resume: true,
diff --git a/packages/cli/src/providers/codex.ts b/packages/cli/src/providers/codex.ts
@@ -21,6 +21,15 @@ function readAccessToken(): string | null {
   }
 }
 
+function readSystemPrompt(filePath?: string): string {
+  if (!filePath) return "";
+  return readFileSync(filePath, "utf-8");
+}
+
+function buildPrompt(opts: ExecuteOpts): string {
+  return [readSystemPrompt(opts.systemPromptFile), opts.taskContext].filter(Boolean).join("\n\n");
+}
+
 /** Per 1M tokens, OpenAI pricing */
 const CODEX_PRICING: Record<string, { input: number; cached_input: number; output: number }> = {
   o3: { input: 2.0, cached_input: 0.5, output: 8.0 },
@@ -223,7 +232,7 @@ export const codexProvider: AgentProvider = {
     const thread = opts.resume ? codex.resumeThread(opts.resumeToken ?? opts.sessionId, threadOpts) : codex.startThread(threadOpts);
 
     const abortController = new AbortController();
-    const streamed = await thread.runStreamed(opts.taskContext, { signal: abortController.signal });
+    const streamed = await thread.runStreamed(buildPrompt(opts), { signal: abortController.signal });
 
     const events = (async function* () {
       const turnOpen = { value: false };
diff --git a/packages/cli/tests/providers.test.ts b/packages/cli/tests/providers.test.ts
@@ -685,6 +685,33 @@ describe("codexProvider.execute — thread selection", () => {
     expect(resumeThreadSpy).toHaveBeenCalledWith("codex-thread-1", expect.any(Object));
   });
 
+  it("passes system prompt content and task context to Codex", async () => {
+    const { Codex } = await import("@openai/codex-sdk");
+    const fsModule = await import("node:fs");
+    vi.mocked(fsModule.readFileSync).mockImplementation((path) => {
+      if (path === "/tmp/system.txt") return "You are Codex with board rules." as any;
+      throw new Error("ENOENT");
+    });
+    const runStreamedSpy = vi.fn().mockResolvedValue({ events: (async function* () {})() });
+    vi.mocked(Codex).mockImplementationOnce(
+      () =>
+        ({
+          startThread: vi.fn().mockReturnValue({ runStreamed: runStreamedSpy }),
+          resumeThread: vi.fn(),
+        }) as any,
+    );
+
+    await codexProvider.execute({
+      sessionId: "s1",
+      cwd: "/tmp",
+      env: { OPENAI_API_KEY: "test-key" },
+      systemPromptFile: "/tmp/system.txt",
+      taskContext: "Implement the task.",
+    });
+
+    expect(runStreamedSpy).toHaveBeenCalledWith("You are Codex with board rules.\n\nImplement the task.", expect.any(Object));
+  });
+
   it("omits explicit model for ChatGPT-backed Codex sessions", async () => {
     const { Codex } = await import("@openai/codex-sdk");
     const fsModule = await import("node:fs");
@@ -1369,6 +1396,23 @@ describe("geminiProvider.execute — arg selection", () => {
     expect(call.args).toContain("--resume");
   });
 
+  it("uses task context only when resuming", async () => {
+    const { spawnAgent } = await import("../src/providers/spawnHelper.js");
+    vi.mocked(spawnAgent).mockClear();
+    await geminiProvider.execute({
+      sessionId: "s1",
+      cwd: "/tmp",
+      env: {},
+      systemPromptFile: "/tmp/system.txt",
+      taskContext: "Task rejected. Reason: fix it",
+      resume: true,
+    });
+    const call = vi.mocked(spawnAgent).mock.calls[0][0];
+    const promptIdx = call.args.indexOf("--prompt");
+
+    expect(call.args[promptIdx + 1]).toBe("Task rejected. Reason: fix it");
+  });
+
   it("uses buildArgs when resume is false or absent", async () => {
     const { spawnAgent } = await import("../src/providers/spawnHelper.js");
     vi.mocked(spawnAgent).mockClear();
diff --git a/packages/cli/tests/rejectResumeFlow.integration.test.ts b/packages/cli/tests/rejectResumeFlow.integration.test.ts
@@ -115,7 +115,7 @@ import { resumeSession } from "../src/daemon/resumer.js";
 import { RuntimePool } from "../src/daemon/runtimePool.js";
 import type { AgentEvent, AgentHandle, AgentProvider, ExecuteOpts } from "../src/providers/types.js";
 import type { SessionFile } from "../src/session/store.js";
-import { clearAllSessions, listSessions, readSession, writeSession } from "../src/session/store.js";
+import { clearAllSessions, readSession, writeSession } from "../src/session/store.js";
 
 // ── FakeProvider ──────────────────────────────────────────────────────────────
 
@@ -136,7 +136,6 @@ class FakeProvider implements AgentProvider {
   executeCalls: FakeExecuteCall[] = [];
 
   async execute(opts: ExecuteOpts): Promise<AgentHandle> {
-    let pushEvent!: (event: AgentEvent) => void;
     let endStream!: () => void;
 
     // The queue is implemented with a simple promise chain so events
@@ -145,7 +144,7 @@ class FakeProvider implements AgentProvider {
     const waiters: Array<(done: boolean) => void> = [];
     let done = false;
 
-    pushEvent = (event: AgentEvent) => {
+    const pushEvent = (event: AgentEvent) => {
       if (waiters.length > 0) {
         // a consumer is already waiting — deliver directly
         eventQueue.push(event);
@@ -643,9 +642,13 @@ describe("Scenario 5: full end-to-end reject-resume", () => {
     // (b) a new execute() call happened on FakeProvider
     expect(fake.executeCalls).toHaveLength(1);
 
-    // (c) taskContext passed in contains "fix it"
+    // (c) provider receives resume guard context plus the original rejection message
     const executeOpts = fake.executeCalls[0].opts;
-    expect(executeOpts.taskContext).toContain("fix it");
+    expect(executeOpts.taskContext).toContain("already claimed task");
+    expect(executeOpts.taskContext).toContain("already assigned to you and in_progress");
+    expect(executeOpts.taskContext).toContain("do not run `ak task claim` again");
+    expect(executeOpts.taskContext).toContain(message);
+    expect(executeOpts.resume).toBe(true);
 
     // (d) session status went back to "active"
     const afterResume = readSession(session.sessionId);
diff --git a/tests/runtimePool-coverage.test.ts b/tests/runtimePool-coverage.test.ts
@@ -295,6 +295,46 @@ describe("RuntimePool — getActiveTaskIds", () => {
   });
 });
 
+describe("RuntimePool — provider execute options", () => {
+  it("passes systemPromptFile through to the provider", async () => {
+    const taskId = randomUUID();
+    const sessionId = randomUUID();
+    await seedActiveSession(sessions, sessionId, taskId);
+
+    const agentClient = makeAgentClient({ status: "in_progress" });
+    let resolveEvents!: () => void;
+    const stuckHandle: AgentHandle = {
+      events: (async function* () {
+        await new Promise<void>((r) => {
+          resolveEvents = r;
+        });
+      })(),
+      abort: vi.fn().mockResolvedValue(undefined),
+      send: vi.fn().mockResolvedValue(undefined),
+    };
+    const provider = makeProvider(stuckHandle);
+    const pool = new RuntimePool(apiClient, { onSlotFreed: vi.fn() }, { onRateLimited: vi.fn(), onRateLimitResumed: vi.fn() }, 0, null);
+
+    await pool.spawnAgent({
+      provider,
+      taskId,
+      sessionId,
+      cwd: "/tmp",
+      taskContext: "test task",
+      agentClient,
+      agentEnv: {},
+      systemPromptFile: "/tmp/system-prompt.txt",
+    });
+
+    expect(provider.execute).toHaveBeenCalledWith(
+      expect.objectContaining({
+        systemPromptFile: "/tmp/system-prompt.txt",
+      }),
+    );
+    resolveEvents();
+  });
+});
+
 describe("RuntimePool — sendToAgent", () => {
   it("sends message to a running agent", async () => {
     const taskId = randomUUID();
diff --git a/tests/task-scheduled-at.test.ts b/tests/task-scheduled-at.test.ts
@@ -521,6 +521,24 @@ describe("dispatchTasks — scheduled_at filter", () => {
     rl.stop();
   });
 
+  it("writes generated system prompt and passes its file to the runtime", async () => {
+    const { dispatchTasks } = await import("../packages/cli/src/daemon/dispatcher");
+    const { getSessionManager } = await import("../packages/cli/src/session/manager");
+    const spawnSpy = vi.fn().mockResolvedValue(undefined);
+    vi.mocked(getSessionManager().create).mockClear();
+    const task = makeTask({ id: "task-system-prompt", assigned_to: "agent-system-prompt", status: "todo" });
+    const client = makeClient([task]);
+    const pool = makePool(spawnSpy);
+    const rl = makeRateLimiter();
+
+    const result = await dispatchTasks(client as any, pool as any, rl, prMonitor, opts);
+
+    expect(result).toBe(true);
+    expect(getSessionManager().create).toHaveBeenCalledWith(expect.not.objectContaining({ systemPrompt: expect.anything() }));
+    expect(spawnSpy).toHaveBeenCalledWith(expect.objectContaining({ systemPromptFile: "/tmp/prompt.txt" }));
+    rl.stop();
+  });
+
   it("does not dispatch when the local runtime is unauthorized", async () => {
     const { dispatchTasks } = await import("../packages/cli/src/daemon/dispatcher");
     providerMocks.availability = { status: "unauthorized" };
