fix(cloud-task): deliver first-message skill bundles through prewarmed runs (#3173)

Author: tatoalo

packages/agent/src/server/agent-server.ts

@@ -1561,19 +1561,29 @@ export class AgentServer {
         ? this.getInitialPromptOverride(taskRun)
         : null;
       const pendingUserPrompt = await this.getPendingUserPrompt(taskRun);
+      // A prewarmed run gets its first message forwarded as a user_message
+      // signal on activation; building one from task.description here too
+      // would deliver it twice (and without the forwarded artifacts).
+      const prewarmed = !!(
+        taskRun?.state as Record<string, unknown> | undefined
+      )?.prewarmed;
       let initialPrompt: ContentBlock[] = [];
       let initialPromptMeta: Record<string, unknown> | undefined;
       if (pendingUserPrompt?.prompt.length) {
         initialPrompt = pendingUserPrompt.prompt;
         initialPromptMeta = pendingUserPrompt.meta;
       } else if (initialPromptOverride) {
         initialPrompt = [{ type: "text", text: initialPromptOverride }];
-      } else if (task.description) {
+      } else if (task.description && !prewarmed) {
         initialPrompt = [{ type: "text", text: task.description }];
       }
 
       if (initialPrompt.length === 0) {
-        this.logger.debug("Task has no description, skipping initial message");
+        this.logger.debug(
+          prewarmed
+            ? "Prewarmed run awaits its forwarded first message, skipping initial message"
+            : "Task has no description, skipping initial message",
+        );
         return;
       }
 

packages/agent/src/server/question-relay.test.ts

@@ -629,6 +629,38 @@ describe("Question relay", () => {
       });
     });
 
+    it("does not build a description prompt for a prewarmed run awaiting its forwarded message", async () => {
+      vi.spyOn(server.posthogAPI, "getTask").mockResolvedValue({
+        id: "test-task-id",
+        title: "t",
+        description: "/millie readme this skill",
+      } as unknown as Task);
+      vi.spyOn(server.posthogAPI, "getTaskRun").mockResolvedValue({
+        id: "test-run-id",
+        task: "test-task-id",
+        state: { prewarmed: true },
+      } as unknown as TaskRun);
+
+      const promptSpy = vi.fn().mockResolvedValue({ stopReason: "end_turn" });
+      server.session = {
+        payload: TEST_PAYLOAD,
+        acpSessionId: "acp-session",
+        clientConnection: { prompt: promptSpy },
+        logWriter: {
+          flushAll: vi.fn().mockResolvedValue(undefined),
+          getFullAgentResponse: vi.fn().mockReturnValue(null),
+          resetTurnMessages: vi.fn(),
+          appendRawLine: vi.fn(),
+          flush: vi.fn().mockResolvedValue(undefined),
+          isRegistered: vi.fn().mockReturnValue(true),
+        },
+      };
+
+      await server.sendInitialTaskMessage(TEST_PAYLOAD);
+
+      expect(promptSpy).not.toHaveBeenCalled();
+    });
+
     it("does not replay a transient upstream termination before any session activity", async () => {
       vi.spyOn(server.posthogAPI, "getTask").mockResolvedValue({
         id: "test-task-id",

packages/api-client/src/posthog-client.ts

@@ -2218,6 +2218,8 @@ export class PostHogAPIClient {
         model?: string | null;
         reasoning_effort?: string | null;
         channel?: string | null;
+        pending_user_message?: string;
+        pending_user_artifact_ids?: string[];
       },
   ) {
     const teamId = await this.getTeamId();

packages/core/src/task-detail/taskCreationHost.ts

@@ -112,6 +112,20 @@ export interface ITaskCreationHost {
    * too, or a typed `/my-skill` reaches the sandbox with no bundle attached.
    */
   resolveLocalSkillCommandPrompt(prompt: string): Promise<string>;
+  /**
+   * Return-and-clear the pre-warmed sandbox lease matching the composer
+   * selection, if one was provisioned while the user typed. The saga uploads
+   * first-message attachments (skill bundles, files) to this run before
+   * createTask so the backend's warm activation can forward them; null means
+   * no warm run is known client-side.
+   */
+  takeWarmTaskLease(args: {
+    repository: string;
+    branch?: string | null;
+    runtimeAdapter?: string | null;
+    model?: string | null;
+    reasoningEffort?: string | null;
+  }): { taskId: string; runId: string } | null;
   uploadRunAttachments(
     client: TaskCreationApiClient,
     taskId: string,

packages/core/src/task-detail/taskCreationSaga.test.ts

@@ -21,6 +21,9 @@ const mockHost = vi.hoisted(() => ({
   detectRepo: vi.fn(),
   getCloudPromptTransport: vi.fn(),
   resolveLocalSkillCommandPrompt: vi.fn(async (prompt: string) => prompt),
+  takeWarmTaskLease: vi.fn(
+    (): { taskId: string; runId: string } | null => null,
+  ),
   uploadRunAttachments: vi.fn(),
   setProvisioningActive: vi.fn(),
   clearProvisioning: vi.fn(),
@@ -516,6 +519,167 @@ describe("TaskCreationSaga", () => {
     },
   );
 
+  it("uploads skill bundles to the warm run and passes pending fields through createTask", async () => {
+    const skillTag =
+      '<skill name="my-skill" source="user" path="/skills/my-skill" /> do it';
+    mockHost.resolveLocalSkillCommandPrompt.mockResolvedValue(skillTag);
+    mockHost.getCloudPromptTransport.mockReturnValue({
+      filePaths: [],
+      skillBundles: [
+        { name: "my-skill", source: "user", path: "/skills/my-skill" },
+      ],
+      messageText: "/my-skill do it",
+      promptText: "/my-skill do it",
+    });
+    mockHost.takeWarmTaskLease.mockReturnValue({
+      taskId: "warm-task",
+      runId: "warm-run",
+    });
+    mockHost.uploadRunAttachments.mockResolvedValue(["skill-artifact-1"]);
+
+    const warmActivatedTask = createTask({
+      id: "warm-task",
+      latest_run: createRun({ id: "warm-run", task: "warm-task" }),
+    });
+    const createTaskMock = vi.fn().mockResolvedValue(warmActivatedTask);
+    const createTaskRunMock = vi.fn();
+    const startTaskRunMock = vi.fn();
+    const saga = makeSaga({
+      createTask: createTaskMock,
+      createTaskRun: createTaskRunMock,
+      startTaskRun: startTaskRunMock,
+    });
+
+    const result = await saga.run({
+      content: "/my-skill do it",
+      repository: "posthog/posthog",
+      workspaceMode: "cloud",
+      branch: "main",
+    });
+
+    expect(result.success).toBe(true);
+    expect(mockHost.takeWarmTaskLease).toHaveBeenCalledWith({
+      repository: "posthog/posthog",
+      branch: "main",
+      runtimeAdapter: null,
+      model: null,
+      reasoningEffort: null,
+    });
+    // The bundle must land on the warm run before createTask triggers activation.
+    expect(mockHost.uploadRunAttachments).toHaveBeenCalledWith(
+      expect.anything(),
+      "warm-task",
+      "warm-run",
+      [],
+      [{ name: "my-skill", source: "user", path: "/skills/my-skill" }],
+    );
+    expect(createTaskMock).toHaveBeenCalledWith(
+      expect.objectContaining({
+        branch: "main",
+        pending_user_message: "/my-skill do it",
+        pending_user_artifact_ids: ["skill-artifact-1"],
+      }),
+    );
+    // Warm-activated at create time: no fresh run is created or started.
+    expect(createTaskRunMock).not.toHaveBeenCalled();
+    expect(startTaskRunMock).not.toHaveBeenCalled();
+  });
+
+  it("suppresses warm reuse when attachments exist but no warm lease is known", async () => {
+    const skillTag =
+      '<skill name="my-skill" source="user" path="/skills/my-skill" /> do it';
+    mockHost.resolveLocalSkillCommandPrompt.mockResolvedValue(skillTag);
+    mockHost.getCloudPromptTransport.mockReturnValue({
+      filePaths: [],
+      skillBundles: [
+        { name: "my-skill", source: "user", path: "/skills/my-skill" },
+      ],
+      messageText: "/my-skill do it",
+      promptText: "/my-skill do it",
+    });
+    mockHost.takeWarmTaskLease.mockReturnValue(null);
+    mockHost.uploadRunAttachments.mockResolvedValue(["skill-artifact-1"]);
+
+    const createdTask = createTask();
+    const startedTask = createTask({ latest_run: createRun() });
+    const createTaskMock = vi.fn().mockResolvedValue(createdTask);
+    const createTaskRunMock = vi.fn().mockResolvedValue(createRun());
+    const startTaskRunMock = vi.fn().mockResolvedValue(startedTask);
+    const saga = makeSaga({
+      createTask: createTaskMock,
+      createTaskRun: createTaskRunMock,
+      startTaskRun: startTaskRunMock,
+    });
+
+    const result = await saga.run({
+      content: "/my-skill do it",
+      repository: "posthog/posthog",
+      workspaceMode: "cloud",
+      branch: "main",
+    });
+
+    expect(result.success).toBe(true);
+    // No lease to upload to: omit the warm-reuse branch hint so the backend
+    // cannot activate a warm run this client can't attach the bundle to.
+    expect(createTaskMock.mock.calls[0][0].branch).toBeUndefined();
+    // Cold path proceeds and delivers the bundle through the run start.
+    expect(startTaskRunMock).toHaveBeenCalledWith("task-123", "run-123", {
+      pendingUserMessage: "/my-skill do it",
+      pendingUserArtifactIds: ["skill-artifact-1"],
+    });
+  });
+
+  it("falls back to cold creation when the warm-run upload fails", async () => {
+    const skillTag =
+      '<skill name="my-skill" source="user" path="/skills/my-skill" /> do it';
+    mockHost.resolveLocalSkillCommandPrompt.mockResolvedValue(skillTag);
+    mockHost.getCloudPromptTransport.mockReturnValue({
+      filePaths: [],
+      skillBundles: [
+        { name: "my-skill", source: "user", path: "/skills/my-skill" },
+      ],
+      messageText: "/my-skill do it",
+      promptText: "/my-skill do it",
+    });
+    mockHost.takeWarmTaskLease.mockReturnValue({
+      taskId: "warm-task",
+      runId: "warm-run",
+    });
+    mockHost.uploadRunAttachments
+      .mockRejectedValueOnce(new Error("warm upload failed"))
+      .mockResolvedValueOnce(["skill-artifact-1"]);
+
+    const createdTask = createTask();
+    const startedTask = createTask({ latest_run: createRun() });
+    const createTaskMock = vi.fn().mockResolvedValue(createdTask);
+    const createTaskRunMock = vi.fn().mockResolvedValue(createRun());
+    const startTaskRunMock = vi.fn().mockResolvedValue(startedTask);
+    const saga = makeSaga({
+      createTask: createTaskMock,
+      createTaskRun: createTaskRunMock,
+      startTaskRun: startTaskRunMock,
+    });
+
+    const result = await saga.run({
+      content: "/my-skill do it",
+      repository: "posthog/posthog",
+      workspaceMode: "cloud",
+      branch: "main",
+    });
+
+    // The failed pre-upload must not fail creation or activate warm without
+    // the bundle: warm reuse is suppressed and the cold path re-uploads.
+    expect(result.success).toBe(true);
+    expect(createTaskMock.mock.calls[0][0].branch).toBeUndefined();
+    expect(
+      createTaskMock.mock.calls[0][0].pending_user_artifact_ids,
+    ).toBeUndefined();
+    expect(startTaskRunMock).toHaveBeenCalledWith("task-123", "run-123", {
+      pendingUserMessage: "/my-skill do it",
+      pendingUserArtifactIds: ["skill-artifact-1"],
+    });
+  });
+
   it("uses the selected user GitHub integration for cloud task creation", async () => {
     const createdTask = createTask({
       github_user_integration: "user-integration-123",