fix(channels): show uploaded files in the task Artifacts pane

The pane read the run artifact manifest and then dropped everything on
`type === "plan"` — a type nothing in the product has ever written. The
only deliverable type agents actually produce is `output`, via the
`upload_artifact` tool, so the manifest branch was unreachable and files
handed back by a run never appeared.

Verified against a live run's manifest: 6 `output`, 2 `user_attachment`,
zero `plan`. The `plan` row was speculative — down to a bare-UUID
fallback for names that never arrive — so it goes rather than shipping a
UI affordance for data that doesn't exist. It can come back with a
producer.

Same inversion is why the conversation's Files box showed these while
the pane said "No artifacts yet": it filters to `output`, the exact
complement.

- `parseRunPlans` becomes `parseRunArtifacts(raw, types)`, and reads the
  `size`/`content_type`/`uploaded_at` the rows need.
- Re-uploads collapse to the newest per name: agents revise a
  deliverable and upload it again, and keeping every copy buries the
  current one under its own drafts.
- `formatFileSize` moves out of CloudArtifactDownloads so both surfaces
  format sizes the same way.

Generated-By: PostHog Code
Task-Id: 8d187d00-0633-4706-8443-f79130b65f9f

Author: puemos

packages/core/src/canvas/runArtifactSchemas.test.ts

@@ -1,36 +1,68 @@
 import { describe, expect, it } from "vitest";
-import { parseRunPlans } from "./runArtifactSchemas";
+import { OUTPUT_ARTIFACT_TYPES, parseRunArtifacts } from "./runArtifactSchemas";
 
-describe("parseRunPlans", () => {
+describe("parseRunArtifacts", () => {
   it.each([
     { name: "undefined", raw: undefined },
     { name: "null", raw: null },
     { name: "an object", raw: { artifacts: [] } },
-    { name: "a string", raw: "plan" },
+    { name: "a string", raw: "output" },
   ])("reads $name as no artifacts", ({ raw }) => {
-    expect(parseRunPlans(raw)).toEqual([]);
+    expect(parseRunArtifacts(raw, OUTPUT_ARTIFACT_TYPES)).toEqual([]);
   });
 
-  it("keeps only plan artifacts", () => {
-    const plans = parseRunPlans([
-      { id: "a", type: "plan", name: "Plan A" },
-      { id: "b", type: "upload", name: "internal blob" },
+  // A run's manifest mixes deliverables with plumbing nobody asked to see.
+  it("keeps only the requested types", () => {
+    const outputs = parseRunArtifacts(
+      [
+        { id: "a", type: "output", name: "report.md" },
+        { id: "b", type: "user_attachment", name: "clipboard.png" },
+        { id: "c", type: "skill_bundle", name: "skills.zip" },
+      ],
+      OUTPUT_ARTIFACT_TYPES,
+    );
+    expect(outputs).toEqual([{ id: "a", type: "output", name: "report.md" }]);
+  });
+
+  it("reads the size and upload time the row renders", () => {
+    const artifact = {
+      id: "a",
+      type: "output",
+      name: "report.md",
+      size: 16861,
+      content_type: "text/markdown",
+      uploaded_at: "2026-07-27T08:27:26.896719+00:00",
+    };
+    expect(parseRunArtifacts([artifact], OUTPUT_ARTIFACT_TYPES)).toEqual([
+      artifact,
     ]);
-    expect(plans).toEqual([{ id: "a", type: "plan", name: "Plan A" }]);
+  });
+
+  it("keeps an artifact that omits the optional fields", () => {
+    expect(
+      parseRunArtifacts([{ type: "output" }], OUTPUT_ARTIFACT_TYPES),
+    ).toEqual([{ type: "output" }]);
   });
 
   // One bad entry shouldn't take the Artifacts tab down with it.
   it("drops entries that don't match the shape", () => {
-    const plans = parseRunPlans([
-      { id: 42, type: "plan" },
-      null,
-      "not an object",
-      { type: "plan", storage_path: "runs/1/plan.md" },
+    const outputs = parseRunArtifacts(
+      [
+        { id: 42, type: "output" },
+        null,
+        "not an object",
+        { type: "output", storage_path: "runs/1/report.md" },
+      ],
+      OUTPUT_ARTIFACT_TYPES,
+    );
+    expect(outputs).toEqual([
+      { type: "output", storage_path: "runs/1/report.md" },
     ]);
-    expect(plans).toEqual([{ type: "plan", storage_path: "runs/1/plan.md" }]);
   });
 
   it("ignores an artifact with no type", () => {
-    expect(parseRunPlans([{ id: "a", name: "mystery" }])).toEqual([]);
+    expect(
+      parseRunArtifacts([{ id: "a", name: "mystery" }], OUTPUT_ARTIFACT_TYPES),
+    ).toEqual([]);
   });
 });

packages/core/src/canvas/runArtifactSchemas.ts

@@ -4,14 +4,30 @@ export const runArtifactSchema = z.object({
   id: z.string().optional(),
   name: z.string().optional(),
   type: z.string().optional(),
+  size: z.number().optional(),
+  content_type: z.string().optional(),
   storage_path: z.string().optional(),
+  uploaded_at: z.string().optional(),
 });
 export type RunArtifact = z.infer<typeof runArtifactSchema>;
 
-export function parseRunPlans(raw: unknown): RunArtifact[] {
+/** Artifacts the agent hands back as deliverables, via the `upload_artifact` tool. */
+export const OUTPUT_ARTIFACT_TYPES = ["output"] as const;
+
+/**
+ * The run's artifacts of the given types, in manifest order. A run's manifest
+ * also carries plumbing the user never asked for — skill bundles, their own
+ * attachments — so callers name the types they want.
+ */
+export function parseRunArtifacts(
+  raw: unknown,
+  types: readonly string[],
+): RunArtifact[] {
   if (!Array.isArray(raw)) return [];
   return raw.flatMap((entry) => {
     const parsed = runArtifactSchema.safeParse(entry);
-    return parsed.success && parsed.data.type === "plan" ? [parsed.data] : [];
+    if (!parsed.success) return [];
+    const { type } = parsed.data;
+    return type && types.includes(type) ? [parsed.data] : [];
   });
 }

packages/ui/src/features/canvas/components/TaskArtifactsList.test.tsx

@@ -1,14 +1,20 @@
-import type { Task, TaskRun } from "@posthog/shared/domain-types";
+import type { Task, TaskRun, TaskRunArtifact } from "@posthog/shared";
 import { fireEvent, render, screen } from "@testing-library/react";
 import { beforeEach, describe, expect, it, vi } from "vitest";
 
 const mocks = vi.hoisted(() => ({
   runs: [] as TaskRun[],
+  presignTaskRunArtifact: vi.fn(),
 }));
 
 vi.mock("@posthog/ui/features/canvas/hooks/useTaskRuns", () => ({
   useTaskRuns: () => ({ runs: mocks.runs, isLoading: false }),
 }));
+vi.mock("@posthog/ui/features/auth/authClient", () => ({
+  useOptionalAuthenticatedClient: () => ({
+    presignTaskRunArtifact: mocks.presignTaskRunArtifact,
+  }),
+}));
 vi.mock("@posthog/ui/features/git-interaction/usePrArtifact", () => ({
   usePrArtifact: (url: string) => ({
     safeUrl: url,
@@ -33,16 +39,35 @@ const task = {
   latest_run: null,
 } as unknown as Task;
 
-function run(id: string, prNumber: number): TaskRun {
+function run(
+  id: string,
+  options: { prNumber?: number; artifacts?: Partial<TaskRunArtifact>[] } = {},
+): TaskRun {
   return {
     id,
-    output: { pr_url: `https://github.com/acme/repo/pull/${prNumber}` },
+    output: options.prNumber
+      ? { pr_url: `https://github.com/acme/repo/pull/${options.prNumber}` }
+      : null,
+    artifacts: options.artifacts,
   } as unknown as TaskRun;
 }
 
+function outputFile(
+  overrides: Partial<TaskRunArtifact>,
+): Partial<TaskRunArtifact> {
+  return {
+    type: "output",
+    name: "report.md",
+    storage_path: "runs/1/report.md",
+    ...overrides,
+  };
+}
+
 describe("TaskArtifactsList", () => {
   beforeEach(() => {
-    mocks.runs = [run("run-1", 1), run("run-2", 2)];
+    mocks.runs = [run("run-1", { prNumber: 1 }), run("run-2", { prNumber: 2 })];
+    mocks.presignTaskRunArtifact.mockReset();
+    mocks.presignTaskRunArtifact.mockResolvedValue("https://signed.example/x");
     useReviewNavigationStore.setState({
       reviewModes: {},
       selectedPrUrls: {},
@@ -60,4 +85,77 @@ describe("TaskArtifactsList", () => {
     );
     expect(state.reviewModes[task.id]).toBe("split");
   });
+
+  it("lists the files the agent uploaded, with their size", () => {
+    mocks.runs = [
+      run("run-1", { artifacts: [outputFile({ id: "a", size: 16861 })] }),
+    ];
+
+    render(<TaskArtifactsList task={task} timeline={[]} />);
+
+    expect(screen.getByText("report.md")).toBeTruthy();
+    expect(screen.getByText("File · 17 KB")).toBeTruthy();
+  });
+
+  it("presigns the artifact of the run that produced it", () => {
+    mocks.runs = [
+      run("run-1", { artifacts: [outputFile({ id: "a", name: "old.md" })] }),
+      run("run-2", {
+        artifacts: [
+          outputFile({
+            id: "b",
+            name: "new.md",
+            storage_path: "runs/2/new.md",
+          }),
+        ],
+      }),
+    ];
+
+    render(<TaskArtifactsList task={task} timeline={[]} />);
+    fireEvent.click(screen.getByText("new.md"));
+
+    expect(mocks.presignTaskRunArtifact).toHaveBeenCalledWith(
+      "task-1",
+      "run-2",
+      "runs/2/new.md",
+    );
+  });
+
+  // Agents revise a deliverable and upload it again under the same name.
+  it("keeps only the newest upload of a repeatedly revised file", () => {
+    mocks.runs = [
+      run("run-1", {
+        artifacts: [
+          outputFile({
+            id: "a",
+            size: 1000,
+            uploaded_at: "2026-07-27T08:00:00+00:00",
+          }),
+          outputFile({
+            id: "b",
+            size: 2000,
+            storage_path: "runs/1/report-v2.md",
+            uploaded_at: "2026-07-27T09:00:00+00:00",
+          }),
+        ],
+      }),
+    ];
+
+    render(<TaskArtifactsList task={task} timeline={[]} />);
+
+    expect(screen.getAllByText("report.md")).toHaveLength(1);
+    expect(screen.getByText("File · 2 KB")).toBeTruthy();
+  });
+
+  it.each([
+    { name: "a plan", type: "plan" as const },
+    { name: "a user attachment", type: "user_attachment" as const },
+    { name: "a skill bundle", type: "skill_bundle" as const },
+  ])("shows the empty state for a run with only $name", ({ type }) => {
+    mocks.runs = [run("run-1", { artifacts: [outputFile({ id: "a", type })] })];
+
+    render(<TaskArtifactsList task={task} timeline={[]} />);
+
+    expect(screen.getByText("No artifacts yet")).toBeTruthy();
+  });
 });