feat(agent): show PostHog products used below each turn

When the agent uses a PostHog resource via the MCP `exec` dispatcher during a
turn, surface a chip row under that turn's final message listing the products
touched (Experiments, Feature flags, SQL, Error tracking, …). A turn with no
PostHog calls shows no row.

Detection and classification live in the agent (main/business layer); the
renderer is strictly UI:

- packages/agent/src/posthog-products.ts: classify an exec sub-tool's domain
  into a stable product id (admin/meta domains hidden; unknown → generic
  "PostHog"). Exported via @posthog/agent.
- PostToolUse hook records the product behind each executed `call` onto a
  per-turn Set on the session; reset at prompt start.
- At turn end the agent emits a new `_posthog/resources_used` notification with
  the turn's products, then clears the accumulator.
- Renderer: buildConversationItems handles the notification and places a
  `resources_used` item under the final message; ResourcesUsedView renders the
  chips.

Tests: posthog-products classification, and buildConversationItems placement /
empty-payload handling.

Generated-By: PostHog Code
Task-Id: f2ff4d75-f51e-4618-9e64-68ca4be237fa

Author: raquelmsmith

apps/code/src/renderer/features/sessions/components/buildConversationItems.test.ts

@@ -74,6 +74,38 @@ function turnCompleteMsg(ts: number, stopReason = "end_turn"): AcpMessage {
   };
 }
 
+function agentMessageMsg(ts: number, text: string): AcpMessage {
+  return {
+    type: "acp_message",
+    ts,
+    message: {
+      jsonrpc: "2.0",
+      method: "session/update",
+      params: {
+        update: {
+          sessionUpdate: "agent_message_chunk",
+          content: { type: "text", text },
+        },
+      },
+    },
+  };
+}
+
+function resourcesUsedMsg(
+  ts: number,
+  products: { id: string; label: string }[],
+): AcpMessage {
+  return {
+    type: "acp_message",
+    ts,
+    message: {
+      jsonrpc: "2.0",
+      method: "_posthog/resources_used",
+      params: { sessionId: "session-1", products },
+    },
+  };
+}
+
 describe("buildConversationItems", () => {
   it("extracts cloud prompt attachments into user messages", () => {
     const uri = makeAttachmentUri("/tmp/hello world.txt");
@@ -421,6 +453,63 @@ describe("buildConversationItems", () => {
       expect(findProgressGroups(result.items)).toHaveLength(0);
     });
   });
+
+  describe("resources_used", () => {
+    it("renders a resources_used item after the turn's final message", () => {
+      const products = [
+        { id: "experiments", label: "Experiments" },
+        { id: "sql", label: "SQL" },
+      ];
+      const events: AcpMessage[] = [
+        userPromptMsg(1, 1, "list my experiments"),
+        agentMessageMsg(2, "Here are your experiments."),
+        resourcesUsedMsg(3, products),
+        promptResponseMsg(4, 1),
+      ];
+
+      const result = buildConversationItems(events, false);
+
+      const idx = result.items.findIndex(
+        (i) =>
+          i.type === "session_update" &&
+          i.update.sessionUpdate === "resources_used",
+      );
+      expect(idx).toBeGreaterThanOrEqual(0);
+
+      // Must land after the agent's final message in the turn.
+      const msgIdx = result.items.findIndex(
+        (i) =>
+          i.type === "session_update" &&
+          i.update.sessionUpdate === "agent_message_chunk",
+      );
+      expect(idx).toBeGreaterThan(msgIdx);
+
+      const item = result.items[idx];
+      if (
+        item.type === "session_update" &&
+        item.update.sessionUpdate === "resources_used"
+      ) {
+        expect(item.update.products).toEqual(products);
+      }
+    });
+
+    it("ignores a resources_used notification with no products", () => {
+      const events: AcpMessage[] = [
+        userPromptMsg(1, 1, "hi"),
+        resourcesUsedMsg(2, []),
+        promptResponseMsg(3, 1),
+      ];
+
+      const result = buildConversationItems(events, false);
+      expect(
+        result.items.some(
+          (i) =>
+            i.type === "session_update" &&
+            i.update.sessionUpdate === "resources_used",
+        ),
+      ).toBe(false);
+    });
+  });
 });
 
 // Local alias kept intentionally narrow to the shape we care about in tests.

apps/code/src/renderer/features/sessions/components/buildConversationItems.ts

@@ -9,7 +9,11 @@ import {
   extractSkillButtonId,
   type SkillButtonId,
 } from "@features/skill-buttons/prompts";
-import { isNotification, POSTHOG_NOTIFICATIONS } from "@posthog/agent";
+import {
+  isNotification,
+  POSTHOG_NOTIFICATIONS,
+  type PostHogProductId,
+} from "@posthog/agent";
 import {
   type AcpMessage,
   isJsonRpcNotification,
@@ -380,6 +384,19 @@ function handleNotification(
     return;
   }
 
+  if (isNotification(msg.method, POSTHOG_NOTIFICATIONS.RESOURCES_USED)) {
+    const params = msg.params as
+      | { products?: { id: PostHogProductId; label: string }[] }
+      | undefined;
+    if (!params?.products?.length) return;
+    if (!b.currentTurn) ensureImplicitTurn(b, ts);
+    pushItem(b, {
+      sessionUpdate: "resources_used",
+      products: params.products,
+    });
+    return;
+  }
+
   if (isNotification(msg.method, POSTHOG_NOTIFICATIONS.TURN_COMPLETE)) {
     const params = msg.params as { stopReason?: string } | undefined;
     if (!b.currentTurn) return;

apps/code/src/renderer/features/sessions/components/session-update/ResourcesUsedView.tsx

@@ -0,0 +1,70 @@
+import type { IconProps } from "@phosphor-icons/react";
+import {
+  BrainIcon,
+  BugIcon,
+  ChartLineIcon,
+  ClipboardTextIcon,
+  DatabaseIcon,
+  FileTextIcon,
+  FlagIcon,
+  FlaskIcon,
+  GaugeIcon,
+  GlobeIcon,
+  PlugIcon,
+  SparkleIcon,
+  TableIcon,
+  VideoIcon,
+} from "@phosphor-icons/react";
+import type { PostHogProductId } from "@posthog/agent";
+import { Badge, Box, Flex, Text } from "@radix-ui/themes";
+import type { ComponentType } from "react";
+
+/**
+ * Icon per PostHog product. `Record<PostHogProductId, …>` keeps this exhaustive:
+ * adding a product id in `@posthog/agent` forces an icon here at compile time.
+ */
+const PRODUCT_ICON: Record<PostHogProductId, ComponentType<IconProps>> = {
+  product_analytics: ChartLineIcon,
+  web_analytics: GlobeIcon,
+  feature_flags: FlagIcon,
+  experiments: FlaskIcon,
+  error_tracking: BugIcon,
+  session_replay: VideoIcon,
+  surveys: ClipboardTextIcon,
+  llm_analytics: BrainIcon,
+  data_warehouse: DatabaseIcon,
+  cdp: PlugIcon,
+  logs: FileTextIcon,
+  apm: GaugeIcon,
+  sql: TableIcon,
+  posthog: SparkleIcon,
+};
+
+interface ResourcesUsedViewProps {
+  products: { id: PostHogProductId; label: string }[];
+}
+
+/**
+ * A subtle chip row rendered under a completed turn, listing the PostHog
+ * products the agent touched (via the MCP `exec` tool) while answering.
+ */
+export function ResourcesUsedView({ products }: ResourcesUsedViewProps) {
+  if (products.length === 0) return null;
+
+  return (
+    <Box className="mt-0.5 mb-1 pl-3">
+      <Flex align="center" gap="2" wrap="wrap">
+        <Text className="text-[12px] text-gray-9">PostHog resources used</Text>
+        {products.map((product) => {
+          const Icon = PRODUCT_ICON[product.id] ?? SparkleIcon;
+          return (
+            <Badge key={product.id} size="1" color="gray" variant="soft">
+              <Icon size={12} />
+              {product.label}
+            </Badge>
+          );
+        })}
+      </Flex>
+    </Box>
+  );
+}

apps/code/src/renderer/features/sessions/components/session-update/SessionUpdateView.tsx

@@ -1,13 +1,15 @@
 import type { Step } from "@components/ui/StepList";
 import type { ConversationItem } from "@features/sessions/components/buildConversationItems";
 import type { SessionUpdate, ToolCall } from "@features/sessions/types";
+import type { PostHogProductId } from "@posthog/agent";
 import { memo } from "react";
 
 import { AgentMessage } from "./AgentMessage";
 import { CompactBoundaryView } from "./CompactBoundaryView";
 import { ConsoleMessage } from "./ConsoleMessage";
 import { ErrorNotificationView } from "./ErrorNotificationView";
 import { ProgressGroupView } from "./ProgressGroupView";
+import { ResourcesUsedView } from "./ResourcesUsedView";
 import { StatusNotificationView } from "./StatusNotificationView";
 import { TaskNotificationView } from "./TaskNotificationView";
 import { ThoughtView } from "./ThoughtView";
@@ -48,6 +50,10 @@ export type RenderItem =
       sessionUpdate: "progress_group";
       steps: Step[];
       isActive: boolean;
+    }
+  | {
+      sessionUpdate: "resources_used";
+      products: { id: PostHogProductId; label: string }[];
     };
 
 interface SessionUpdateViewProps {
@@ -138,6 +144,8 @@ export const SessionUpdateView = memo(function SessionUpdateView({
           turnComplete={turnComplete}
         />
       );
+    case "resources_used":
+      return <ResourcesUsedView products={item.products} />;
     default:
       return null;
   }

packages/agent/src/acp-extensions.ts

@@ -67,6 +67,9 @@ export const POSTHOG_NOTIFICATIONS = {
   /** Token usage update for a session turn */
   USAGE_UPDATE: "_posthog/usage_update",
 
+  /** PostHog products used during a turn (derived from MCP exec calls) */
+  RESOURCES_USED: "_posthog/resources_used",
+
   /** Response to a relayed permission request (plan approval, question) */
   PERMISSION_RESPONSE: "_posthog/permission_response",
 } as const;

packages/agent/src/adapters/claude/claude-agent.refresh.test.ts

@@ -97,6 +97,7 @@ function installFakeSession(
       cachedReadTokens: 0,
       cachedWriteTokens: 0,
     },
+    turnResources: new Set(),
     configOptions: [],
     promptRunning: false,
     pendingMessages: new Map(),

packages/agent/src/adapters/claude/claude-agent.slash-command.test.ts

@@ -58,6 +58,7 @@ function installFakeSession(
       cachedReadTokens: 0,
       cachedWriteTokens: 0,
     },
+    turnResources: new Set(),
     configOptions: [],
     promptRunning: false,
     pendingMessages: new Map(),

packages/agent/src/adapters/claude/claude-agent.ts

@@ -52,6 +52,10 @@ import {
   POSTHOG_METHODS,
   POSTHOG_NOTIFICATIONS,
 } from "../../acp-extensions";
+import {
+  classifyPostHogSubTool,
+  POSTHOG_PRODUCTS,
+} from "../../posthog-products";
 import {
   createEnrichment,
   type Enrichment,
@@ -435,6 +439,7 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
       cachedReadTokens: 0,
       cachedWriteTokens: 0,
     };
+    this.session.turnResources.clear();
 
     await this.broadcastUserMessage(params);
 
@@ -639,6 +644,8 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
                 },
               });
 
+              await this.emitResourcesUsed(params.sessionId);
+
               return {
                 stopReason: this.session.cancelled ? "cancelled" : "end_turn",
               };
@@ -728,6 +735,8 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
               },
             );
 
+            await this.emitResourcesUsed(params.sessionId);
+
             const usage: Usage = {
               inputTokens: this.session.accumulatedUsage.inputTokens,
               outputTokens: this.session.accumulatedUsage.outputTokens,
@@ -1405,6 +1414,7 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
       outputFormat,
       settingsManager,
       onModeChange: this.createOnModeChange(),
+      onPostHogResourceUsed: this.createOnPostHogResourceUsed(),
       onProcessSpawned: this.options?.onProcessSpawned,
       onProcessExited: this.options?.onProcessExited,
       effort,
@@ -1442,6 +1452,7 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
         cachedReadTokens: 0,
         cachedWriteTokens: 0,
       },
+      turnResources: new Set(),
       effort,
       configOptions: [],
       promptRunning: false,
@@ -1644,6 +1655,30 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
     };
   }
 
+  /** Records the PostHog product behind an executed MCP exec `call` so the
+   *  current turn can report which products it touched. */
+  private createOnPostHogResourceUsed() {
+    return (subTool: string) => {
+      const product = classifyPostHogSubTool(subTool);
+      if (product) this.session?.turnResources.add(product);
+    };
+  }
+
+  /** Emits the PostHog products used this turn, then clears the accumulator.
+   *  Fires before the prompt response so the notification lands in the turn. */
+  private async emitResourcesUsed(sessionId: string): Promise<void> {
+    if (!this.session || this.session.turnResources.size === 0) return;
+    const products = [...this.session.turnResources].map((id) => ({
+      id,
+      label: POSTHOG_PRODUCTS[id],
+    }));
+    this.session.turnResources.clear();
+    await this.client.extNotification(POSTHOG_NOTIFICATIONS.RESOURCES_USED, {
+      sessionId,
+      products,
+    });
+  }
+
   private getExistingSessionState(
     sessionId: string,
   ): NewSessionResponse | null {

packages/agent/src/adapters/claude/hooks.ts

@@ -176,10 +176,15 @@ export type OnModeChange = (mode: CodeExecutionMode) => Promise<void>;
 
 interface CreatePostToolUseHookParams {
   onModeChange?: OnModeChange;
+  /** Called with the PostHog MCP sub-tool name after a `call` exec executes. */
+  onPostHogResourceUsed?: (subTool: string) => void;
 }
 
 export const createPostToolUseHook =
-  ({ onModeChange }: CreatePostToolUseHookParams): HookCallback =>
+  ({
+    onModeChange,
+    onPostHogResourceUsed,
+  }: CreatePostToolUseHookParams): HookCallback =>
   async (
     input: HookInput,
     toolUseID: string | undefined,
@@ -191,6 +196,14 @@ export const createPostToolUseHook =
         await onModeChange("plan");
       }
 
+      // Record PostHog product usage from the MCP exec dispatcher. Only the
+      // `call <sub-tool>` verb counts as "used a resource" — extractPostHogSubTool
+      // matches that verb and ignores introspection (tools/info/schema/search).
+      if (onPostHogResourceUsed && isPostHogExecTool(toolName)) {
+        const subTool = extractPostHogSubTool(input.tool_input);
+        if (subTool) onPostHogResourceUsed(subTool);
+      }
+
       if (toolUseID) {
         const onPostToolUseHook =
           toolUseCallbacks[toolUseID]?.onPostToolUseHook;