feat(scouts): filter the fleet list by creator (#3292)

## Problem

The scouts fleet list shows every scout on the project. On a shared project with a large fleet (canonical scouts plus many teammates' custom ones), there's no way to narrow the list to the scouts a given person authored — most commonly your own.

## Changes

- Adds a **Created by** picker next to **Hide disabled** in the fleet list — "Any user" plus the fleet's distinct authors, with the current user pinned first (and always offered, so "just mine" is one click). Same filter shape as the cloud skills list's Created-by member filter.
- The configs endpoint carries no creator, so authorship is joined client-side from the backing `signals-scout-*` skills (`listLlmSkills` gained a `category` option; the fleet fetches `?category=scout` once). Canonical seeds carry no `created_by`, so they never match a person. As on the cloud skills list, "creator" means the latest version's author.
- Splits the fleet list into a pure `ScoutsFleetListView` (data via props) with Storybook stories for the default fleet, filtered-to-you, filtered-empty, and skills-API-gated states; the picker hides entirely when authorship is unknowable.
- New pure helpers in core (`buildScoutCreatorIndex`, `listScoutCreatorOptions`, `scoutCreatorKey`) with unit tests, and a `filter_created_by` scout analytics action.

The picker, open (Storybook, fixture data):

<img src="https://raw.githubusercontent.com/PostHog/code/37382bf9493edeb93b6499e70c61b8a5108293f5/.github/pr-assets/scouts-fleet-picker-open.png" width="900" alt="Scouts fleet list with the Created by picker open, showing Any user, the current user pinned first, and two other authors">

Filtered to the current user:

<img src="https://raw.githubusercontent.com/PostHog/code/37382bf9493edeb93b6499e70c61b8a5108293f5/.github/pr-assets/scouts-fleet-filtered.png" width="900" alt="Scouts fleet list filtered to the current user, showing only their scout">

(Screenshots were committed once for hosting and removed again in the next commit — the merged tree carries no binaries.)

**Why**: when viewing the list of scouts, you generally want to be able to select just the ones you (or a teammate) created.

## How did you test this?

- Unit tests for the creator helpers and option builder in `scoutPresentation.test.ts` (`pnpm --filter @posthog/core test` — 2172 passed).
- `pnpm turbo typecheck` for `shared`, `api-client`, `core`, and `ui`, plus `biome check` on the touched files — all clean.
- Rendered the new Storybook stories in the dev server and captured the screenshots above via headless Chromium (no page errors).
- Verified against the live backend serializers that `?category=scout` filtering and `created_by` on the skills list exist, and that canonical seeds have no author.

## Automatic notifications

- [ ] Publish to changelog?
- [ ] Alert Sales and Marketing teams?

---
*Created with [PostHog Code](https://posthog.com/code?ref=pr)*

Author: pauldambra

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

@@ -4698,11 +4698,18 @@ export class PostHogAPIClient {
    * Lists the team's LLM skills (latest versions, no bodies).
    * Returns null when the feature is unavailable for this org (the
    * llm-analytics-skills flag gates the endpoint server-side with a 403).
+   * `category` narrows to one exact server-owned category (e.g. "scout"
+   * for Signals scouts); omit it to list every category.
    */
-  async listLlmSkills(): Promise<LlmSkillListItem[] | null> {
+  async listLlmSkills(
+    options: { category?: string } = {},
+  ): Promise<LlmSkillListItem[] | null> {
     const teamId = await this.getTeamId();
     const urlPath = `/api/environments/${teamId}/llm_skills/`;
     const url = new URL(`${this.api.baseUrl}${urlPath}`);
+    if (options.category !== undefined) {
+      url.searchParams.set("category", options.category);
+    }
     const response = await this.api.fetcher.fetch({
       method: "get",
       url,

packages/core/src/scouts/scoutPresentation.test.ts

@@ -1,6 +1,7 @@
 import type { ScoutConfig, ScoutRun } from "@posthog/api-client/posthog-client";
 import { describe, expect, it } from "vitest";
 import {
+  buildScoutCreatorIndex,
   computeFleetSummary,
   computeScoutRollups,
   deriveRunFailureKind,
@@ -10,12 +11,16 @@ import {
   formatRunIntervalShort,
   getScoutOrigin,
   isRunStuck,
+  isScoutCreatedByUser,
+  listScoutCreatorOptions,
   normalizeRunStatus,
   prettifyScoutSkillName,
   runDurationSeconds,
   runMatchesFilter,
   type ScoutOrigin,
   type ScoutRunFilter,
+  scoutCreatorDisplayName,
+  scoutCreatorKey,
   scoutRunOutcomeLabel,
   scoutSkillNameFromSlug,
   scoutSkillSlug,
@@ -329,3 +334,164 @@ describe("intervals and ordering", () => {
     ]);
   });
 });
+
+describe("creators", () => {
+  it("indexes latest authored skills and skips canonical seeds", () => {
+    const index = buildScoutCreatorIndex([
+      {
+        name: "signals-scout-ad-spend",
+        created_by: { id: 7, email: "paul@example.com" },
+        is_latest: true,
+      },
+      // Canonical seeds carry no author.
+      {
+        name: "signals-scout-error-tracking",
+        created_by: null,
+        is_latest: true,
+      },
+      // Superseded versions must not shadow the latest author.
+      {
+        name: "signals-scout-ad-spend",
+        created_by: { id: 9, email: "someone@example.com" },
+        is_latest: false,
+      },
+    ]);
+    expect(index.get("signals-scout-ad-spend")).toEqual({
+      id: 7,
+      email: "paul@example.com",
+    });
+    expect(index.has("signals-scout-error-tracking")).toBe(false);
+  });
+
+  it.each<{
+    label: string;
+    creator: Parameters<typeof isScoutCreatedByUser>[0];
+    user: Parameters<typeof isScoutCreatedByUser>[1];
+    expected: boolean;
+  }>([
+    {
+      label: "matches on numeric id",
+      creator: { id: 7, email: "old@example.com" },
+      user: { id: 7, email: "new@example.com" },
+      expected: true,
+    },
+    {
+      label: "rejects a different id even when emails collide",
+      creator: { id: 7, email: "shared@example.com" },
+      user: { id: 8, email: "shared@example.com" },
+      expected: false,
+    },
+    {
+      label: "falls back to case-insensitive email when the id is absent",
+      creator: { email: "Paul@Example.com" },
+      user: { id: 7, email: "paul@example.com" },
+      expected: true,
+    },
+    {
+      label: "never matches an unauthored scout",
+      creator: undefined,
+      user: { id: 7, email: "paul@example.com" },
+      expected: false,
+    },
+    {
+      label: "never matches without a user",
+      creator: { id: 7 },
+      user: null,
+      expected: false,
+    },
+    {
+      label: "never matches on missing emails",
+      creator: { email: null },
+      user: { email: "" },
+      expected: false,
+    },
+  ])("$label", ({ creator, user, expected }) => {
+    expect(isScoutCreatedByUser(creator, user)).toBe(expected);
+  });
+
+  it("keys creators by numeric id, falling back to normalized email", () => {
+    expect(scoutCreatorKey({ id: 7, email: "x@example.com" })).toBe("id:7");
+    expect(scoutCreatorKey({ email: " Paul@Example.com " })).toBe(
+      "email:paul@example.com",
+    );
+    expect(scoutCreatorKey({})).toBeNull();
+    expect(scoutCreatorKey(null)).toBeNull();
+  });
+
+  it("prefers the full name for display, then the email", () => {
+    expect(
+      scoutCreatorDisplayName({
+        first_name: "Paul",
+        last_name: "Smith",
+        email: "p@example.com",
+      }),
+    ).toBe("Paul Smith");
+    expect(scoutCreatorDisplayName({ email: "p@example.com" })).toBe(
+      "p@example.com",
+    );
+    expect(scoutCreatorDisplayName({})).toBe("Unknown user");
+  });
+
+  describe("listScoutCreatorOptions", () => {
+    const index = buildScoutCreatorIndex([
+      {
+        name: "signals-scout-ad-spend",
+        created_by: { id: 7, first_name: "Paul", email: "paul@example.com" },
+        is_latest: true,
+      },
+      {
+        name: "signals-scout-checkout",
+        created_by: { id: 9, first_name: "Zoe", email: "zoe@example.com" },
+        is_latest: true,
+      },
+      {
+        name: "signals-scout-digest",
+        created_by: { id: 8, first_name: "Amy", email: "amy@example.com" },
+        is_latest: true,
+      },
+      // A second skill by an existing author must not duplicate the option.
+      {
+        name: "signals-scout-uptime",
+        created_by: { id: 9, first_name: "Zoe", email: "zoe@example.com" },
+        is_latest: true,
+      },
+    ]);
+
+    it("pins the current user first and sorts the rest alphabetically", () => {
+      const options = listScoutCreatorOptions(index, {
+        id: 7,
+        email: "paul@example.com",
+      });
+      expect(options.map((option) => option.label)).toEqual([
+        "Paul (you)",
+        "Amy",
+        "Zoe",
+      ]);
+      expect(options[0]).toMatchObject({ key: "id:7", isCurrentUser: true });
+    });
+
+    it("still offers the current user when they authored nothing", () => {
+      const options = listScoutCreatorOptions(index, {
+        id: 1,
+        first_name: "New",
+        email: "new@example.com",
+      });
+      expect(options[0]).toEqual({
+        key: "id:1",
+        label: "New (you)",
+        isCurrentUser: true,
+      });
+      expect(options).toHaveLength(4);
+    });
+
+    it("lists plain authors when the current user is unknown", () => {
+      const options = listScoutCreatorOptions(index, null);
+      expect(options.map((option) => option.label)).toEqual([
+        "Amy",
+        "Paul",
+        "Zoe",
+      ]);
+      expect(options.every((option) => !option.isCurrentUser)).toBe(true);
+    });
+  });
+});

packages/core/src/scouts/scoutPresentation.ts

@@ -1,4 +1,9 @@
-import type { ScoutConfig, ScoutRun } from "@posthog/api-client/posthog-client";
+import type {
+  LlmSkillCreatedBy,
+  LlmSkillListItem,
+  ScoutConfig,
+  ScoutRun,
+} from "@posthog/api-client/posthog-client";
 
 // Single source of truth lives in `@posthog/shared` so `buildScoutDeeplink`
 // (which cannot import core) and the UI share one slug implementation.
@@ -27,6 +32,117 @@ export function prettifyScoutSkillName(skillName: string): string {
   return cleaned.charAt(0).toUpperCase() + cleaned.slice(1);
 }
 
+/** Skill name → author of the backing `signals-scout-*` skill's latest version. */
+export type ScoutCreatorIndex = Map<string, LlmSkillCreatedBy>;
+
+/**
+ * The configs endpoint carries no creator, so authorship comes from the
+ * backing skill (the scout IS the skill). Canonical seeds are created with no
+ * `created_by`, so absence from the index means "not hand-authored by anyone".
+ */
+export function buildScoutCreatorIndex(
+  skills: Pick<LlmSkillListItem, "name" | "created_by" | "is_latest">[],
+): ScoutCreatorIndex {
+  const index: ScoutCreatorIndex = new Map();
+  for (const skill of skills) {
+    if (!skill.is_latest || !skill.created_by) continue;
+    index.set(skill.name, skill.created_by);
+  }
+  return index;
+}
+
+/** The slice of the current user the creator filter needs. */
+export interface ScoutCreatorUser {
+  id?: number;
+  email?: string | null;
+  first_name?: string | null;
+  last_name?: string | null;
+}
+
+export function isScoutCreatedByUser(
+  creator: LlmSkillCreatedBy | null | undefined,
+  user: ScoutCreatorUser | null | undefined,
+): boolean {
+  if (!creator || !user) return false;
+  if (creator.id !== undefined && user.id !== undefined) {
+    return creator.id === user.id;
+  }
+  // Older payloads may omit the numeric id; emails are unique per instance.
+  const creatorEmail = creator.email?.trim().toLowerCase();
+  const userEmail = user.email?.trim().toLowerCase();
+  return !!creatorEmail && creatorEmail === userEmail;
+}
+
+export function scoutCreatorDisplayName(
+  creator: Pick<LlmSkillCreatedBy, "first_name" | "last_name" | "email">,
+): string {
+  const name = [creator.first_name, creator.last_name]
+    .filter(Boolean)
+    .join(" ")
+    .trim();
+  return name || creator.email?.trim() || "Unknown user";
+}
+
+/**
+ * Stable identity for a creator across the option list and the per-config
+ * lookup: the numeric user id when present, else the lowercased email.
+ */
+export function scoutCreatorKey(
+  creator: Pick<LlmSkillCreatedBy, "id" | "email"> | null | undefined,
+): string | null {
+  if (!creator) return null;
+  if (typeof creator.id === "number") return `id:${creator.id}`;
+  const email = creator.email?.trim().toLowerCase();
+  return email ? `email:${email}` : null;
+}
+
+export interface ScoutCreatorOption {
+  key: string;
+  label: string;
+  isCurrentUser: boolean;
+}
+
+/**
+ * Distinct authors across the fleet for a "Created by" picker: the current
+ * user pinned first (offered even with nothing authored yet, so "just mine"
+ * is always selectable), then the other authors A–Z. Canonical seeds carry no
+ * author, so they never contribute an option.
+ */
+export function listScoutCreatorOptions(
+  index: ScoutCreatorIndex,
+  currentUser: ScoutCreatorUser | null | undefined,
+): ScoutCreatorOption[] {
+  const byKey = new Map<string, ScoutCreatorOption>();
+  for (const creator of index.values()) {
+    const key = scoutCreatorKey(creator);
+    if (!key || byKey.has(key)) continue;
+    const isCurrentUser = isScoutCreatedByUser(creator, currentUser);
+    byKey.set(key, {
+      key,
+      label: isCurrentUser
+        ? `${scoutCreatorDisplayName(creator)} (you)`
+        : scoutCreatorDisplayName(creator),
+      isCurrentUser,
+    });
+  }
+  const options = [...byKey.values()];
+  if (currentUser && !options.some((option) => option.isCurrentUser)) {
+    const key = scoutCreatorKey(currentUser);
+    if (key) {
+      options.push({
+        key,
+        label: `${scoutCreatorDisplayName(currentUser)} (you)`,
+        isCurrentUser: true,
+      });
+    }
+  }
+  options.sort((a, b) => {
+    if (a.isCurrentUser !== b.isCurrentUser) return a.isCurrentUser ? -1 : 1;
+    return a.label.localeCompare(b.label);
+  });
+  return options;
+}
+
 export type ScoutRunStatus =
   | "completed"
   | "failed"

packages/shared/src/analytics-events.ts

@@ -717,6 +717,7 @@ export type ScoutActionType =
   | "show_more_emitted_runs"
   | "filter_runs"
   | "toggle_hide_disabled"
+  | "filter_created_by"
   | "open_settings"
   | "close_settings"
   | "open_findings"
@@ -775,6 +776,7 @@ export interface ScoutActionProperties {
   filter_match_count?: number;
   helper_skill?: string;
   hide_disabled?: boolean;
+  created_by_me?: boolean;
   /** Status of the linked inbox report, for `open_linked_report`. */
   report_status?: string;
 }