diff --git a/packages/api-client/package.json b/packages/api-client/package.json
index bee0ebc547..3a592020a4 100644
--- a/packages/api-client/package.json
+++ b/packages/api-client/package.json
@@ -25,7 +25,6 @@
     "src/**/*"
   ],
   "dependencies": {
-    "@posthog/agent": "workspace:*",
     "@posthog/shared": "workspace:*"
   }
 }
diff --git a/packages/api-client/src/fetcher.test.ts b/packages/api-client/src/fetcher.test.ts
index c205949418..6e1e17a351 100644
--- a/packages/api-client/src/fetcher.test.ts
+++ b/packages/api-client/src/fetcher.test.ts
@@ -53,6 +53,45 @@ describe("buildApiFetcher", () => {
     expect(mockFetch.mock.calls[0][1].headers.get("Authorization")).toBe(
       "Bearer my-token",
     );
+    expect(mockFetch.mock.calls[0][1].headers.get("User-Agent")).toBe(
+      "posthog/desktop.hog.dev; version: test",
+    );
+  });
+
+  it("uses an injected fetch implementation and custom user agent", async () => {
+    const injectedFetch = vi.fn().mockResolvedValueOnce(ok());
+    const fetcher = buildApiFetcher({
+      getAccessToken: vi.fn().mockResolvedValue("token"),
+      refreshAccessToken: vi.fn().mockResolvedValue("new-token"),
+      appVersion: "1.2.3",
+      fetch: injectedFetch,
+      userAgent: "posthog/mobile; version: 1.2.3",
+    });
+
+    await fetcher.fetch(mockInput);
+
+    expect(injectedFetch).toHaveBeenCalledTimes(1);
+    expect(mockFetch).not.toHaveBeenCalled();
+    expect(injectedFetch.mock.calls[0][1].headers.get("User-Agent")).toBe(
+      "posthog/mobile; version: 1.2.3",
+    );
+  });
+
+  it("omits the user agent when explicitly disabled", async () => {
+    const injectedFetch = vi.fn().mockResolvedValueOnce(ok());
+    const fetcher = buildApiFetcher({
+      getAccessToken: vi.fn().mockResolvedValue("token"),
+      refreshAccessToken: vi.fn().mockResolvedValue("new-token"),
+      appVersion: "1.2.3",
+      fetch: injectedFetch,
+      userAgent: null,
+    });
+
+    await fetcher.fetch(mockInput);
+
+    expect(injectedFetch.mock.calls[0][1].headers.has("User-Agent")).toBe(
+      false,
+    );
   });
 
   it("retries once with a freshly fetched token on 401", async () => {
diff --git a/packages/api-client/src/fetcher.ts b/packages/api-client/src/fetcher.ts
index 6bf59aa9f8..bc061a3030 100644
--- a/packages/api-client/src/fetcher.ts
+++ b/packages/api-client/src/fetcher.ts
@@ -1,9 +1,16 @@
 import type { createApiClient } from "./generated";
 
+export type FetchImplementation = (
+  input: string | URL | Request,
+  init?: RequestInit,
+) => Promise<Response>;
+
 export type ApiFetcherConfig = {
   getAccessToken: () => Promise<string>;
   refreshAccessToken: () => Promise<string>;
   appVersion: string;
+  fetch?: FetchImplementation;
+  userAgent?: string | null;
 };
 
 /**
@@ -13,11 +20,13 @@ export type ApiFetcherConfig = {
  */
 export class ApiRequestError extends Error {
   readonly status: number;
+  readonly body: unknown;
 
-  constructor(status: number, serializedBody: string) {
+  constructor(status: number, serializedBody: string, body?: unknown) {
     super(`Failed request: [${status}] ${serializedBody}`);
     this.name = "ApiRequestError";
     this.status = status;
+    this.body = body;
   }
 }
 
@@ -29,7 +38,11 @@ export function requestErrorStatus(error: unknown): number | undefined {
 export const buildApiFetcher: (
   config: ApiFetcherConfig,
 ) => Parameters<typeof createApiClient>[0] = (config) => {
-  const userAgent = `posthog/desktop.hog.dev; version: ${config.appVersion}`;
+  const fetchImpl = config.fetch ?? globalThis.fetch;
+  const userAgent =
+    config.userAgent === undefined
+      ? `posthog/desktop.hog.dev; version: ${config.appVersion}`
+      : config.userAgent;
 
   const makeRequest = async (
     input: Parameters<Parameters<typeof createApiClient>[0]["fetch"]>[0],
@@ -38,7 +51,9 @@ export const buildApiFetcher: (
     const headers = new Headers();
     headers.set("Authorization", `Bearer ${token}`);
     headers.set("Content-Type", "application/json");
-    headers.set("User-Agent", userAgent);
+    if (userAgent) {
+      headers.set("User-Agent", userAgent);
+    }
 
     if (input.urlSearchParams) {
       input.url.search = input.urlSearchParams.toString();
@@ -59,7 +74,7 @@ export const buildApiFetcher: (
     }
 
     try {
-      const response = await fetch(input.url, {
+      const response = await fetchImpl(input.url, {
         method: input.method.toUpperCase(),
         ...(body && { body }),
         headers,
@@ -114,6 +129,7 @@ export const buildApiFetcher: (
           throw new ApiRequestError(
             response.status,
             JSON.stringify(errorResponse),
+            errorResponse,
           );
         }
       }
@@ -128,6 +144,7 @@ export const buildApiFetcher: (
         throw new ApiRequestError(
           response.status,
           JSON.stringify(errorResponse),
+          errorResponse,
         );
       }
 
diff --git a/packages/api-client/src/index.ts b/packages/api-client/src/index.ts
index e6b7c3c639..a18d6ff4b0 100644
--- a/packages/api-client/src/index.ts
+++ b/packages/api-client/src/index.ts
@@ -1,6 +1,10 @@
 import "./generated.augment";
 
-export { type ApiFetcherConfig, buildApiFetcher } from "./fetcher";
+export {
+  type ApiFetcherConfig,
+  buildApiFetcher,
+  type FetchImplementation,
+} from "./fetcher";
 export { createApiClient, type Schemas } from "./generated";
 export {
   createLoop,
diff --git a/packages/api-client/src/posthog-client.automations.test.ts b/packages/api-client/src/posthog-client.automations.test.ts
new file mode 100644
index 0000000000..3d3386ef3a
--- /dev/null
+++ b/packages/api-client/src/posthog-client.automations.test.ts
@@ -0,0 +1,192 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import {
+  PostHogAPIClient,
+  TaskAutomationValidationError,
+} from "./posthog-client";
+
+const automationPayload = {
+  id: "automation-1",
+  name: "Daily PRs",
+  prompt: "Check PRs",
+  repository: "posthog/posthog",
+  github_integration: 7,
+  cron_expression: "0 9 * * *",
+  timezone: "Europe/London",
+  template_id: "llm-skill:daily-prs",
+  enabled: true,
+  last_run_at: null,
+  last_run_status: null,
+  last_task_id: null,
+  last_task_run_id: null,
+  last_error: null,
+  created_at: "2026-07-21T00:00:00Z",
+  updated_at: "2026-07-21T00:00:00Z",
+};
+
+function jsonResponse(body: unknown, status = 200): Response {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { "Content-Type": "application/json" },
+  });
+}
+
+describe("PostHogAPIClient task automations", () => {
+  const fetch = vi.fn();
+  const client = new PostHogAPIClient(
+    "https://app.posthog.test",
+    async () => "access-token",
+    async () => "refreshed-token",
+    42,
+    { appVersion: "test", fetch },
+  );
+
+  beforeEach(() => {
+    fetch.mockReset();
+  });
+
+  it("lists automations and normalizes optional response fields", async () => {
+    const minimalPayload = {
+      ...automationPayload,
+      github_integration: undefined,
+      timezone: undefined,
+      template_id: undefined,
+      enabled: undefined,
+    };
+    fetch.mockResolvedValueOnce(
+      jsonResponse({
+        count: 1,
+        next: null,
+        previous: null,
+        results: [minimalPayload],
+      }),
+    );
+
+    await expect(client.listTaskAutomations()).resolves.toEqual([
+      expect.objectContaining({
+        id: "automation-1",
+        github_integration: null,
+        timezone: null,
+        template_id: null,
+        enabled: true,
+      }),
+    ]);
+    expect(fetch).toHaveBeenCalledWith(
+      new URL(
+        "https://app.posthog.test/api/projects/42/task_automations/?limit=500",
+      ),
+      expect.objectContaining({ method: "GET" }),
+    );
+  });
+
+  it("gets and creates automations through generated endpoints", async () => {
+    fetch
+      .mockResolvedValueOnce(jsonResponse(automationPayload))
+      .mockResolvedValueOnce(jsonResponse(automationPayload, 201));
+
+    await expect(client.getTaskAutomation("automation-1")).resolves.toEqual(
+      automationPayload,
+    );
+    await expect(
+      client.createTaskAutomation({
+        name: "Daily PRs",
+        prompt: "Check PRs",
+        repository: "posthog/posthog",
+        github_integration: 7,
+        cron_expression: "0 9 * * *",
+        timezone: "Europe/London",
+        template_id: "llm-skill:daily-prs",
+        enabled: true,
+      }),
+    ).resolves.toEqual(automationPayload);
+
+    expect(fetch).toHaveBeenNthCalledWith(
+      2,
+      new URL("https://app.posthog.test/api/projects/42/task_automations/"),
+      expect.objectContaining({
+        method: "POST",
+        body: JSON.stringify({
+          name: "Daily PRs",
+          prompt: "Check PRs",
+          repository: "posthog/posthog",
+          github_integration: 7,
+          cron_expression: "0 9 * * *",
+          timezone: "Europe/London",
+          template_id: "llm-skill:daily-prs",
+          enabled: true,
+        }),
+      }),
+    );
+  });
+
+  it("updates, deletes, and runs automations", async () => {
+    fetch
+      .mockResolvedValueOnce(
+        jsonResponse({ ...automationPayload, enabled: false }),
+      )
+      .mockResolvedValueOnce(new Response(null, { status: 204 }))
+      .mockResolvedValueOnce(jsonResponse(automationPayload));
+
+    await expect(
+      client.updateTaskAutomation("automation-1", { enabled: false }),
+    ).resolves.toMatchObject({ enabled: false });
+    await expect(
+      client.deleteTaskAutomation("automation-1"),
+    ).resolves.toBeUndefined();
+    await expect(client.runTaskAutomation("automation-1")).resolves.toEqual(
+      automationPayload,
+    );
+
+    expect(fetch).toHaveBeenNthCalledWith(
+      1,
+      new URL(
+        "https://app.posthog.test/api/projects/42/task_automations/automation-1/",
+      ),
+      expect.objectContaining({
+        method: "PATCH",
+        body: JSON.stringify({ enabled: false }),
+      }),
+    );
+    expect(fetch).toHaveBeenNthCalledWith(
+      3,
+      new URL(
+        "https://app.posthog.test/api/projects/42/task_automations/automation-1/run/",
+      ),
+      expect.objectContaining({ method: "POST" }),
+    );
+    expect(fetch.mock.calls[2]?.[1]?.body).toBeUndefined();
+  });
+
+  it("preserves validation detail, code, and field attribution", async () => {
+    fetch.mockResolvedValueOnce(
+      new Response(
+        JSON.stringify({
+          type: "validation_error",
+          code: "invalid_input",
+          detail: "Enter a valid cron expression.",
+          attr: "cron_expression",
+        }),
+        {
+          status: 400,
+          statusText: "Bad Request",
+          headers: { "Content-Type": "application/json" },
+        },
+      ),
+    );
+
+    const request = client.createTaskAutomation({
+      name: "Daily PRs",
+      prompt: "Check PRs",
+      repository: "posthog/posthog",
+      cron_expression: "not a cron",
+      timezone: "Europe/London",
+    });
+
+    await expect(request).rejects.toBeInstanceOf(TaskAutomationValidationError);
+    await expect(request).rejects.toMatchObject({
+      status: 400,
+      code: "invalid_input",
+      attr: "cron_expression",
+      message: "Enter a valid cron expression.",
+    });
+  });
+});
diff --git a/packages/api-client/src/posthog-client.test.ts b/packages/api-client/src/posthog-client.test.ts
index 42a36681cb..da93bc7960 100644
--- a/packages/api-client/src/posthog-client.test.ts
+++ b/packages/api-client/src/posthog-client.test.ts
@@ -1,8 +1,337 @@
 import { describe, expect, it, vi } from "vitest";
 import { ApiRequestError } from "./fetcher";
-import { PostHogAPIClient } from "./posthog-client";
+import { CloudCommandError, PostHogAPIClient } from "./posthog-client";
 
 describe("PostHogAPIClient", () => {
+  it.each([
+    "user_message",
+    "permission_response",
+    "set_config_option",
+    "cancel",
+  ] as const)("sends the %s cloud run command", async (method) => {
+    const fetch = vi.fn().mockResolvedValue(
+      new Response(JSON.stringify({ result: { accepted: true } }), {
+        status: 200,
+      }),
+    );
+    const client = new PostHogAPIClient(
+      "https://app.posthog.test",
+      async () => "token",
+      async () => "token",
+      42,
+      { fetch },
+    );
+
+    await expect(
+      client.sendCloudRunCommand("task-1", "run-1", method, {
+        value: "payload",
+      }),
+    ).resolves.toEqual({ accepted: true });
+
+    expect(fetch).toHaveBeenCalledWith(
+      new URL(
+        "https://app.posthog.test/api/projects/42/tasks/task-1/runs/run-1/command/",
+      ),
+      expect.objectContaining({
+        method: "POST",
+        body: expect.any(String),
+      }),
+    );
+    const request = fetch.mock.calls[0][1] as RequestInit;
+    expect(JSON.parse(request.body as string)).toMatchObject({
+      jsonrpc: "2.0",
+      method,
+      params: { value: "payload" },
+    });
+  });
+
+  it("throws structured cloud command errors for HTTP failures", async () => {
+    const fetch = vi.fn().mockResolvedValue(
+      new Response(
+        JSON.stringify({ error: "No active sandbox for this run" }),
+        {
+          status: 409,
+          statusText: "Conflict",
+        },
+      ),
+    );
+    const client = new PostHogAPIClient(
+      "https://app.posthog.test",
+      async () => "token",
+      async () => "token",
+      42,
+      { fetch },
+    );
+
+    const error = await client
+      .sendCloudRunCommand("task-1", "run-1", "user_message")
+      .catch((caught: unknown) => caught);
+
+    expect(error).toMatchObject({
+      name: "CloudCommandError",
+      method: "user_message",
+      status: 409,
+      backendError: "No active sandbox for this run",
+    });
+    expect(error).toBeInstanceOf(CloudCommandError);
+    expect((error as CloudCommandError).isSandboxInactive()).toBe(true);
+  });
+
+  it("throws structured cloud command errors for JSON-RPC failures", async () => {
+    const fetch = vi
+      .fn()
+      .mockResolvedValue(
+        new Response(
+          JSON.stringify({ error: { message: "Permission request expired" } }),
+          { status: 200 },
+        ),
+      );
+    const client = new PostHogAPIClient(
+      "https://app.posthog.test",
+      async () => "token",
+      async () => "token",
+      42,
+      { fetch },
+    );
+
+    await expect(
+      client.sendCloudRunCommand("task-1", "run-1", "permission_response"),
+    ).rejects.toMatchObject({
+      method: "permission_response",
+      status: 200,
+      backendError: "Permission request expired",
+    });
+  });
+
+  it("preserves the legacy sendRunCommand result contract", async () => {
+    const fetch = vi.fn().mockResolvedValue(
+      new Response(JSON.stringify({ error: "Run is unavailable" }), {
+        status: 503,
+      }),
+    );
+    const client = new PostHogAPIClient(
+      "https://app.posthog.test",
+      async () => "token",
+      async () => "token",
+      42,
+      { fetch },
+    );
+
+    await expect(
+      client.sendRunCommand("task-1", "run-1", "set_config_option"),
+    ).resolves.toEqual({
+      success: false,
+      error: "Cloud command 'set_config_option' failed: 503 Run is unavailable",
+    });
+  });
+
+  it("cancels a cloud task run with an optional reason", async () => {
+    const fetch = vi
+      .fn()
+      .mockResolvedValue(
+        new Response(JSON.stringify({ status: "cancelled" }), { status: 200 }),
+      );
+    const client = new PostHogAPIClient(
+      "https://app.posthog.test",
+      async () => "token",
+      async () => "token",
+      42,
+      { fetch },
+    );
+
+    await expect(
+      client.cancelTaskRun("task-1", "run-1", "user requested"),
+    ).resolves.toEqual({ status: "cancelled" });
+
+    expect(fetch).toHaveBeenCalledWith(
+      new URL(
+        "https://app.posthog.test/api/projects/42/tasks/task-1/runs/run-1/cancel/",
+      ),
+      expect.objectContaining({
+        method: "POST",
+        body: JSON.stringify({ reason: "user requested" }),
+      }),
+    );
+  });
+
+  it("cancels a cloud task run with an empty body by default", async () => {
+    const fetch = vi
+      .fn()
+      .mockResolvedValue(new Response(null, { status: 204 }));
+    const client = new PostHogAPIClient(
+      "https://app.posthog.test",
+      async () => "token",
+      async () => "token",
+      42,
+      { fetch },
+    );
+
+    await expect(client.cancelTaskRun("task-1", "run-1")).resolves.toEqual({});
+
+    const request = fetch.mock.calls[0][1] as RequestInit;
+    expect(request.body).toBe(JSON.stringify({}));
+  });
+
+  it("builds cloud task config from the authenticated gateway catalog", async () => {
+    const fetch = vi.fn().mockResolvedValue(
+      new Response(
+        JSON.stringify({
+          data: [
+            {
+              id: "claude-opus-4-8",
+              owned_by: "anthropic",
+              context_window: 200000,
+              supports_streaming: true,
+              supports_vision: true,
+              allowed: true,
+            },
+            {
+              id: "claude-fable-5",
+              owned_by: "anthropic",
+              context_window: 200000,
+              supports_streaming: true,
+              supports_vision: true,
+              allowed: false,
+            },
+          ],
+        }),
+        { status: 200, headers: { "Content-Type": "application/json" } },
+      ),
+    );
+    const client = new PostHogAPIClient(
+      "https://eu.posthog.com",
+      async () => "token",
+      async () => "token",
+      123,
+      { fetch },
+    );
+
+    const options = await client.getCloudTaskConfigOptions("claude");
+
+    expect(fetch).toHaveBeenCalledWith(
+      new URL("https://gateway.eu.posthog.com/posthog_code/v1/models"),
+      expect.objectContaining({ method: "GET" }),
+    );
+    expect(options.find((option) => option.category === "model")).toMatchObject(
+      {
+        currentValue: "claude-opus-4-8",
+        options: [
+          expect.objectContaining({ value: "claude-opus-4-8" }),
+          expect.objectContaining({
+            value: "claude-fable-5",
+            _meta: expect.any(Object),
+          }),
+        ],
+      },
+    );
+  });
+
+  it("uses the configured fetch implementation for task log URLs", async () => {
+    const fetch = vi
+      .fn()
+      .mockResolvedValue(
+        new Response(
+          '{"type":"notification","timestamp":"2026-07-21T00:00:00Z"}\n',
+          { status: 200 },
+        ),
+      );
+    const client = new PostHogAPIClient(
+      "http://localhost:8000",
+      async () => "token",
+      async () => "token",
+      123,
+      { fetch },
+    );
+    vi.spyOn(client, "getTask").mockResolvedValue({
+      id: "task-1",
+      task_number: 1,
+      slug: "task-1",
+      title: "Task",
+      description: "Task",
+      created_at: "2026-07-21T00:00:00Z",
+      updated_at: "2026-07-21T00:00:00Z",
+      origin_product: "user_created",
+      latest_run: {
+        id: "run-1",
+        task: "task-1",
+        team: 123,
+        branch: null,
+        status: "in_progress",
+        log_url: "https://logs.posthog.test/run-1.jsonl",
+        error_message: null,
+        output: null,
+        state: {},
+        created_at: "2026-07-21T00:00:00Z",
+        updated_at: "2026-07-21T00:00:00Z",
+        completed_at: null,
+      },
+    });
+
+    await expect(client.getTaskLogs("task-1")).resolves.toHaveLength(1);
+    expect(fetch).toHaveBeenCalledWith("https://logs.posthog.test/run-1.jsonl");
+  });
+
+  it.each([
+    {
+      label: "desktop default",
+      options: undefined,
+      expectedConnectFrom: "posthog_code",
+      expectedUserAgent: "posthog/desktop.hog.dev; version: unknown",
+    },
+    {
+      label: "mobile configuration",
+      options: {
+        appVersion: "1.2.3",
+        userAgent: "posthog/mobile; version: 1.2.3",
+        githubConnectFrom: "posthog_mobile",
+      },
+      expectedConnectFrom: "posthog_mobile",
+      expectedUserAgent: "posthog/mobile; version: 1.2.3",
+    },
+  ])(
+    "uses $label identity for GitHub connections",
+    async ({ options, expectedConnectFrom, expectedUserAgent }) => {
+      const fetch = vi.fn().mockResolvedValue(
+        new Response(
+          JSON.stringify({ install_url: "https://github.com/login/oauth" }),
+          {
+            status: 200,
+            headers: { "Content-Type": "application/json" },
+          },
+        ),
+      );
+      const client = new PostHogAPIClient(
+        "http://localhost:8000",
+        async () => "token",
+        async () => "token",
+        123,
+        { ...options, fetch },
+      );
+
+      await expect(client.startGithubUserIntegrationConnect()).resolves.toEqual(
+        {
+          install_url: "https://github.com/login/oauth",
+        },
+      );
+
+      expect(fetch).toHaveBeenCalledWith(
+        new URL(
+          "http://localhost:8000/api/users/@me/integrations/github/start/",
+        ),
+        expect.objectContaining({
+          method: "POST",
+          body: JSON.stringify({
+            team_id: 123,
+            connect_from: expectedConnectFrom,
+          }),
+        }),
+      );
+      expect(fetch.mock.calls[0][1].headers.get("User-Agent")).toBe(
+        expectedUserAgent,
+      );
+    },
+  );
+
   it("sends supported reasoning effort for cloud Codex runs", async () => {
     const client = new PostHogAPIClient(
       "http://localhost:8000",
@@ -257,7 +586,13 @@ describe("PostHogAPIClient", () => {
         reasoningLevel: "high",
         initialPermissionMode: "auto",
       }),
-    ).resolves.toEqual({ id: "run-123", environment: "cloud" });
+    ).resolves.toMatchObject({
+      id: "run-123",
+      task: "task-123",
+      team: 123,
+      environment: "cloud",
+      status: "not_started",
+    });
 
     expect(fetch).toHaveBeenCalledWith(
       expect.objectContaining({
@@ -435,7 +770,15 @@ describe("PostHogAPIClient", () => {
         pendingUserMessage: "Read the attached file first",
         pendingUserArtifactIds: ["artifact-1"],
       }),
-    ).resolves.toEqual({ id: "task-123", latest_run: { id: "run-123" } });
+    ).resolves.toMatchObject({
+      id: "task-123",
+      latest_run: {
+        id: "run-123",
+        task: "task-123",
+        team: 123,
+        status: "not_started",
+      },
+    });
 
     expect(fetch).toHaveBeenCalledWith(
       expect.objectContaining({
diff --git a/packages/api-client/src/posthog-client.ts b/packages/api-client/src/posthog-client.ts
index b14ddcaa08..baf7bc3df8 100644
--- a/packages/api-client/src/posthog-client.ts
+++ b/packages/api-client/src/posthog-client.ts
@@ -4,18 +4,30 @@ import type {
   CloudMcpServerImport,
   CloudMcpServerRelayDesignation,
   CloudRunSource,
+  CreateTaskAutomationOptions,
   ExecutionMode,
   PrAuthorshipMode,
   SourceProduct,
   SourceType,
   StoredLogEntry,
+  TaskAutomation,
   TaskRunArtifactMetadata,
+  UpdateTaskAutomationOptions,
 } from "@posthog/shared";
 import {
+  buildCloudTaskConfigOptions,
+  type CloudTaskConfigOption,
+  createTaskAutomationSchema,
   DISMISSAL_REASON_OPTIONS,
   type DismissalReasonOptionValue,
+  getCloudTaskGatewayUrl,
   isSupportedReasoningEffort,
+  normalizeGatewayModelsResponse,
   resolveCloudInitialPermissionMode,
+  taskAutomationListSchema,
+  taskAutomationSchema,
+  taskAutomationValidationErrorSchema,
+  updateTaskAutomationSchema,
 } from "@posthog/shared";
 import type {
   AgentAnalyticsData,
@@ -98,9 +110,18 @@ import {
   type HogQLGrid,
   shapeAgentAnalytics,
 } from "./agent-analytics";
-import { buildApiFetcher, requestErrorStatus } from "./fetcher";
+import {
+  ApiRequestError,
+  buildApiFetcher,
+  type FetchImplementation,
+  requestErrorStatus,
+} from "./fetcher";
 import { createApiClient, type Schemas } from "./generated";
 import type { SpendAnalysisResponse } from "./spend-analysis";
+import {
+  normalizeTaskResponse,
+  normalizeTaskRunResponse,
+} from "./task-normalization";
 export interface ApiClientLogger {
   warn(...args: unknown[]): void;
 }
@@ -119,6 +140,13 @@ export function setPosthogApiClientAppVersion(version: string): void {
   clientAppVersion = version;
 }
 
+export interface PostHogAPIClientOptions {
+  fetch?: FetchImplementation;
+  appVersion?: string;
+  userAgent?: string | null;
+  githubConnectFrom?: string;
+}
+
 export function getPosthogApiClientAppVersion(): string {
   return clientAppVersion;
 }
@@ -160,6 +188,36 @@ export class CloudUsageLimitError extends Error {
   }
 }
 
+export class TaskAutomationValidationError extends Error {
+  readonly status = 400;
+  readonly code: string;
+  readonly attr: string | null;
+
+  constructor(details: {
+    detail: string;
+    code: string;
+    attr: string | null;
+  }) {
+    super(details.detail);
+    this.name = "TaskAutomationValidationError";
+    this.code = details.code;
+    this.attr = details.attr;
+  }
+}
+
+function rethrowTaskAutomationError(error: unknown): never {
+  if (error instanceof ApiRequestError && error.status === 400) {
+    const validationError = taskAutomationValidationErrorSchema.safeParse(
+      error.body,
+    );
+    if (validationError.success) {
+      throw new TaskAutomationValidationError(validationError.data);
+    }
+  }
+
+  throw error;
+}
+
 export const MCP_CATEGORIES = [
   { id: "all", label: "All" },
   { id: "business", label: "Business Operations" },
@@ -578,7 +636,7 @@ export interface FinalizedTaskArtifactUpload {
   uploaded_at?: string;
 }
 
-interface CloudRunOptions {
+export interface CloudRunOptions {
   adapter?: Adapter;
   model?: string;
   reasoningLevel?: string;
@@ -599,6 +657,56 @@ interface CloudRunOptions {
   relayedMcpServers?: CloudMcpServerRelayDesignation[];
 }
 
+export type CloudRunCommandMethod =
+  | "user_message"
+  | "permission_response"
+  | "set_config_option"
+  | "cancel"
+  | "close";
+
+export class CloudCommandError extends Error {
+  readonly status: number;
+  readonly backendError: string | null;
+  readonly method: CloudRunCommandMethod;
+
+  constructor(
+    method: CloudRunCommandMethod,
+    status: number,
+    backendError: string | null,
+    message: string,
+  ) {
+    super(message);
+    this.name = "CloudCommandError";
+    this.method = method;
+    this.status = status;
+    this.backendError = backendError;
+  }
+
+  isSandboxInactive(): boolean {
+    const backendError = this.backendError?.toLowerCase();
+    return (
+      this.status === 404 ||
+      backendError?.includes("no active sandbox") === true ||
+      backendError?.includes("returned 404") === true
+    );
+  }
+}
+
+function cloudCommandBackendError(payload: unknown): string | null {
+  if (typeof payload === "string") return payload || null;
+  if (!payload || typeof payload !== "object") return null;
+
+  const error = "error" in payload ? payload.error : null;
+  if (typeof error === "string") return error || null;
+  if (error && typeof error === "object" && "message" in error) {
+    return typeof error.message === "string" ? error.message : null;
+  }
+  if ("message" in payload && typeof payload.message === "string") {
+    return payload.message;
+  }
+  return null;
+}
+
 interface CreateTaskRunOptions extends CloudRunOptions {
   environment?: "local" | "cloud";
   mode?: "interactive" | "background";
@@ -1339,19 +1447,28 @@ function previewTokenHeader(
 export class PostHogAPIClient {
   private api: ReturnType<typeof createApiClient>;
   private _teamId: number | null = null;
+  private githubConnectFrom: string;
+  private readonly fetch: FetchImplementation;
+  private readonly apiHost: string;
 
   constructor(
     apiHost: string,
     getAccessToken: () => Promise<string>,
     refreshAccessToken: () => Promise<string>,
     teamId?: number,
+    options: PostHogAPIClientOptions = {},
   ) {
     const baseUrl = apiHost.endsWith("/") ? apiHost.slice(0, -1) : apiHost;
+    this.apiHost = baseUrl;
+    this.githubConnectFrom = options.githubConnectFrom ?? "posthog_code";
+    this.fetch = options.fetch ?? globalThis.fetch.bind(globalThis);
     this.api = createApiClient(
       buildApiFetcher({
         getAccessToken,
         refreshAccessToken,
-        appVersion: clientAppVersion,
+        appVersion: options.appVersion ?? clientAppVersion,
+        fetch: options.fetch,
+        userAgent: options.userAgent,
       }),
       baseUrl,
     );
@@ -1388,6 +1505,21 @@ export class PostHogAPIClient {
     return data;
   }
 
+  async getCloudTaskConfigOptions(
+    adapter: Adapter = "claude",
+  ): Promise<CloudTaskConfigOption[]> {
+    const url = new URL(`${getCloudTaskGatewayUrl(this.apiHost)}/v1/models`);
+    const response = await this.api.fetcher.fetch({
+      method: "get",
+      url,
+      path: url.pathname,
+    });
+    return buildCloudTaskConfigOptions(
+      normalizeGatewayModelsResponse(await response.json()),
+      adapter,
+    );
+  }
+
   // Desktop file system — the backend surface that backs canvas channels
   // (top-level folders) and dashboards. These routes aren't in the generated
   // OpenAPI client, so we use the raw fetcher.
@@ -1752,7 +1884,10 @@ export class PostHogAPIClient {
       url,
       path: urlPath,
       overrides: {
-        body: JSON.stringify({ team_id: id, connect_from: "posthog_code" }),
+        body: JSON.stringify({
+          team_id: id,
+          connect_from: this.githubConnectFrom,
+        }),
       },
     });
     if (!response.ok) {
@@ -2254,7 +2389,7 @@ export class PostHogAPIClient {
     originProduct?: string;
     internal?: boolean;
     channel?: string;
-  }) {
+  }): Promise<Task[]> {
     const teamId = await this.getTeamId();
     const params: Record<string, string | number | boolean> = {
       limit: 500,
@@ -2285,7 +2420,9 @@ export class PostHogAPIClient {
       query: params,
     });
 
-    return data.results ?? [];
+    return (data.results ?? []).map((task) =>
+      normalizeTaskResponse(task, { teamId }),
+    );
   }
 
   async getTaskSummaries(ids: string[]) {
@@ -2327,7 +2464,102 @@ export class PostHogAPIClient {
     const data = await this.api.get(`/api/projects/{project_id}/tasks/{id}/`, {
       path: { project_id: teamId.toString(), id: taskId },
     });
-    return data as unknown as Task;
+    return normalizeTaskResponse(data, { teamId });
+  }
+
+  async listTaskAutomations(options?: {
+    limit?: number;
+    offset?: number;
+  }): Promise<TaskAutomation[]> {
+    const teamId = await this.getTeamId();
+    const data = await this.api.get(
+      `/api/projects/{project_id}/task_automations/`,
+      {
+        path: { project_id: teamId.toString() },
+        query: {
+          limit: options?.limit ?? 500,
+          ...(options?.offset === undefined ? {} : { offset: options.offset }),
+        },
+      },
+    );
+
+    return taskAutomationListSchema.parse(data).results;
+  }
+
+  async getTaskAutomation(automationId: string): Promise<TaskAutomation> {
+    const teamId = await this.getTeamId();
+    const data = await this.api.get(
+      `/api/projects/{project_id}/task_automations/{id}/`,
+      {
+        path: { project_id: teamId.toString(), id: automationId },
+      },
+    );
+
+    return taskAutomationSchema.parse(data);
+  }
+
+  async createTaskAutomation(
+    options: CreateTaskAutomationOptions,
+  ): Promise<TaskAutomation> {
+    const teamId = await this.getTeamId();
+    const body = createTaskAutomationSchema.parse(options);
+
+    try {
+      const data = await this.api.post(
+        `/api/projects/{project_id}/task_automations/`,
+        {
+          path: { project_id: teamId.toString() },
+          body: body as Schemas.TaskAutomation,
+        },
+      );
+      return taskAutomationSchema.parse(data);
+    } catch (error) {
+      rethrowTaskAutomationError(error);
+    }
+  }
+
+  async updateTaskAutomation(
+    automationId: string,
+    updates: UpdateTaskAutomationOptions,
+  ): Promise<TaskAutomation> {
+    const teamId = await this.getTeamId();
+    const body = updateTaskAutomationSchema.parse(updates);
+
+    try {
+      const data = await this.api.patch(
+        `/api/projects/{project_id}/task_automations/{id}/`,
+        {
+          path: { project_id: teamId.toString(), id: automationId },
+          body,
+        },
+      );
+      return taskAutomationSchema.parse(data);
+    } catch (error) {
+      rethrowTaskAutomationError(error);
+    }
+  }
+
+  async deleteTaskAutomation(automationId: string): Promise<void> {
+    const teamId = await this.getTeamId();
+    await this.api.delete(`/api/projects/{project_id}/task_automations/{id}/`, {
+      path: { project_id: teamId.toString(), id: automationId },
+    });
+  }
+
+  async runTaskAutomation(automationId: string): Promise<TaskAutomation> {
+    const teamId = await this.getTeamId();
+    const path = `/api/projects/${teamId}/task_automations/${automationId}/run/`;
+
+    try {
+      const response = await this.api.fetcher.fetch({
+        method: "post",
+        path,
+        url: new URL(`${this.api.baseUrl}${path}`),
+      });
+      return taskAutomationSchema.parse(await response.json());
+    } catch (error) {
+      rethrowTaskAutomationError(error);
+    }
   }
 
   async createTask(
@@ -2354,7 +2586,7 @@ export class PostHogAPIClient {
         pending_user_artifact_ids?: string[];
         auto_publish?: boolean;
       },
-  ) {
+  ): Promise<Task> {
     const teamId = await this.getTeamId();
     const { origin_product: originProduct, ...taskOptions } = options;
 
@@ -2366,10 +2598,13 @@ export class PostHogAPIClient {
       } as unknown as Schemas.Task,
     });
 
-    return data;
+    return normalizeTaskResponse(data, { teamId });
   }
 
-  async updateTask(taskId: string, updates: Partial<Schemas.Task>) {
+  async updateTask(
+    taskId: string,
+    updates: Partial<Schemas.Task>,
+  ): Promise<Task> {
     const teamId = await this.getTeamId();
     const data = await this.api.patch(
       `/api/projects/{project_id}/tasks/{id}/`,
@@ -2379,7 +2614,7 @@ export class PostHogAPIClient {
       },
     );
 
-    return data;
+    return normalizeTaskResponse(data, { teamId });
   }
 
   async deleteTask(taskId: string) {
@@ -2631,9 +2866,28 @@ export class PostHogAPIClient {
   async sendRunCommand(
     taskId: string,
     runId: string,
-    method: "user_message" | "cancel" | "close",
+    method: CloudRunCommandMethod,
     params?: Record<string, unknown>,
   ): Promise<{ success: boolean; result?: unknown; error?: string }> {
+    try {
+      return {
+        success: true,
+        result: await this.sendCloudRunCommand(taskId, runId, method, params),
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error",
+      };
+    }
+  }
+
+  async sendCloudRunCommand(
+    taskId: string,
+    runId: string,
+    method: CloudRunCommandMethod,
+    params: Record<string, unknown> = {},
+  ): Promise<unknown> {
     const teamId = await this.getTeamId();
     const url = new URL(
       `${this.api.baseUrl}/api/projects/${teamId}/tasks/${taskId}/runs/${runId}/command/`,
@@ -2641,7 +2895,7 @@ export class PostHogAPIClient {
     const body = {
       jsonrpc: "2.0",
       method,
-      params: params ?? {},
+      params,
       id: `posthog-code-${Date.now()}`,
     };
 
@@ -2655,39 +2909,54 @@ export class PostHogAPIClient {
         },
       });
 
-      if (!response.ok) {
-        const errorText = await response.text().catch(() => "");
-        let errorMessage = `Command failed: ${response.statusText}`;
-        try {
-          const errorJson = JSON.parse(errorText);
-          errorMessage =
-            errorJson.error?.message ?? errorJson.error ?? errorMessage;
-        } catch {
-          if (errorText) errorMessage = errorText;
-        }
-        return { success: false, error: errorMessage };
-      }
-
       const data = (await response.json()) as {
-        error?: { message?: string };
+        error?: unknown;
         result?: unknown;
       };
       if (data.error) {
-        return {
-          success: false,
-          error: data.error.message ?? JSON.stringify(data.error),
-        };
+        const backendError = cloudCommandBackendError(data);
+        throw new CloudCommandError(
+          method,
+          response.status,
+          backendError,
+          `Cloud command '${method}' error: ${backendError ?? JSON.stringify(data.error)}`,
+        );
       }
 
-      return { success: true, result: data.result };
+      return data.result;
     } catch (error) {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : "Unknown error",
-      };
+      if (error instanceof CloudCommandError) throw error;
+      if (error instanceof ApiRequestError) {
+        const backendError = cloudCommandBackendError(error.body);
+        throw new CloudCommandError(
+          method,
+          error.status,
+          backendError,
+          `Cloud command '${method}' failed: ${error.status}${backendError ? ` ${backendError}` : ""}`,
+        );
+      }
+      throw error;
     }
   }
 
+  async cancelTaskRun(
+    taskId: string,
+    runId: string,
+    reason?: string,
+  ): Promise<{ status?: string }> {
+    const teamId = await this.getTeamId();
+    const path = `/api/projects/${teamId}/tasks/${taskId}/runs/${runId}/cancel/`;
+    const response = await this.api.fetcher.fetch({
+      method: "post",
+      url: new URL(`${this.api.baseUrl}${path}`),
+      path,
+      overrides: {
+        body: JSON.stringify(reason ? { reason } : {}),
+      },
+    });
+    return (await response.json().catch(() => ({}))) as { status?: string };
+  }
+
   async runTaskInCloud(
     taskId: string,
     branch?: string | null,
@@ -2711,7 +2980,7 @@ export class PostHogAPIClient {
       }),
     );
 
-    return data as unknown as Task;
+    return normalizeTaskResponse(data, { teamId });
   }
 
   async warmTask(options: {
@@ -2951,7 +3220,8 @@ export class PostHogAPIClient {
       throw new Error(`Failed to resume run in cloud: ${response.statusText}`);
     }
 
-    return (await response.json()) as TaskRun;
+    const data = (await response.json()) as Schemas.TaskRunDetail;
+    return normalizeTaskRunResponse(data, { teamId, taskId });
   }
 
   async listTaskRuns(taskId: string): Promise<TaskRun[]> {
@@ -2969,8 +3239,11 @@ export class PostHogAPIClient {
       throw new Error(`Failed to fetch task runs: ${response.statusText}`);
     }
 
-    const data = (await response.json()) as { results?: TaskRun[] };
-    return data.results ?? [];
+    const data =
+      (await response.json()) as Partial<Schemas.PaginatedTaskRunDetailList>;
+    return (data.results ?? []).map((run) =>
+      normalizeTaskRunResponse(run, { teamId, taskId }),
+    );
   }
 
   async getTaskRun(taskId: string, runId: string): Promise<TaskRun> {
@@ -2988,7 +3261,8 @@ export class PostHogAPIClient {
       throw new Error(`Failed to fetch task run: ${response.statusText}`);
     }
 
-    return (await response.json()) as TaskRun;
+    const data = (await response.json()) as Schemas.TaskRunDetail;
+    return normalizeTaskRunResponse(data, { teamId, taskId });
   }
 
   async createTaskRun(
@@ -3020,7 +3294,8 @@ export class PostHogAPIClient {
       throw new Error(`Failed to create task run: ${response.statusText}`);
     }
 
-    return (await response.json()) as TaskRun;
+    const data = (await response.json()) as Schemas.TaskRunDetail;
+    return normalizeTaskRunResponse(data, { teamId, taskId });
   }
 
   async startTaskRun(
@@ -3050,7 +3325,8 @@ export class PostHogAPIClient {
       throw new Error(`Failed to start task run: ${response.statusText}`);
     }
 
-    return (await response.json()) as Task;
+    const data = (await response.json()) as Schemas.Task;
+    return normalizeTaskResponse(data, { teamId });
   }
 
   async updateTaskRun(
@@ -3075,7 +3351,7 @@ export class PostHogAPIClient {
         body: updates as Record<string, unknown>,
       },
     );
-    return data as unknown as TaskRun;
+    return normalizeTaskRunResponse(data, { teamId, taskId });
   }
 
   /**
@@ -3165,14 +3441,14 @@ export class PostHogAPIClient {
 
   async getTaskLogs(taskId: string): Promise<StoredLogEntry[]> {
     try {
-      const task = (await this.getTask(taskId)) as unknown as Task;
+      const task = await this.getTask(taskId);
       const logUrl = task?.latest_run?.log_url;
 
       if (!logUrl) {
         return [];
       }
 
-      const response = await fetch(logUrl);
+      const response = await this.fetch(logUrl);
 
       if (!response.ok) {
         log.warn(
diff --git a/packages/api-client/src/task-normalization.test.ts b/packages/api-client/src/task-normalization.test.ts
new file mode 100644
index 0000000000..9c9739a51f
--- /dev/null
+++ b/packages/api-client/src/task-normalization.test.ts
@@ -0,0 +1,115 @@
+import { describe, expect, it } from "vitest";
+import {
+  normalizeTaskResponse,
+  normalizeTaskRunResponse,
+} from "./task-normalization";
+
+describe("task response normalization", () => {
+  it("normalizes legacy started runs and nullable generated fields", () => {
+    expect(
+      normalizeTaskRunResponse(
+        {
+          id: "run-1",
+          task: "task-1",
+          status: "started",
+          branch: null,
+          stage: null,
+          runtime_adapter: null,
+          model: null,
+          reasoning_effort: null,
+          log_url: null,
+          error_message: null,
+          output: null,
+          state: null,
+          artifacts: [
+            {
+              id: "artifact-1",
+              name: "result.txt",
+              type: "legacy_type",
+              storage_path: "tasks/result.txt",
+              uploaded_at: "2026-07-21T00:00:00Z",
+            },
+          ],
+          created_at: "2026-07-21T00:00:00Z",
+          updated_at: "2026-07-21T00:01:00Z",
+          completed_at: null,
+        },
+        { teamId: 123 },
+      ),
+    ).toEqual({
+      id: "run-1",
+      task: "task-1",
+      team: 123,
+      branch: null,
+      stage: null,
+      runtime_adapter: null,
+      model: null,
+      reasoning_effort: null,
+      status: "in_progress",
+      log_url: "",
+      error_message: null,
+      output: null,
+      state: {},
+      artifacts: [
+        {
+          id: "artifact-1",
+          name: "result.txt",
+          type: "artifact",
+          storage_path: "tasks/result.txt",
+          uploaded_at: "2026-07-21T00:00:00Z",
+        },
+      ],
+      created_at: "2026-07-21T00:00:00Z",
+      updated_at: "2026-07-21T00:01:00Z",
+      completed_at: null,
+    });
+  });
+
+  it("normalizes task responses and their generated latest-run records", () => {
+    expect(
+      normalizeTaskResponse(
+        {
+          id: "task-1",
+          task_number: null,
+          slug: "task-1",
+          repository: null,
+          github_integration: null,
+          github_user_integration: null,
+          json_schema: null,
+          signal_report: null,
+          channel: null,
+          latest_run: {
+            id: "run-1",
+            status: "started",
+            log_url: null,
+          },
+          created_at: "2026-07-21T00:00:00Z",
+          updated_at: "2026-07-21T00:01:00Z",
+        },
+        { teamId: 123 },
+      ),
+    ).toMatchObject({
+      id: "task-1",
+      task_number: null,
+      slug: "task-1",
+      title: "",
+      description: "",
+      origin_product: "",
+      repository: null,
+      github_integration: null,
+      github_user_integration: null,
+      json_schema: null,
+      signal_report: null,
+      channel: null,
+      latest_run: {
+        id: "run-1",
+        task: "task-1",
+        team: 123,
+        status: "in_progress",
+        log_url: "",
+        output: null,
+        state: {},
+      },
+    });
+  });
+});
diff --git a/packages/api-client/src/task-normalization.ts b/packages/api-client/src/task-normalization.ts
new file mode 100644
index 0000000000..9571a5b27e
--- /dev/null
+++ b/packages/api-client/src/task-normalization.ts
@@ -0,0 +1,203 @@
+import type {
+  ArtifactType,
+  Task,
+  TaskRun,
+  TaskRunArtifact,
+  TaskRunArtifactMetadata,
+  TaskRunStatus,
+} from "@posthog/shared/domain-types";
+import type { Schemas } from "./generated";
+
+type TaskRunResponseDTO = Partial<
+  Omit<Schemas.TaskRunDetail, "artifacts" | "status">
+> & {
+  id: string;
+  artifacts?: Array<
+    Schemas.TaskRunArtifactResponse & { metadata?: unknown }
+  > | null;
+  status?: Schemas.StatusA35Enum | "started" | null;
+  team?: number | null;
+};
+
+type TaskResponseDTO = Partial<
+  Omit<Schemas.Task, "created_by" | "json_schema" | "latest_run">
+> & {
+  id: string;
+  channel?: string | null;
+  created_by?: Schemas.UserBasic | null;
+  github_user_integration?: string | null;
+  json_schema?: unknown | null;
+  latest_run?: Record<string, unknown> | null;
+  runtime?: unknown;
+};
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function isTaskRunResponseDTO(value: unknown): value is TaskRunResponseDTO {
+  return isRecord(value) && typeof value.id === "string";
+}
+
+function normalizeTaskRunStatus(status: unknown): TaskRunStatus {
+  switch (status) {
+    case "started":
+      return "in_progress";
+    case "not_started":
+    case "queued":
+    case "in_progress":
+    case "completed":
+    case "failed":
+    case "cancelled":
+      return status;
+    default:
+      return "not_started";
+  }
+}
+
+function normalizeArtifactType(type: string): ArtifactType {
+  switch (type) {
+    case "plan":
+    case "context":
+    case "reference":
+    case "output":
+    case "artifact":
+    case "user_attachment":
+    case "skill_bundle":
+      return type;
+    default:
+      return "artifact";
+  }
+}
+
+function normalizeArtifactMetadata(
+  value: unknown,
+): TaskRunArtifactMetadata | undefined {
+  if (
+    !isRecord(value) ||
+    typeof value.skill_name !== "string" ||
+    (value.skill_source !== "user" &&
+      value.skill_source !== "repo" &&
+      value.skill_source !== "marketplace" &&
+      value.skill_source !== "codex")
+  ) {
+    return undefined;
+  }
+  if (
+    typeof value.content_sha256 !== "string" ||
+    value.bundle_format !== "zip" ||
+    typeof value.schema_version !== "number"
+  ) {
+    return undefined;
+  }
+
+  return {
+    skill_name: value.skill_name,
+    skill_source: value.skill_source,
+    content_sha256: value.content_sha256,
+    bundle_format: value.bundle_format,
+    schema_version: value.schema_version,
+  };
+}
+
+function normalizeTaskRunArtifact(
+  artifact: NonNullable<TaskRunResponseDTO["artifacts"]>[number],
+): TaskRunArtifact {
+  const metadata = normalizeArtifactMetadata(artifact.metadata);
+
+  return {
+    ...(artifact.id === undefined ? {} : { id: artifact.id }),
+    name: artifact.name,
+    type: normalizeArtifactType(artifact.type),
+    ...(artifact.source === undefined ? {} : { source: artifact.source }),
+    ...(artifact.size === undefined ? {} : { size: artifact.size }),
+    ...(artifact.content_type === undefined
+      ? {}
+      : { content_type: artifact.content_type }),
+    ...(metadata === undefined ? {} : { metadata }),
+    ...(artifact.storage_path === undefined
+      ? {}
+      : { storage_path: artifact.storage_path }),
+    ...(artifact.uploaded_at === undefined
+      ? {}
+      : { uploaded_at: artifact.uploaded_at }),
+  };
+}
+
+export function normalizeTaskRunResponse(
+  dto: TaskRunResponseDTO,
+  context: { teamId: number; taskId?: string },
+): TaskRun {
+  return {
+    id: dto.id,
+    task: dto.task ?? context.taskId ?? "",
+    team: dto.team ?? context.teamId,
+    branch: dto.branch ?? null,
+    ...(dto.runtime_adapter === undefined
+      ? {}
+      : { runtime_adapter: dto.runtime_adapter }),
+    ...(dto.model === undefined ? {} : { model: dto.model }),
+    ...(dto.reasoning_effort === undefined
+      ? {}
+      : { reasoning_effort: dto.reasoning_effort }),
+    ...(dto.stage === undefined ? {} : { stage: dto.stage }),
+    ...(dto.environment === undefined ? {} : { environment: dto.environment }),
+    status: normalizeTaskRunStatus(dto.status),
+    log_url: dto.log_url ?? "",
+    error_message: dto.error_message ?? null,
+    output: isRecord(dto.output) ? dto.output : null,
+    state: isRecord(dto.state) ? dto.state : {},
+    ...(dto.artifacts == null
+      ? {}
+      : { artifacts: dto.artifacts.map(normalizeTaskRunArtifact) }),
+    created_at: dto.created_at ?? "",
+    updated_at: dto.updated_at ?? "",
+    completed_at: dto.completed_at ?? null,
+  };
+}
+
+export function normalizeTaskResponse(
+  dto: TaskResponseDTO,
+  context: { teamId: number },
+): Task {
+  const jsonSchema = isRecord(dto.json_schema) ? dto.json_schema : null;
+  const runtime =
+    dto.runtime === "acp" || dto.runtime === "pi" ? dto.runtime : undefined;
+
+  const latestRun = isTaskRunResponseDTO(dto.latest_run)
+    ? normalizeTaskRunResponse(dto.latest_run, {
+        teamId: context.teamId,
+        taskId: dto.id,
+      })
+    : undefined;
+
+  return {
+    id: dto.id,
+    task_number: dto.task_number ?? null,
+    slug: dto.slug ?? "",
+    title: dto.title ?? "",
+    ...(dto.title_manually_set === undefined
+      ? {}
+      : { title_manually_set: dto.title_manually_set }),
+    description: dto.description ?? "",
+    created_at: dto.created_at ?? "",
+    updated_at: dto.updated_at ?? "",
+    ...(dto.created_by === undefined ? {} : { created_by: dto.created_by }),
+    origin_product: dto.origin_product ?? "",
+    ...(dto.repository === undefined ? {} : { repository: dto.repository }),
+    ...(dto.github_integration === undefined
+      ? {}
+      : { github_integration: dto.github_integration }),
+    ...(dto.github_user_integration === undefined
+      ? {}
+      : { github_user_integration: dto.github_user_integration }),
+    ...(dto.json_schema === undefined ? {} : { json_schema: jsonSchema }),
+    ...(dto.signal_report === undefined
+      ? {}
+      : { signal_report: dto.signal_report }),
+    ...(dto.internal === undefined ? {} : { internal: dto.internal }),
+    ...(runtime === undefined ? {} : { runtime }),
+    ...(dto.channel === undefined ? {} : { channel: dto.channel }),
+    ...(latestRun === undefined ? {} : { latest_run: latestRun }),
+  };
+}
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 6680b87dd7..467fc54ff3 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -869,9 +869,6 @@ importers:
 
   packages/api-client:
     dependencies:
-      '@posthog/agent':
-        specifier: workspace:*
-        version: link:../agent
       '@posthog/shared':
         specifier: workspace:*
         version: link:../shared
@@ -19205,13 +19202,6 @@ snapshots:
       '@tybys/wasm-util': 0.10.2
     optional: true
 
-  '@napi-rs/wasm-runtime@1.1.6(@emnapi/core@1.10.0)(@emnapi/runtime@1.10.0)':
-    dependencies:
-      '@emnapi/core': 1.10.0
-      '@emnapi/runtime': 1.10.0
-      '@tybys/wasm-util': 0.10.3
-    optional: true
-
   '@napi-rs/wasm-runtime@1.1.6(@emnapi/core@1.11.1)(@emnapi/runtime@1.11.1)':
     dependencies:
       '@emnapi/core': 1.11.1
@@ -22649,7 +22639,7 @@ snapshots:
     dependencies:
       '@emnapi/core': 1.10.0
       '@emnapi/runtime': 1.10.0
-      '@napi-rs/wasm-runtime': 1.1.6(@emnapi/core@1.10.0)(@emnapi/runtime@1.10.0)
+      '@napi-rs/wasm-runtime': 1.1.5(@emnapi/core@1.10.0)(@emnapi/runtime@1.10.0)
     optional: true
 
   '@unrs/resolver-binding-win32-arm64-msvc@1.12.2':