feat: implement Radar backend tRPC procedures with repository extensions

Add five new tRPC query procedures powering the Radar page's per-agent
behavioral metrics (questions asked, subagent spawns, compaction events,
inter-agent messages) plus the batch repository methods they require.

Repository changes:
- LogChunkRepository: add findByAgentIds() for batch fetching without N+1
- ConversationRepository: add countByFromAgentIds() and findByFromAgentId()
- Drizzle adapters: implement all three new methods using inArray()
- InMemoryConversationRepository (integration test): implement new methods

tRPC procedures added:
- agent.listForRadar: filtered agent list with per-agent metrics computed
  from log chunks (questionsCount, subagentsCount, compactionsCount) and
  conversation counts (messagesCount); supports timeRange/status/mode/initiative filters
- agent.getCompactionEvents: compact system init chunks for one agent (cap 200)
- agent.getSubagentSpawns: Agent tool_use entries with prompt preview (cap 200)
- agent.getQuestionsAsked: AskUserQuestion tool calls with questions array (cap 200)
- conversation.getByFromAgent: conversations by fromAgentId with toAgentName resolved

All 13 new unit tests pass; existing test suite unaffected.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

apps/server/db/repositories/conversation-repository.ts

@@ -20,4 +20,18 @@ export interface ConversationRepository {
   findById(id: string): Promise<Conversation | null>;
   findPendingForAgent(toAgentId: string): Promise<Conversation[]>;
   answer(id: string, answer: string): Promise<Conversation | null>;
+
+  /**
+   * Count conversations grouped by fromAgentId for a batch of agent IDs.
+   * Returns only agents that have at least one conversation (count > 0).
+   * Used by listForRadar to compute messagesCount without N+1 queries.
+   */
+  countByFromAgentIds(agentIds: string[]): Promise<{ agentId: string; count: number }[]>;
+
+  /**
+   * Find all conversations initiated by a given agent, ordered by createdAt ascending.
+   * Used by conversation.getByFromAgent drilldown procedure.
+   * Cap at 200 results.
+   */
+  findByFromAgentId(agentId: string): Promise<Conversation[]>;
 }

apps/server/db/repositories/drizzle/conversation.ts

@@ -4,7 +4,7 @@
  * Implements ConversationRepository interface using Drizzle ORM.
  */
 
-import { eq, and, asc } from 'drizzle-orm';
+import { eq, and, asc, count, inArray } from 'drizzle-orm';
 import { nanoid } from 'nanoid';
 import type { DrizzleDatabase } from '../../index.js';
 import { conversations, type Conversation } from '../../schema.js';
@@ -64,4 +64,26 @@ export class DrizzleConversationRepository implements ConversationRepository {
       .where(eq(conversations.id, id));
     return this.findById(id);
   }
+
+  async countByFromAgentIds(agentIds: string[]): Promise<{ agentId: string; count: number }[]> {
+    if (agentIds.length === 0) return [];
+    const rows = await this.db
+      .select({
+        agentId: conversations.fromAgentId,
+        count: count(),
+      })
+      .from(conversations)
+      .where(inArray(conversations.fromAgentId, agentIds))
+      .groupBy(conversations.fromAgentId);
+    return rows.map(r => ({ agentId: r.agentId, count: Number(r.count) }));
+  }
+
+  async findByFromAgentId(agentId: string): Promise<Conversation[]> {
+    return this.db
+      .select()
+      .from(conversations)
+      .where(eq(conversations.fromAgentId, agentId))
+      .orderBy(asc(conversations.createdAt))
+      .limit(200);
+  }
 }

apps/server/db/repositories/drizzle/log-chunk.ts

@@ -4,7 +4,7 @@
  * Implements LogChunkRepository interface using Drizzle ORM.
  */
 
-import { eq, asc, max } from 'drizzle-orm';
+import { eq, asc, max, inArray } from 'drizzle-orm';
 import { nanoid } from 'nanoid';
 import type { DrizzleDatabase } from '../../index.js';
 import { agentLogChunks } from '../../schema.js';
@@ -41,6 +41,20 @@ export class DrizzleLogChunkRepository implements LogChunkRepository {
       .orderBy(asc(agentLogChunks.createdAt));
   }
 
+  async findByAgentIds(agentIds: string[]): Promise<{ agentId: string; content: string; sessionNumber: number; createdAt: Date }[]> {
+    if (agentIds.length === 0) return [];
+    return this.db
+      .select({
+        agentId: agentLogChunks.agentId,
+        content: agentLogChunks.content,
+        sessionNumber: agentLogChunks.sessionNumber,
+        createdAt: agentLogChunks.createdAt,
+      })
+      .from(agentLogChunks)
+      .where(inArray(agentLogChunks.agentId, agentIds))
+      .orderBy(asc(agentLogChunks.createdAt));
+  }
+
   async deleteByAgentId(agentId: string): Promise<void> {
     await this.db
       .delete(agentLogChunks)

apps/server/db/repositories/log-chunk-repository.ts

@@ -17,6 +17,13 @@ export interface LogChunkRepository {
 
   findByAgentId(agentId: string): Promise<Pick<AgentLogChunk, 'content' | 'sessionNumber' | 'createdAt'>[]>;
 
+  /**
+   * Batch-fetch chunks for multiple agent IDs in a single query.
+   * Returns chunks ordered by createdAt ascending.
+   * agentId field is included so results can be grouped by agent.
+   */
+  findByAgentIds(agentIds: string[]): Promise<{ agentId: string; content: string; sessionNumber: number; createdAt: Date }[]>;
+
   deleteByAgentId(agentId: string): Promise<void>;
 
   getSessionCount(agentId: string): Promise<number>;