feat: display subagents on root allocator card

Author: EdSDR

apps/torus-portal/src/app/(pages)/root-allocator/_components/agent-card.tsx

@@ -18,6 +18,8 @@ interface AgentCardProps {
   percComputedWeight: number | null;
   weightFactor: number | null;
   isWhitelisted: boolean;
+  /** For root agents: count of all connected agents in their swarm */
+  subagentCount?: number;
 }
 
 export function AgentCard(props: Readonly<AgentCardProps>) {
@@ -118,6 +120,7 @@ export function AgentCard(props: Readonly<AgentCardProps>) {
       isMetadataLoading={isMetadataLoading}
       userWeightPower={userWeightPower}
       isWhitelisted={props.isWhitelisted}
+      subagentCount={props.subagentCount}
     />
   );
 }

apps/torus-portal/src/app/(pages)/root-allocator/_components/infinite-agent-list.tsx

@@ -4,7 +4,7 @@ import type { RouterOutputs } from "@torus-ts/api";
 import { AgentItemSkeleton } from "@torus-ts/ui/components/agent-card/agent-card-skeleton-loader";
 import { InfiniteList } from "@torus-ts/ui/components/infinite-list";
 import { api } from "~/trpc/react";
-import { useEffect } from "react";
+import { useEffect, useMemo } from "react";
 import { AgentCard } from "./agent-card";
 
 type InfiniteAgentData = RouterOutputs["agent"]["infinite"];
@@ -45,6 +45,9 @@ export function InfiniteAgentList({
     },
   );
 
+  // Fetch agent connection counts for displaying subagent/parent counts
+  const { data: connectionCounts } = api.agent.agentConnectionCounts.useQuery();
+
   // Log error to console and treat as empty list
   useEffect(() => {
     if (error) {
@@ -55,6 +58,12 @@ export function InfiniteAgentList({
   const agents: AgentType[] =
     data?.pages.flatMap((page: InfiniteAgentData) => page.agents) ?? [];
 
+  // Create lookup function for subagent counts
+  const getSubagentCount = useMemo(() => {
+    if (!connectionCounts) return (_key: string) => undefined;
+    return (agentKey: string) => connectionCounts.subagentCounts[agentKey];
+  }, [connectionCounts]);
+
   return (
     <InfiniteList
       items={agents}
@@ -68,6 +77,7 @@ export function InfiniteAgentList({
           registrationBlock={agent.registrationBlock}
           percComputedWeight={agent.percComputedWeight}
           isWhitelisted={agent.isWhitelisted ?? false}
+          subagentCount={getSubagentCount(agent.key)}
         />
       )}
       getItemKey={(agent: AgentType, index: number) =>

packages/api/src/router/agent/agent.ts

@@ -2,7 +2,10 @@ import { and, eq, gte, inArray, isNull, max, sql } from "@torus-ts/db";
 import {
   agentSchema,
   computedAgentWeightSchema,
+  emissionDistributionTargetsSchema,
+  namespacePermissionsSchema,
   penalizeAgentVotesSchema,
+  permissionsSchema,
 } from "@torus-ts/db/schema";
 import type { TRPCRouterRecord } from "@trpc/server";
 import { z } from "zod";
@@ -408,4 +411,134 @@ export const agentRouter = {
       penalties: penaltiesByAgent[agent.key] ?? [],
     }));
   }),
+
+  /**
+   * Returns connection counts for agents:
+   * - subagentCounts: For root agents, the count of all connected agents in their swarm
+   * - parentCounts: For all agents, the count of root agents that grant permissions to them
+   */
+  agentConnectionCounts: publicProcedure.query(async ({ ctx }) => {
+    // 1. Fetch all relationships from multiple sources
+    // Source 1: Base permissions (grantorAccountId -> granteeAccountId)
+    const basePermissions = await ctx.db
+      .select({
+        grantor: permissionsSchema.grantorAccountId,
+        grantee: permissionsSchema.granteeAccountId,
+      })
+      .from(permissionsSchema)
+      .where(isNull(permissionsSchema.deletedAt));
+
+    // Source 2: Namespace permissions (grantor -> recipient)
+    const namespaceRelations = await ctx.db
+      .select({
+        grantor: permissionsSchema.grantorAccountId,
+        grantee: namespacePermissionsSchema.recipient,
+      })
+      .from(namespacePermissionsSchema)
+      .innerJoin(
+        permissionsSchema,
+        eq(
+          namespacePermissionsSchema.permissionId,
+          permissionsSchema.permissionId,
+        ),
+      )
+      .where(isNull(permissionsSchema.deletedAt));
+
+    // Source 3: Emission distribution targets (grantor -> targetAccountId)
+    const emissionTargets = await ctx.db
+      .select({
+        grantor: permissionsSchema.grantorAccountId,
+        grantee: emissionDistributionTargetsSchema.targetAccountId,
+      })
+      .from(emissionDistributionTargetsSchema)
+      .innerJoin(
+        permissionsSchema,
+        eq(
+          emissionDistributionTargetsSchema.permissionId,
+          permissionsSchema.permissionId,
+        ),
+      )
+      .where(isNull(permissionsSchema.deletedAt));
+
+    // 2. Fetch whitelisted (root) agents
+    const whitelistedAgents = await ctx.db
+      .select({ key: agentSchema.key })
+      .from(agentSchema)
+      .where(
+        and(eq(agentSchema.isWhitelisted, true), isNull(agentSchema.deletedAt)),
+      );
+
+    const whitelistedSet = new Set(whitelistedAgents.map((a) => a.key));
+
+    // 3. Build adjacency lists from all relationship sources
+    const adjacencyList = new Map<string, Set<string>>();
+    const reverseAdjacencyList = new Map<string, Set<string>>();
+
+    const addRelation = (grantor: string, grantee: string | null) => {
+      if (!grantee) return;
+
+      // Forward: grantor -> grantee (for subagent traversal)
+      const grantorNeighbors = adjacencyList.get(grantor);
+      if (grantorNeighbors) {
+        grantorNeighbors.add(grantee);
+      } else {
+        adjacencyList.set(grantor, new Set([grantee]));
+      }
+
+      // Reverse: grantee -> grantor (for parent lookup)
+      const granteeNeighbors = reverseAdjacencyList.get(grantee);
+      if (granteeNeighbors) {
+        granteeNeighbors.add(grantor);
+      } else {
+        reverseAdjacencyList.set(grantee, new Set([grantor]));
+      }
+    };
+
+    // Add relationships from all sources
+    for (const p of basePermissions) {
+      addRelation(p.grantor, p.grantee);
+    }
+    for (const p of namespaceRelations) {
+      addRelation(p.grantor, p.grantee);
+    }
+    for (const p of emissionTargets) {
+      addRelation(p.grantor, p.grantee);
+    }
+
+    // 4. Calculate subagent counts for root agents (BFS traversal)
+    const subagentCounts: Record<string, number> = {};
+    for (const rootKey of whitelistedSet) {
+      const visited = new Set<string>();
+      const queue = [rootKey];
+
+      while (queue.length > 0) {
+        const current = queue.shift();
+        if (!current || visited.has(current)) continue;
+        visited.add(current);
+
+        const neighbors = adjacencyList.get(current);
+        if (neighbors) {
+          for (const neighbor of neighbors) {
+            if (!visited.has(neighbor)) {
+              queue.push(neighbor);
+            }
+          }
+        }
+      }
+
+      visited.delete(rootKey); // Don't count self
+      subagentCounts[rootKey] = visited.size;
+    }
+
+    // 5. Calculate parent counts for all agents (only counting root agent parents)
+    const parentCounts: Record<string, number> = {};
+    for (const [grantee, grantors] of reverseAdjacencyList) {
+      const rootParents = [...grantors].filter((g) => whitelistedSet.has(g));
+      if (rootParents.length > 0) {
+        parentCounts[grantee] = rootParents.length;
+      }
+    }
+
+    return { subagentCounts, parentCounts };
+  }),
 } satisfies TRPCRouterRecord;

packages/ui/src/components/agent-card/agent-card-header.tsx

@@ -17,6 +17,8 @@ export interface AgentCardHeaderProps {
   isAgentSelected?: boolean;
   isWhitelisted?: boolean;
   isMetadataLoading?: boolean;
+  /** For root agents: count of all connected agents in their swarm */
+  subagentCount?: number;
 }
 
 function AgentBadge({
@@ -64,6 +66,7 @@ export function AgentCardHeader({
   isAgentSelected,
   isWhitelisted,
   isMetadataLoading = false,
+  subagentCount,
 }: AgentCardHeaderProps) {
   const socialsList = buildSocials(socials, website);
 
@@ -83,7 +86,14 @@ export function AgentCardHeader({
             {name}
           </h2>
           <div className="flex w-full items-center justify-between gap-1 md:absolute md:inset-x-0 md:top-0">
-            <AgentCardSocialsInfo socials={socialsList} />
+            <div className="flex items-center gap-1">
+              <AgentCardSocialsInfo socials={socialsList} />
+              {isWhitelisted && subagentCount !== undefined && subagentCount > 0 && (
+                <Badge variant="secondary" className="whitespace-nowrap">
+                  {subagentCount} Subagent{subagentCount !== 1 ? "s" : ""}
+                </Badge>
+              )}
+            </div>
             <AgentBadge
               isAgentSelected={isAgentSelected}
               isAgentDelegated={isAgentDelegated}

packages/ui/src/components/agent-card/agent-card.tsx

@@ -77,6 +77,8 @@ export interface AgentCardProps {
   isMetadataLoading?: boolean;
   footerContent?: React.ReactNode;
   userWeightPower?: string | bigint | null;
+  /** For root agents: count of all connected agents in their swarm */
+  subagentCount?: number;
 }
 
 export function AgentCard(props: Readonly<AgentCardProps>) {
@@ -103,6 +105,7 @@ export function AgentCard(props: Readonly<AgentCardProps>) {
     isMetadataLoading = false,
     footerContent,
     userWeightPower,
+    subagentCount,
   } = props;
 
   const cardContent = (
@@ -117,6 +120,7 @@ export function AgentCard(props: Readonly<AgentCardProps>) {
         isAgentSelected={isAgentSelected}
         isWhitelisted={isWhitelisted}
         isMetadataLoading={isMetadataLoading}
+        subagentCount={subagentCount}
       />
 
       <AgentCardContent