feat(scouts): add "Created by me" filter to the fleet list

The scout configs endpoint carries no creator, so authorship is joined
client-side from the backing signals-scout-* skills (?category=scout on
the llm_skills list). Canonical seeds have no created_by, so only
hand-authored scouts can match. The toggle sits next to Hide disabled
and is hidden when the skills API is unavailable for the org.

Generated-By: PostHog Code
Task-Id: dd4f5437-2451-4783-b648-c0fad872f150

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,6 +11,7 @@ import {
   formatRunIntervalShort,
   getScoutOrigin,
   isRunStuck,
+  isScoutCreatedByUser,
   normalizeRunStatus,
   prettifyScoutSkillName,
   runDurationSeconds,
@@ -329,3 +331,78 @@ 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);
+  });
+});

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,39 @@ 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;
+}
+
+export function isScoutCreatedByUser(
+  creator: LlmSkillCreatedBy | null | undefined,
+  user: { id?: number; email?: string | null } | 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 type ScoutRunStatus =
   | "completed"
   | "failed"

packages/shared/src/analytics-events.ts

@@ -716,6 +716,7 @@ export type ScoutActionType =
   | "show_more_emitted_runs"
   | "filter_runs"
   | "toggle_hide_disabled"
+  | "toggle_created_by_me"
   | "open_settings"
   | "close_settings"
   | "open_findings"
@@ -774,6 +775,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;
 }

packages/ui/src/features/scouts/components/ScoutsFleetSection.tsx

@@ -10,6 +10,7 @@ import {
   computeFleetSummary,
   computeScoutRollups,
   getScoutOrigin,
+  isScoutCreatedByUser,
   sortConfigsForDisplay,
 } from "@posthog/core/scouts/scoutPresentation";
 import {
@@ -27,10 +28,12 @@ import { RelativeTimestamp } from "@posthog/ui/primitives/RelativeTimestamp";
 import { track } from "@posthog/ui/shell/analytics";
 import { Box, Flex, Text } from "@radix-ui/themes";
 import { useEffect, useMemo, useRef, useState } from "react";
+import { useMeQuery } from "../../auth/useMeQuery";
 import { useScoutChatTask } from "../hooks/useScoutChatTask";
 import { useScoutConfigMutations } from "../hooks/useScoutConfigMutations";
 import { useScoutConfigs } from "../hooks/useScoutConfigs";
 import { useScoutRuns } from "../hooks/useScoutRuns";
+import { useScoutSkillCreators } from "../hooks/useScoutSkillCreators";
 import { FleetFindingsCallout } from "./FleetFindingsCallout";
 import { FleetMemoryCallout } from "./FleetMemoryCallout";
 import { ScoutAlphaBanner } from "./ScoutAlphaBanner";
@@ -154,6 +157,9 @@ function ScoutsFleetList({ configs }: { configs: ScoutConfig[] }) {
   const { data: runsWindow } = useScoutRuns();
   const { updateConfig } = useScoutConfigMutations();
   const [hideDisabled, setHideDisabled] = useState(false);
+  const [createdByMe, setCreatedByMe] = useState(false);
+  const { data: creators } = useScoutSkillCreators();
+  const { data: currentUser } = useMeQuery();
   useTrackFleetViewed(configs);
 
   const runs = runsWindow?.runs;
@@ -162,10 +168,28 @@ function ScoutsFleetList({ configs }: { configs: ScoutConfig[] }) {
     () => computeFleetSummary(configs, rollups),
     [configs, rollups],
   );
+  // Null creators = the skills API is gated for this org, so authorship is
+  // unknowable; skip the affordance instead of offering an always-empty filter.
+  const canFilterByCreator = !!creators && !!currentUser;
   const visibleConfigs = useMemo(() => {
-    const sorted = sortConfigsForDisplay(configs);
-    return hideDisabled ? sorted.filter((config) => config.enabled) : sorted;
-  }, [configs, hideDisabled]);
+    let sorted = sortConfigsForDisplay(configs);
+    if (hideDisabled) {
+      sorted = sorted.filter((config) => config.enabled);
+    }
+    if (createdByMe && canFilterByCreator) {
+      sorted = sorted.filter((config) =>
+        isScoutCreatedByUser(creators?.get(config.skill_name), currentUser),
+      );
+    }
+    return sorted;
+  }, [
+    configs,
+    hideDisabled,
+    createdByMe,
+    canFilterByCreator,
+    creators,
+    currentUser,
+  ]);
 
   return (
     <Flex direction="column" gap="3">
@@ -187,6 +211,36 @@ function ScoutsFleetList({ configs }: { configs: ScoutConfig[] }) {
           </span>
         </Text>
         <span className="flex-1" />
+        {canFilterByCreator ? (
+          <button
+            type="button"
+            aria-pressed={createdByMe}
+            onClick={() => {
+              const next = !createdByMe;
+              setCreatedByMe(next);
+              track(ANALYTICS_EVENTS.SCOUT_ACTION, {
+                action_type: "toggle_created_by_me",
+                surface: "fleet_list",
+                created_by_me: next,
+                filter_match_count: next
+                  ? configs.filter((config) =>
+                      isScoutCreatedByUser(
+                        creators?.get(config.skill_name),
+                        currentUser,
+                      ),
+                    ).length
+                  : undefined,
+              });
+            }}
+            className={`rounded px-1.5 py-0.5 text-[12px] transition-colors ${
+              createdByMe
+                ? "bg-(--gray-4) text-gray-12"
+                : "text-gray-10 hover:bg-gray-3 hover:text-gray-12"
+            }`}
+          >
+            Created by me
+          </button>
+        ) : null}
         <button
           type="button"
           onClick={() => {
@@ -238,14 +292,22 @@ function ScoutsFleetList({ configs }: { configs: ScoutConfig[] }) {
       {/* Bounded to roughly 10 rows; larger fleets scroll within the section. */}
       <div className="max-h-[710px] overflow-y-auto">
         <Flex direction="column" gap="2">
-          {visibleConfigs.map((config) => (
-            <ScoutRowCard
-              key={config.id}
-              config={config}
-              rollup={rollups.get(config.skill_name)}
-              onUpdate={updateConfig}
-            />
-          ))}
+          {visibleConfigs.length === 0 ? (
+            <Text className="px-1 py-2 text-[12.5px] text-gray-10">
+              {createdByMe
+                ? "No scouts created by you match the current filters."
+                : "No scouts match the current filters."}
+            </Text>
+          ) : (
+            visibleConfigs.map((config) => (
+              <ScoutRowCard
+                key={config.id}
+                config={config}
+                rollup={rollups.get(config.skill_name)}
+                onUpdate={updateConfig}
+              />
+            ))
+          )}
         </Flex>
       </div>
 

packages/ui/src/features/scouts/hooks/scoutQueryKeys.ts

@@ -4,6 +4,8 @@ export const scoutQueryKeys = {
   metadata: (projectId: number | null) =>
     ["scouts", "metadata", projectId] as const,
   runs: (projectId: number | null) => ["scouts", "runs", projectId] as const,
+  skillCreators: (projectId: number | null) =>
+    ["scouts", "skillCreators", projectId] as const,
   scratchpad: (projectId: number | null) =>
     ["scouts", "scratchpad", projectId] as const,
   emissions: (projectId: number | null, runIds: string[]) =>

packages/ui/src/features/scouts/hooks/useScoutSkillCreators.ts

@@ -0,0 +1,24 @@
+import {
+  buildScoutCreatorIndex,
+  type ScoutCreatorIndex,
+} from "@posthog/core/scouts/scoutPresentation";
+import { useAuthenticatedQuery } from "@posthog/ui/hooks/useAuthenticatedQuery";
+import { useAuthStateValue } from "../../auth/store";
+import { scoutQueryKeys } from "./scoutQueryKeys";
+
+/**
+ * Skill name → author of each scout's backing skill, for creator filtering.
+ * Resolves to null when the org lacks the team-skills feature — callers should
+ * drop creator affordances entirely rather than show an always-empty filter.
+ */
+export function useScoutSkillCreators() {
+  const projectId = useAuthStateValue((state) => state.currentProjectId);
+  return useAuthenticatedQuery<ScoutCreatorIndex | null>(
+    scoutQueryKeys.skillCreators(projectId),
+    async (client) => {
+      const skills = await client.listLlmSkills({ category: "scout" });
+      return skills === null ? null : buildScoutCreatorIndex(skills);
+    },
+    { enabled: !!projectId, staleTime: 30_000 },
+  );
+}