@sentry/junior 0.108.0 → 0.110.0

package/dist/api.js

@@ -2,6 +2,9 @@ import {
   activityDays,
   actorDirectoryReportSchema,
   actorProfileReportSchema,
+  apiErrorSchema,
+  archiveConversationBodySchema,
+  archiveConversationResponseSchema,
   conversationDetailReportSchema,
   conversationFeedQuerySchema,
   conversationFeedSchema,
@@ -12,50 +15,51 @@ import {
   locationDirectoryReportSchema,
   locationParamsSchema,
   personParamsSchema
-} from "./chunk-PUAMO4PI.js";
+} from "./chunk-FPK7XY3F.js";
 import {
   buildSentryConversationUrl,
   formatSlackConversationRedactedLabel,
-  readConversationEventPrivacySnapshot,
   readHealthReport,
   resolveSlackConversationContextFromThreadId
-} from "./chunk-XKB7LGIW.js";
+} from "./chunk-3S7YYHBI.js";
 import {
+  healthReportSchema,
   pluginOperationalReportFeedSchema,
   pluginReportsSchema,
   runtimeInfoReportSchema,
   skillReportsSchema
-} from "./chunk-CEA3A3UA.js";
+} from "./chunk-2ZTTXTSZ.js";
 import {
   agentTurnUsageSchema,
   hasAgentTurnUsage
 } from "./chunk-MU6HHZEN.js";
 import "./chunk-PDO5BLNM.js";
-import "./chunk-VH6KWKG2.js";
+import "./chunk-L5XQPJ7T.js";
 import {
   decodeStoredConversationEvent,
   getDb,
-  getSqlExecutor,
+  getSqlExecutor
+} from "./chunk-4QU44P7Q.js";
+import {
   juniorConversationEvents,
   juniorConversations,
   juniorIdentities,
   juniorUsers
-} from "./chunk-TE4QHJH4.js";
+} from "./chunk-JQFJO5WH.js";
 import "./chunk-4ZNGQH7C.js";
-import "./chunk-SS67LUOK.js";
+import "./chunk-WNOVRQ67.js";
 import {
   juniorDestinations
 } from "./chunk-VFUK3X5B.js";
 import {
   canExposeConversationPayload,
-  parseSlackThreadId,
-  resolveConversationPrivacy
-} from "./chunk-RT5BUHR5.js";
-import "./chunk-B7PUBQQM.js";
-import "./chunk-O24R4DCK.js";
-import "./chunk-OB42YVAE.js";
+  parseSlackThreadId
+} from "./chunk-6Y5L4BOM.js";
+import "./chunk-IYKPU7H6.js";
+import "./chunk-42WRQLJ6.js";
 import "./chunk-6GWA276C.js";
-import "./chunk-7FBGKXPE.js";
+import "./chunk-W75ZPAGG.js";
+import "./chunk-ZKIOWEFL.js";
 import "./chunk-MLKGABMK.js";
 
 // src/api.ts
@@ -64,32 +68,50 @@ import { Hono as Hono4 } from "hono";
 // src/api/conversations/routes.ts
 import { Hono } from "hono";
 
-// src/api/conversations/archive.ts
-import { and, eq, isNotNull } from "drizzle-orm";
-import { HTTPException as HTTPException2 } from "hono/http-exception";
-import { z } from "zod";
-
 // src/api/http.ts
 import { HTTPException } from "hono/http-exception";
+function jsonResponse(schema, value, init) {
+  return Response.json(schema.parse(value), init);
+}
+function throwApiError(status, message2, cause) {
+  throw new HTTPException(status, {
+    ...cause === void 0 ? {} : { cause },
+    message: message2,
+    res: jsonResponse(apiErrorSchema, { error: message2 }, { status })
+  });
+}
 function parseParams(schema, params) {
   const result = schema.safeParse(params);
   if (result.success) return result.data;
-  throw new HTTPException(400, {
-    cause: result.error,
-    message: "Invalid route parameters."
-  });
+  return throwApiError(400, "Invalid route parameters.", result.error);
 }
 function parseQuery(schema, query) {
   const result = schema.safeParse(query);
   if (result.success) return result.data;
-  throw new HTTPException(400, {
-    cause: result.error,
-    message: "Invalid query parameters."
-  });
+  return throwApiError(400, "Invalid query parameters.", result.error);
+}
+function parseBody(schema, body) {
+  const result = schema.safeParse(body);
+  if (result.success) return result.data;
+  return throwApiError(400, "Invalid request body.", result.error);
+}
+
+// src/api/route.ts
+function defineApiRoute(route) {
+  return route;
+}
+function registerApiRoutes(app, routes5) {
+  for (const route of routes5) {
+    app.on(
+      route.method,
+      route.path,
+      async (context) => jsonResponse(route.responseSchema, await route.handler(context))
+    );
+  }
 }
 
 // src/api/conversations/archive.ts
-var archiveBodySchema = z.object({ archived: z.boolean(), lastSeenAt: z.string().datetime() }).strict();
+import { and, eq, isNotNull } from "drizzle-orm";
 async function archiveIfUnchanged(args) {
   const db = getDb();
   const rows = await db.update(juniorConversations).set({ archivedAt: args.archived ? /* @__PURE__ */ new Date() : null }).where(
@@ -107,9 +129,10 @@ async function archiveIfUnchanged(args) {
   if (!args.archived && existing.archivedAt === null) return "updated";
   return "conflict";
 }
-var archive_default = {
+var archive_default = defineApiRoute({
   method: "patch",
   path: "/:conversationId/archive",
+  responseSchema: archiveConversationResponseSchema,
   handler: async (c) => {
     const { conversationId } = parseParams(
       conversationParamsSchema,
@@ -119,35 +142,22 @@ var archive_default = {
     try {
       input = await c.req.json();
     } catch (error) {
-      throw new HTTPException2(400, {
-        cause: error,
-        message: "Invalid request body."
-      });
+      throwApiError(400, "Invalid request body.", error);
     }
-    const parsed = archiveBodySchema.safeParse(input);
-    if (!parsed.success) {
-      throw new HTTPException2(400, {
-        cause: parsed.error,
-        message: "Invalid request body."
-      });
-    }
-    const body = parsed.data;
+    const body = parseBody(archiveConversationBodySchema, input);
     const result = await archiveIfUnchanged({ ...body, conversationId });
     if (result === "not_found") {
-      return Response.json(
-        { error: "Conversation not found." },
-        { status: 404 }
-      );
+      throwApiError(404, "Conversation not found.");
     }
     if (result === "conflict") {
-      return Response.json(
-        { error: "Conversation received new activity." },
-        { status: 409 }
-      );
+      throwApiError(409, "Conversation received new activity.");
     }
-    return Response.json({ archived: body.archived });
+    return { archived: body.archived };
   }
-};
+});
+
+// src/api/conversations/detail.ts
+import { and as and5, asc as asc2, eq as eq6, getTableColumns, inArray as inArray3, sql as sql3 } from "drizzle-orm";
 
 // src/chat/pi/sql-model-usage.ts
 import { and as and2, eq as eq2, sql } from "drizzle-orm";
@@ -216,7 +226,7 @@ function usageFromRow(row) {
   };
   return hasAgentTurnUsage(result) ? agentTurnUsageSchema.parse(result) : void 0;
 }
-async function readConversationModelUsageFromSql(executor, conversationId) {
+async function readConversationModelUsageFromSql(executor, options) {
   const modelId = sql`concat(${message}->>'provider', '/', ${message}->>'model')`;
   const inputTokens = token("input", "inputTokens");
   const outputTokens = token("output", "outputTokens");
@@ -242,9 +252,15 @@ async function readConversationModelUsageFromSql(executor, conversationId) {
     costCacheRead: summedCost(nonnegativeNumber(cost, "cacheRead")),
     costCacheWrite: summedCost(nonnegativeNumber(cost, "cacheWrite")),
     costTotal: summedCost(nonnegativeNumber(cost, "total"))
-  }).from(juniorConversationEvents).where(
+  }).from(juniorConversationEvents).innerJoin(
+    juniorConversations,
+    eq2(
+      juniorConversations.conversationId,
+      juniorConversationEvents.conversationId
+    )
+  ).where(
     and2(
-      eq2(juniorConversationEvents.conversationId, conversationId),
+      options.includeDescendants ? eq2(juniorConversations.rootConversationId, options.conversationId) : eq2(juniorConversationEvents.conversationId, options.conversationId),
       eq2(juniorConversationEvents.type, "agent_step"),
       sql`${message}->>'role' = 'assistant'`,
       sql`jsonb_typeof(${message}->'provider') = 'string'`,
@@ -260,9 +276,11 @@ async function readConversationModelUsageFromSql(executor, conversationId) {
 }
 
 // src/api/conversations/events.ts
+import { z } from "zod";
 var conversationReportSourceEventTypes = [
   "message",
   "message_handled",
+  "agent_step",
   "tool_execution_started",
   "turn_started",
   "turn_completed",
@@ -272,6 +290,80 @@ var conversationReportSourceEventTypes = [
   "subagent_started",
   "subagent_ended"
 ];
+var reportingAssistantMessageSchema = z.object({
+  role: z.literal("assistant"),
+  content: z.array(z.unknown())
+}).passthrough();
+var reportingToolCallPartSchema = z.object({
+  type: z.literal("toolCall"),
+  id: z.string().min(1),
+  name: z.string().min(1),
+  arguments: z.unknown()
+}).passthrough();
+var reportingToolResultMessageSchema = z.object({
+  role: z.literal("toolResult"),
+  toolCallId: z.string().min(1),
+  content: z.array(z.unknown()),
+  details: z.unknown().optional(),
+  isError: z.boolean().optional()
+}).passthrough();
+var reportingToolResultDetailsSchema = z.object({
+  ok: z.boolean().optional(),
+  status: z.string().optional()
+}).passthrough();
+var reportingTextPartSchema = z.object({ type: z.literal("text"), text: z.string() }).passthrough();
+var reportingMediaPartSchema = z.object({
+  type: z.enum(["image", "audio"]),
+  mimeType: z.string().min(1).optional()
+}).passthrough();
+function sanitizeModelContentPart(value) {
+  const text = reportingTextPartSchema.safeParse(value);
+  if (text.success) return { type: "text", text: text.data.text };
+  const media = reportingMediaPartSchema.safeParse(value);
+  if (!media.success) return void 0;
+  return {
+    type: media.data.type,
+    ...media.data.mimeType ? { mimeType: media.data.mimeType } : {}
+  };
+}
+function modelVisibleToolOutput(content) {
+  const sanitized = content.map(sanitizeModelContentPart).filter((part) => part !== void 0);
+  if (sanitized.length === 0) return void 0;
+  if (sanitized.length !== 1) return sanitized;
+  const only = sanitized[0];
+  return only.type === "text" ? only.text : only;
+}
+function reportToolCalls(args) {
+  const message2 = reportingAssistantMessageSchema.safeParse(args.message);
+  if (!message2.success) return void 0;
+  const calls = message2.data.content.flatMap((part) => {
+    const call = reportingToolCallPartSchema.safeParse(part);
+    if (!call.success) return [];
+    return [
+      {
+        toolCallId: call.data.id,
+        name: call.data.name,
+        ...args.canExposePayload && call.data.arguments !== void 0 ? { input: call.data.arguments } : {}
+      }
+    ];
+  });
+  return calls.length > 0 ? { type: "tool_calls", calls } : void 0;
+}
+function reportToolResult(args) {
+  const message2 = reportingToolResultMessageSchema.safeParse(args.message);
+  if (!message2.success) return void 0;
+  const details = reportingToolResultDetailsSchema.safeParse(
+    message2.data.details
+  );
+  const outcome = message2.data.isError === true || details.success && (details.data.ok === false || details.data.status === "error") ? "error" : "completed";
+  const output = modelVisibleToolOutput(message2.data.content);
+  return {
+    type: "tool_result",
+    toolCallId: message2.data.toolCallId,
+    outcome,
+    ...args.canExposePayload && output !== void 0 ? { output } : {}
+  };
+}
 function reportEventData(args) {
   const { data } = args;
   switch (data.type) {
@@ -280,6 +372,7 @@ function reportEventData(args) {
         type: "message",
         messageId: data.messageId,
         role: data.role,
+        ...typeof data.meta?.eventType === "string" ? { eventType: data.meta.eventType } : {},
         ...args.canExposePayload ? { text: data.text } : { redacted: true }
       };
     case "message_handled":
@@ -314,21 +407,28 @@ function reportEventData(args) {
 }
 function projectConversationReportEvents(args) {
   const subagentStarts = /* @__PURE__ */ new Map();
-  const toolStarts = /* @__PURE__ */ new Map();
   const projected = [];
   for (const event of args.events) {
     let data;
-    if (event.data.type === "tool_execution_started") {
-      toolStarts.set(event.data.toolCallId, event.seq);
-      data = { type: "tool_started", name: event.data.toolName };
+    if (event.data.type === "agent_step") {
+      const reportArgs = {
+        canExposePayload: args.canExposePayload,
+        message: event.data.message
+      };
+      data = reportToolCalls(reportArgs) ?? reportToolResult(reportArgs);
+    } else if (event.data.type === "tool_execution_started") {
+      data = {
+        type: "tool_started",
+        toolCallId: event.data.toolCallId,
+        name: event.data.toolName
+      };
     } else if (event.data.type === "subagent_started") {
       subagentStarts.set(event.data.subagentInvocationId, event.seq);
-      const toolStartedSeq = event.data.parentToolCallId ? toolStarts.get(event.data.parentToolCallId) : void 0;
       data = {
         type: "subagent_started",
         childConversationId: event.data.childConversationId,
         subagentKind: event.data.subagentKind,
-        ...toolStartedSeq === void 0 ? {} : { toolStartedSeq }
+        ...event.data.parentToolCallId ? { parentToolCallId: event.data.parentToolCallId } : {}
       };
     } else if (event.data.type === "subagent_ended") {
       const startedSeq = subagentStarts.get(event.data.subagentInvocationId);
@@ -340,10 +440,12 @@ function projectConversationReportEvents(args) {
         };
       }
     } else if (event.data.type === "handoff") {
-      const toolStartedSeq = event.data.triggeringToolCallId ? toolStarts.get(event.data.triggeringToolCallId) : void 0;
       data = {
         type: "handoff",
-        ...toolStartedSeq === void 0 ? {} : { toolStartedSeq }
+        modelProfile: event.data.modelProfile,
+        modelId: event.data.modelId,
+        ...event.data.reasoningLevel ? { reasoningLevel: event.data.reasoningLevel } : {},
+        ...event.data.triggeringToolCallId ? { triggeringToolCallId: event.data.triggeringToolCallId } : {}
       };
     } else {
       data = reportEventData({
@@ -364,7 +466,7 @@ function projectConversationReportEvents(args) {
 }
 
 // src/api/conversations/list.ts
-import { and as and3, asc, desc, eq as eq3, isNull } from "drizzle-orm";
+import { and as and4, asc, desc, eq as eq5, isNull as isNull2 } from "drizzle-orm";
 
 // src/api/conversations/shared.ts
 function slackStatsLocationLabel(input) {
@@ -435,16 +537,13 @@ function titleFromConversation(args) {
     threadId: args.conversation.conversationId,
     channelName: effectiveChannelName
   });
-  const privateLabel = resolveConversationPrivacy({
-    conversationId: args.conversation.conversationId,
-    visibility: args.conversation.visibility
-  }) !== "public" ? privateConversationLabel(slackConversation) : void 0;
+  const privateLabel = args.canViewPrivateContent ? void 0 : privateConversationLabel(slackConversation);
   return privateLabel ?? args.conversation.title ?? slackStatsLocationLabel({
     channel: slackThread?.channelId,
     channelName: effectiveChannelName
   }) ?? surfaceFallbackLabel(args.surface);
 }
-function channelNameFromConversation(conversation) {
+function channelNameFromConversation(conversation, canViewPrivateContent) {
   const effectiveChannelName = conversation.channelName;
   const slackThread = parseSlackThreadId(conversation.conversationId);
   if (!effectiveChannelName && !slackThread) {
@@ -454,39 +553,45 @@ function channelNameFromConversation(conversation) {
     threadId: conversation.conversationId,
     channelName: effectiveChannelName
   });
-  if (resolveConversationPrivacy({
-    conversationId: conversation.conversationId,
-    visibility: conversation.visibility
-  }) !== "public") {
+  if (!canViewPrivateContent) {
     return privateConversationLabel(slackConversation);
   }
   return effectiveChannelName;
 }
-function channelNameRedactedFromConversation(conversation) {
+function channelNameRedactedFromConversation(conversation, canViewPrivateContent) {
   const effectiveChannelName = conversation.channelName;
   const slackThread = parseSlackThreadId(conversation.conversationId);
   if (!effectiveChannelName && !slackThread) {
     return false;
   }
-  return resolveConversationPrivacy({
-    conversationId: conversation.conversationId,
-    visibility: conversation.visibility
-  }) !== "public";
+  return !canViewPrivateContent;
 }
 function conversationSummaryFromStoredConversation(args) {
-  const { conversation, durationMs, usage: usage2 } = args;
+  const { conversation, durationMs, usage: usage3 } = args;
+  const canViewPrivateContent = args.access?.canViewPrivateContent ?? false;
   const surface = surfaceFromSource(
     conversation.source,
     conversation.conversationId
   );
   const actorIdentity = actorIdentityReport(conversation.actor);
   const slackThread = parseSlackThreadId(conversation.conversationId);
-  const channelName = channelNameFromConversation(conversation);
-  const channelNameRedacted = channelNameRedactedFromConversation(conversation);
+  const channelName = channelNameFromConversation(
+    conversation,
+    canViewPrivateContent
+  );
+  const channelNameRedacted = channelNameRedactedFromConversation(
+    conversation,
+    canViewPrivateContent
+  );
   return {
     conversationId: conversation.conversationId,
     cumulativeDurationMs: durationMs,
-    displayTitle: titleFromConversation({ conversation, surface }),
+    displayTitle: titleFromConversation({
+      canViewPrivateContent,
+      conversation,
+      surface
+    }),
+    isParticipant: args.access?.isParticipant ?? false,
     lastProgressAt: new Date(
       conversation.execution.updatedAtMs ?? conversation.updatedAtMs
     ).toISOString(),
@@ -494,7 +599,7 @@ function conversationSummaryFromStoredConversation(args) {
     startedAt: new Date(conversation.createdAtMs).toISOString(),
     status: statusFromConversation(conversation),
     surface,
-    ...usage2 ? { cumulativeUsage: usage2 } : {},
+    ...usage3 ? { cumulativeUsage: usage3 } : {},
     ...actorIdentity ? { actorIdentity } : {},
     ...conversation.archivedAtMs ? { archivedAt: new Date(conversation.archivedAtMs).toISOString() } : {},
     ...slackThread ? { channel: slackThread.channelId } : {},
@@ -504,6 +609,163 @@ function conversationSummaryFromStoredConversation(args) {
   };
 }
 
+// src/api/conversations/access.ts
+import { eq as eq3, inArray } from "drizzle-orm";
+import { alias } from "drizzle-orm/pg-core";
+var rootConversation = alias(juniorConversations, "access_root_conversation");
+var rootDestination = alias(juniorDestinations, "access_root_destination");
+var rootIdentity = alias(juniorIdentities, "access_root_identity");
+async function readConversationAccessFromSql(db, conversationIds, verifiedViewerEmail) {
+  if (conversationIds.length === 0) return /* @__PURE__ */ new Map();
+  const normalizedViewerEmail = verifiedViewerEmail?.trim().toLowerCase() || void 0;
+  const rows = await db.select({
+    conversationId: juniorConversations.conversationId,
+    parentConversationId: juniorConversations.parentConversationId,
+    storedRootConversationId: juniorConversations.rootConversationId,
+    rootConversationId: rootConversation.conversationId,
+    rootParentConversationId: rootConversation.parentConversationId,
+    rootRootConversationId: rootConversation.rootConversationId,
+    visibility: rootDestination.visibility,
+    rootEmailNormalized: rootIdentity.emailNormalized,
+    rootEmailVerified: rootIdentity.emailVerified
+  }).from(juniorConversations).leftJoin(
+    rootConversation,
+    eq3(
+      rootConversation.conversationId,
+      juniorConversations.rootConversationId
+    )
+  ).leftJoin(
+    rootDestination,
+    eq3(rootDestination.id, rootConversation.destinationId)
+  ).leftJoin(
+    rootIdentity,
+    eq3(rootIdentity.id, rootConversation.actorIdentityId)
+  ).where(inArray(juniorConversations.conversationId, [...conversationIds]));
+  return new Map(
+    rows.map((row) => {
+      const hasValidRoot = row.rootConversationId !== null && row.rootConversationId === row.storedRootConversationId && row.rootRootConversationId === row.rootConversationId && row.rootParentConversationId === null && (row.parentConversationId !== null || row.storedRootConversationId === row.conversationId);
+      const validRootConversationId = hasValidRoot ? row.rootConversationId ?? void 0 : void 0;
+      const visibility = validRootConversationId === void 0 ? null : row.visibility;
+      const isParticipant = validRootConversationId !== void 0 && normalizedViewerEmail !== void 0 && row.rootEmailVerified === true && row.rootEmailNormalized === normalizedViewerEmail;
+      const canViewPrivateContent = isParticipant || validRootConversationId !== void 0 && canExposeConversationPayload({
+        conversationId: validRootConversationId,
+        ...visibility === "public" || visibility === "private" ? { visibility } : {}
+      });
+      return [
+        row.conversationId,
+        {
+          canViewPrivateContent,
+          isParticipant,
+          visibility
+        }
+      ];
+    })
+  );
+}
+
+// src/api/conversations/usage.ts
+import { and as and3, eq as eq4, inArray as inArray2, isNull, sql as sql2 } from "drizzle-orm";
+import { alias as alias2 } from "drizzle-orm/pg-core";
+var usage2 = juniorConversations.usage;
+var metricRootConversation = alias2(
+  juniorConversations,
+  "metric_root_conversation"
+);
+var componentFields = [
+  "inputTokens",
+  "outputTokens",
+  "cachedInputTokens",
+  "cacheCreationTokens"
+];
+function summedUsageNumber(field) {
+  return sql2`sum((${usage2}->>${field})::double precision)::double precision`;
+}
+function summedCostNumber(field) {
+  return sql2`round(
+    sum((${usage2}->'cost'->>${field})::numeric),
+    12
+  )::double precision`;
+}
+function usageFromAggregate(row) {
+  const components = {};
+  let componentTotal = 0;
+  for (const field of componentFields) {
+    const value = row[field];
+    if (value === null) continue;
+    components[field] = value;
+    componentTotal += value;
+  }
+  const cost2 = {
+    ...row.costInput === null ? {} : { input: row.costInput },
+    ...row.costOutput === null ? {} : { output: row.costOutput },
+    ...row.costCacheRead === null ? {} : { cacheRead: row.costCacheRead },
+    ...row.costCacheWrite === null ? {} : { cacheWrite: row.costCacheWrite },
+    ...row.costTotal === null ? {} : { total: row.costTotal }
+  };
+  const result = {
+    ...row.totalOnlyTokens === null ? components : { totalTokens: row.totalOnlyTokens + componentTotal },
+    ...row.reasoningTokens === null ? {} : { reasoningTokens: row.reasoningTokens },
+    ...Object.keys(cost2).length === 0 ? {} : { cost: cost2 }
+  };
+  return hasAgentTurnUsage(result) ? result : void 0;
+}
+async function readRootConversationMetricsFromSql(db, rootConversationIds) {
+  if (rootConversationIds.length === 0) return /* @__PURE__ */ new Map();
+  const hasComponents = sql2`coalesce(
+    ${usage2}->>'inputTokens',
+    ${usage2}->>'outputTokens',
+    ${usage2}->>'cachedInputTokens',
+    ${usage2}->>'cacheCreationTokens'
+  ) is not null`;
+  const rows = await db.select({
+    rootConversationId: juniorConversations.rootConversationId,
+    durationMs: sql2`coalesce(sum(${juniorConversations.durationMs}), 0)::double precision`,
+    inputTokens: summedUsageNumber("inputTokens"),
+    outputTokens: summedUsageNumber("outputTokens"),
+    cachedInputTokens: summedUsageNumber("cachedInputTokens"),
+    cacheCreationTokens: summedUsageNumber("cacheCreationTokens"),
+    totalOnlyTokens: sql2`sum(
+        case
+          when not (${hasComponents})
+          then (${usage2}->>'totalTokens')::double precision
+        end
+      )::double precision`,
+    reasoningTokens: summedUsageNumber("reasoningTokens"),
+    costInput: summedCostNumber("input"),
+    costOutput: summedCostNumber("output"),
+    costCacheRead: summedCostNumber("cacheRead"),
+    costCacheWrite: summedCostNumber("cacheWrite"),
+    costTotal: summedCostNumber("total")
+  }).from(juniorConversations).innerJoin(
+    metricRootConversation,
+    and3(
+      eq4(
+        metricRootConversation.conversationId,
+        juniorConversations.rootConversationId
+      ),
+      isNull(metricRootConversation.parentConversationId),
+      eq4(
+        metricRootConversation.rootConversationId,
+        metricRootConversation.conversationId
+      )
+    )
+  ).where(
+    inArray2(juniorConversations.rootConversationId, [...rootConversationIds])
+  ).groupBy(juniorConversations.rootConversationId);
+  return new Map(
+    rows.flatMap((row) => {
+      if (!row.rootConversationId) return [];
+      const usage3 = usageFromAggregate(row);
+      return [
+        [
+          row.rootConversationId,
+          { durationMs: row.durationMs, ...usage3 ? { usage: usage3 } : {} }
+        ]
+      ];
+    })
+  );
+}
+
 // src/api/conversations/list.ts
 var CONVERSATION_FEED_LIMIT = 50;
 async function conversationRows(db, limit, actorEmail) {
@@ -520,17 +782,17 @@ async function conversationRows(db, limit, actorEmail) {
     userDisplayName: juniorUsers.displayName
   }).from(juniorConversations).leftJoin(
     juniorDestinations,
-    eq3(juniorDestinations.id, juniorConversations.destinationId)
+    eq5(juniorDestinations.id, juniorConversations.destinationId)
   ).leftJoin(
     juniorIdentities,
-    eq3(juniorIdentities.id, juniorConversations.actorIdentityId)
-  ).leftJoin(juniorUsers, eq3(juniorUsers.id, juniorIdentities.userId)).where(
-    and3(
-      isNull(juniorConversations.parentConversationId),
-      isNull(juniorConversations.archivedAt),
-      actorEmail ? and3(
-        eq3(juniorIdentities.emailNormalized, actorEmail),
-        eq3(juniorIdentities.emailVerified, true)
+    eq5(juniorIdentities.id, juniorConversations.actorIdentityId)
+  ).leftJoin(juniorUsers, eq5(juniorUsers.id, juniorIdentities.userId)).where(
+    and4(
+      isNull2(juniorConversations.parentConversationId),
+      isNull2(juniorConversations.archivedAt),
+      actorEmail ? and4(
+        eq5(juniorIdentities.emailNormalized, actorEmail),
+        eq5(juniorIdentities.emailVerified, true)
       ) : void 0
     )
   ).orderBy(
@@ -565,10 +827,7 @@ function conversationFromRow(row) {
     ...value.channelName ? { channelName: value.channelName } : {},
     ...value.source ? { source: value.source } : {},
     ...value.title ? { title: value.title } : {},
-    ...value.transcriptPurgedAt ? { transcriptPurgedAtMs: value.transcriptPurgedAt.getTime() } : {},
-    ...row.destinationVisibility ? {
-      visibility: row.destinationVisibility === "public" ? "public" : "private"
-    } : {}
+    ...value.transcriptPurgedAt ? { transcriptPurgedAtMs: value.transcriptPurgedAt.getTime() } : {}
   };
 }
 async function readConversationRecordFromSql(conversationId) {
@@ -586,76 +845,110 @@ async function readConversationRecordFromSql(conversationId) {
     userDisplayName: juniorUsers.displayName
   }).from(juniorConversations).leftJoin(
     juniorDestinations,
-    eq3(juniorDestinations.id, juniorConversations.destinationId)
+    eq5(juniorDestinations.id, juniorConversations.destinationId)
   ).leftJoin(
     juniorIdentities,
-    eq3(juniorIdentities.id, juniorConversations.actorIdentityId)
-  ).leftJoin(juniorUsers, eq3(juniorUsers.id, juniorIdentities.userId)).where(eq3(juniorConversations.conversationId, conversationId)).limit(1);
+    eq5(juniorIdentities.id, juniorConversations.actorIdentityId)
+  ).leftJoin(juniorUsers, eq5(juniorUsers.id, juniorIdentities.userId)).where(eq5(juniorConversations.conversationId, conversationId)).limit(1);
   const row = rows[0];
   return row ? {
     conversation: conversationFromRow(row),
     durationMs: row.conversation.durationMs,
     ...row.destinationVisibility === "public" && row.destinationId ? { locationId: row.destinationId } : {},
-    usage: row.conversation.usage
+    usage: row.conversation.usage,
+    rootConversationId: row.conversation.rootConversationId
   } : void 0;
 }
 async function readConversationFeedFromSql(options = {}) {
   const nowMs = Date.now();
+  const db = getDb();
   const rows = await conversationRows(
-    getDb(),
+    db,
     options.limit ?? CONVERSATION_FEED_LIMIT,
     options.actorEmail
   );
+  const conversationIds = rows.map((row) => row.conversation.conversationId);
+  const [accessByConversation, metricsByRoot] = await Promise.all([
+    readConversationAccessFromSql(
+      db,
+      conversationIds,
+      options.verifiedViewerEmail
+    ),
+    readRootConversationMetricsFromSql(db, conversationIds)
+  ]);
   return {
-    conversations: rows.map(
-      (row) => conversationSummaryFromStoredConversation({
+    conversations: rows.map((row) => {
+      const metrics = metricsByRoot.get(row.conversation.conversationId);
+      return conversationSummaryFromStoredConversation({
         conversation: conversationFromRow(row),
-        durationMs: row.conversation.durationMs,
+        access: accessByConversation.get(row.conversation.conversationId),
+        durationMs: metrics?.durationMs ?? row.conversation.durationMs,
         ...row.destinationVisibility === "public" && row.destinationId ? { locationId: row.destinationId } : {},
-        usage: row.conversation.usage ?? void 0
-      })
-    ),
+        usage: metrics?.usage ?? row.conversation.usage ?? void 0
+      });
+    }),
     generatedAt: new Date(nowMs).toISOString(),
     source: "conversation_index"
   };
 }
 async function readConversationFeed(options = {}) {
   return conversationFeedSchema.parse(
-    await readConversationFeedFromSql({ actorEmail: options.actorEmail })
+    await readConversationFeedFromSql(options)
   );
 }
-var list_default = {
+var list_default = defineApiRoute({
   method: "get",
   path: "/",
+  responseSchema: conversationFeedSchema,
   handler: async (c) => {
     const { actorEmail } = parseQuery(
       conversationFeedQuerySchema,
       c.req.query()
     );
-    return Response.json(await readConversationFeed({ actorEmail }));
+    const verifiedViewerEmail = c.get("verifiedViewerEmail");
+    return readConversationFeed({
+      ...actorEmail ? { actorEmail } : {},
+      ...verifiedViewerEmail ? { verifiedViewerEmail } : {}
+    });
   }
-};
+});
 
 // src/api/conversations/detail.ts
+var conversationEventColumns = getTableColumns(juniorConversationEvents);
+async function readConversationReportEventRows(executor, conversationId) {
+  return executor.db().select({
+    ...conversationEventColumns,
+    // Replacement history is model context, never dashboard report data.
+    payload: sql3`case
+        when ${juniorConversationEvents.type} in ('compaction', 'handoff')
+        then jsonb_set(
+          ${juniorConversationEvents.payload},
+          '{replacementHistory}',
+          '[]'::jsonb
+        )
+        else ${juniorConversationEvents.payload}
+      end`
+  }).from(juniorConversationEvents).where(
+    and5(
+      eq6(juniorConversationEvents.conversationId, conversationId),
+      inArray3(juniorConversationEvents.type, [
+        ...conversationReportSourceEventTypes
+      ])
+    )
+  ).orderBy(asc2(juniorConversationEvents.seq));
+}
 function projectConversationDetail(args) {
   const { conversation } = args;
   const conversationId = conversation.conversationId;
   const transcriptPurgedAtMs = conversation.transcriptPurgedAtMs;
-  const { visibility: _storedVisibility, ...conversationWithoutVisibility } = conversation;
-  const authorizedConversation = {
-    ...conversationWithoutVisibility,
-    ...args.effectiveVisibility ? { visibility: args.effectiveVisibility } : {}
-  };
-  const canExposePayload = canExposeConversationPayload({
-    conversationId: args.privacyConversationId ?? conversationId,
-    visibility: args.effectiveVisibility
-  });
+  const canExposePayload = args.access?.canViewPrivateContent ?? false;
   const events = transcriptPurgedAtMs === void 0 ? args.events : [];
   const modelUsage = transcriptPurgedAtMs === void 0 ? args.modelUsage : [];
   const sentryConversationUrl = buildSentryConversationUrl(conversationId);
   return {
     ...conversationSummaryFromStoredConversation({
-      conversation: authorizedConversation,
+      access: args.access,
+      conversation,
       durationMs: args.durationMs,
       ...args.locationId ? { locationId: args.locationId } : {},
       usage: args.usage
@@ -673,19 +966,28 @@ function projectConversationDetail(args) {
     ...sentryConversationUrl ? { sentryConversationUrl } : {}
   };
 }
-async function readConversationDetailFromSql(conversationId) {
+async function readConversationDetailFromSql(conversationId, options) {
   const record = await readConversationRecordFromSql(conversationId);
   if (!record) return void 0;
   const executor = getSqlExecutor();
-  const [snapshot, modelUsage] = await Promise.all([
-    readConversationEventPrivacySnapshot(executor, {
+  const includeDescendantMetrics = record.rootConversationId === conversationId;
+  const [accessByConversation, eventRows, modelUsage, metricsByRoot] = await Promise.all([
+    readConversationAccessFromSql(
+      getDb(),
+      [conversationId],
+      options.verifiedViewerEmail
+    ),
+    readConversationReportEventRows(executor, conversationId),
+    record.conversation.transcriptPurgedAtMs === void 0 ? readConversationModelUsageFromSql(executor, {
       conversationId,
-      eventTypes: conversationReportSourceEventTypes
-    }),
-    record.conversation.transcriptPurgedAtMs === void 0 ? readConversationModelUsageFromSql(executor, conversationId) : Promise.resolve([])
+      includeDescendants: includeDescendantMetrics
+    }) : Promise.resolve([]),
+    readRootConversationMetricsFromSql(
+      getDb(),
+      includeDescendantMetrics ? [conversationId] : []
+    )
   ]);
-  if (!snapshot) return void 0;
-  const events = snapshot.events.map(
+  const events = eventRows.map(
     (row) => decodeStoredConversationEvent({
       schemaVersion: row.schemaVersion,
       seq: row.seq,
@@ -696,106 +998,121 @@ async function readConversationDetailFromSql(conversationId) {
       payload: row.payload
     })
   );
-  const effectiveVisibility = snapshot.visibility === "public" || snapshot.visibility === "private" ? snapshot.visibility : void 0;
+  const metrics = metricsByRoot.get(conversationId);
   return projectConversationDetail({
     ...record,
-    effectiveVisibility,
+    access: accessByConversation.get(conversationId),
+    durationMs: metrics?.durationMs ?? record.durationMs,
     events,
     modelUsage,
-    privacyConversationId: snapshot.rootConversationId,
-    usage: record.usage ?? void 0
+    usage: metrics?.usage ?? record.usage ?? void 0
   });
 }
-async function readConversationDetail(conversationId) {
-  const report = await readConversationDetailFromSql(conversationId);
+async function readConversationDetail(conversationId, options = {}) {
+  const report = await readConversationDetailFromSql(conversationId, options);
   return report ? conversationDetailReportSchema.parse(report) : void 0;
 }
-var detail_default = {
+var detail_default = defineApiRoute({
   method: "get",
   path: "/:conversationId",
+  responseSchema: conversationDetailReportSchema,
   handler: async (c) => {
     const { conversationId } = parseParams(
       conversationParamsSchema,
       c.req.param()
     );
-    const report = await readConversationDetail(conversationId);
-    return report ? Response.json(report) : Response.json({ error: "Conversation not found." }, { status: 404 });
+    const verifiedViewerEmail = c.get("verifiedViewerEmail");
+    const report = await readConversationDetail(
+      conversationId,
+      verifiedViewerEmail ? { verifiedViewerEmail } : {}
+    );
+    if (!report) throwApiError(404, "Conversation not found.");
+    return report;
   }
-};
+});
 
 // src/api/conversations/stats.query.ts
-import { and as and4, eq as eq4, gte, isNull as isNull2, lte, sql as sql3 } from "drizzle-orm";
+import { and as and6, eq as eq7, gte, isNull as isNull3, lte, sql as sql5 } from "drizzle-orm";
+import { alias as alias3 } from "drizzle-orm/pg-core";
 
 // src/api/conversations/aggregate.ts
-import { sql as sql2 } from "drizzle-orm";
-function tokenValue() {
-  return sql2`
+import { sql as sql4 } from "drizzle-orm";
+function tokenValue(source) {
+  return sql4`
     CASE
-      WHEN ${juniorConversations.usage}->>'totalTokens' IS NOT NULL
-        THEN (${juniorConversations.usage}->>'totalTokens')::double precision
       WHEN COALESCE(
-        ${juniorConversations.usage}->>'inputTokens',
-        ${juniorConversations.usage}->>'outputTokens',
-        ${juniorConversations.usage}->>'cachedInputTokens',
-        ${juniorConversations.usage}->>'cacheCreationTokens'
+        ${source.usage}->>'inputTokens',
+        ${source.usage}->>'outputTokens',
+        ${source.usage}->>'cachedInputTokens',
+        ${source.usage}->>'cacheCreationTokens'
       ) IS NOT NULL
-        THEN COALESCE((${juniorConversations.usage}->>'inputTokens')::double precision, 0)
-          + COALESCE((${juniorConversations.usage}->>'outputTokens')::double precision, 0)
-          + COALESCE((${juniorConversations.usage}->>'cachedInputTokens')::double precision, 0)
-          + COALESCE((${juniorConversations.usage}->>'cacheCreationTokens')::double precision, 0)
+        THEN COALESCE((${source.usage}->>'inputTokens')::double precision, 0)
+          + COALESCE((${source.usage}->>'outputTokens')::double precision, 0)
+          + COALESCE((${source.usage}->>'cachedInputTokens')::double precision, 0)
+          + COALESCE((${source.usage}->>'cacheCreationTokens')::double precision, 0)
+      WHEN ${source.usage}->>'totalTokens' IS NOT NULL
+        THEN (${source.usage}->>'totalTokens')::double precision
       ELSE NULL
     END
   `;
 }
-function costValue() {
-  return sql2`
+function costValue(source) {
+  return sql4`
     CASE
-      WHEN ${juniorConversations.usage}->'cost'->>'total' IS NOT NULL
-        THEN (${juniorConversations.usage}->'cost'->>'total')::double precision
+      WHEN ${source.usage}->'cost'->>'total' IS NOT NULL
+        THEN (${source.usage}->'cost'->>'total')::double precision
       WHEN COALESCE(
-        ${juniorConversations.usage}->'cost'->>'input',
-        ${juniorConversations.usage}->'cost'->>'output',
-        ${juniorConversations.usage}->'cost'->>'cacheRead',
-        ${juniorConversations.usage}->'cost'->>'cacheWrite'
+        ${source.usage}->'cost'->>'input',
+        ${source.usage}->'cost'->>'output',
+        ${source.usage}->'cost'->>'cacheRead',
+        ${source.usage}->'cost'->>'cacheWrite'
       ) IS NOT NULL
-        THEN COALESCE((${juniorConversations.usage}->'cost'->>'input')::double precision, 0)
-          + COALESCE((${juniorConversations.usage}->'cost'->>'output')::double precision, 0)
-          + COALESCE((${juniorConversations.usage}->'cost'->>'cacheRead')::double precision, 0)
-          + COALESCE((${juniorConversations.usage}->'cost'->>'cacheWrite')::double precision, 0)
+        THEN COALESCE((${source.usage}->'cost'->>'input')::double precision, 0)
+          + COALESCE((${source.usage}->'cost'->>'output')::double precision, 0)
+          + COALESCE((${source.usage}->'cost'->>'cacheRead')::double precision, 0)
+          + COALESCE((${source.usage}->'cost'->>'cacheWrite')::double precision, 0)
       ELSE NULL
     END
   `;
 }
-function conversationAggregateColumns() {
+function conversationAggregateColumns(sources) {
+  const metrics = sources?.metrics ?? juniorConversations;
+  const roots = sources?.roots ?? juniorConversations;
+  const conversationCount = sources ? sql4`COUNT(DISTINCT ${roots.conversationId})` : sql4`COUNT(*)`;
   return {
-    active: sql2`COUNT(*) FILTER (
-      WHERE ${juniorConversations.executionStatus} NOT IN ('idle', 'failed')
+    active: sql4`${conversationCount} FILTER (
+      WHERE ${roots.executionStatus} NOT IN ('idle', 'failed')
     )::integer`,
-    conversations: sql2`COUNT(*)::integer`,
-    costUsd: sql2`SUM(${costValue()})::double precision`,
-    durationMs: sql2`COALESCE(SUM(${juniorConversations.durationMs}), 0)::double precision`,
-    failed: sql2`COUNT(*) FILTER (
-      WHERE ${juniorConversations.executionStatus} = 'failed'
+    conversations: sql4`${conversationCount}::integer`,
+    costUsd: sql4`SUM(${costValue(metrics)})::double precision`,
+    durationMs: sql4`COALESCE(SUM(${metrics.durationMs}), 0)::double precision`,
+    failed: sql4`${conversationCount} FILTER (
+      WHERE ${roots.executionStatus} = 'failed'
     )::integer`,
-    tokens: sql2`SUM(${tokenValue()})::double precision`
+    tokens: sql4`SUM(${tokenValue(metrics)})::double precision`
   };
 }
 function conversationRangeColumns() {
   return {
-    firstSeenAt: sql2`MIN(${juniorConversations.createdAt})`.mapWith(
+    firstSeenAt: sql4`MIN(${juniorConversations.createdAt})`.mapWith(
       juniorConversations.createdAt
     ),
-    lastSeenAt: sql2`MAX(${juniorConversations.lastActivityAt})`.mapWith(
+    lastSeenAt: sql4`MAX(${juniorConversations.lastActivityAt})`.mapWith(
       juniorConversations.lastActivityAt
     )
   };
 }
 function conversationActiveDaysColumn() {
-  return sql2`COUNT(DISTINCT (${juniorConversations.lastActivityAt} AT TIME ZONE 'UTC')::date)::integer`;
+  return sql4`COUNT(DISTINCT (${juniorConversations.lastActivityAt} AT TIME ZONE 'UTC')::date)::integer`;
 }
 
 // src/api/conversations/stats.query.ts
 var WINDOW_DAYS = 90;
+var treeConversation = alias3(juniorConversations, "stats_tree_conversation");
+var treeAggregateColumns = conversationAggregateColumns({
+  metrics: treeConversation,
+  roots: juniorConversations
+});
 function emptyStatsItem(label) {
   return {
     active: 0,
@@ -850,8 +1167,8 @@ function statsItems(map) {
   );
 }
 function statsWhere(start, end) {
-  return and4(
-    isNull2(juniorConversations.parentConversationId),
+  return and6(
+    isNull3(juniorConversations.parentConversationId),
     gte(juniorConversations.lastActivityAt, start),
     lte(juniorConversations.lastActivityAt, end)
   );
@@ -884,12 +1201,18 @@ function metricDays(rows, endMs) {
 }
 async function aggregateStats(db, start, end) {
   const where = statsWhere(start, end);
-  const activityDate = sql3`TO_CHAR(
+  const activityDate = sql5`TO_CHAR(
     ${juniorConversations.lastActivityAt} AT TIME ZONE 'UTC',
     'YYYY-MM-DD'
   )`;
   const [totalsRows, actorRows, locationRows, metricRows] = await Promise.all([
-    db.select(conversationAggregateColumns()).from(juniorConversations).where(where),
+    db.select(treeAggregateColumns).from(juniorConversations).innerJoin(
+      treeConversation,
+      eq7(
+        treeConversation.rootConversationId,
+        juniorConversations.conversationId
+      )
+    ).where(where),
     db.select({
       identityDisplayName: juniorIdentities.displayName,
       identityEmail: juniorIdentities.emailNormalized,
@@ -897,11 +1220,17 @@ async function aggregateStats(db, start, end) {
       identitySubjectId: juniorIdentities.providerSubjectId,
       userDisplayName: juniorUsers.displayName,
       userEmail: juniorUsers.primaryEmailNormalized,
-      ...conversationAggregateColumns()
-    }).from(juniorConversations).leftJoin(
+      ...treeAggregateColumns
+    }).from(juniorConversations).innerJoin(
+      treeConversation,
+      eq7(
+        treeConversation.rootConversationId,
+        juniorConversations.conversationId
+      )
+    ).leftJoin(
       juniorIdentities,
-      eq4(juniorIdentities.id, juniorConversations.actorIdentityId)
-    ).leftJoin(juniorUsers, eq4(juniorUsers.id, juniorIdentities.userId)).where(where).groupBy(
+      eq7(juniorIdentities.id, juniorConversations.actorIdentityId)
+    ).leftJoin(juniorUsers, eq7(juniorUsers.id, juniorIdentities.userId)).where(where).groupBy(
       juniorIdentities.displayName,
       juniorIdentities.emailNormalized,
       juniorIdentities.handle,
@@ -916,10 +1245,16 @@ async function aggregateStats(db, start, end) {
       destinationProvider: juniorDestinations.provider,
       destinationVisibility: juniorDestinations.visibility,
       source: juniorConversations.source,
-      ...conversationAggregateColumns()
-    }).from(juniorConversations).leftJoin(
+      ...treeAggregateColumns
+    }).from(juniorConversations).innerJoin(
+      treeConversation,
+      eq7(
+        treeConversation.rootConversationId,
+        juniorConversations.conversationId
+      )
+    ).leftJoin(
       juniorDestinations,
-      eq4(juniorDestinations.id, juniorConversations.destinationId)
+      eq7(juniorDestinations.id, juniorConversations.destinationId)
     ).where(where).groupBy(
       juniorConversations.channelName,
       juniorConversations.source,
@@ -929,11 +1264,17 @@ async function aggregateStats(db, start, end) {
       juniorDestinations.visibility
     ),
     db.select({
-      costUsd: conversationAggregateColumns().costUsd,
+      costUsd: treeAggregateColumns.costUsd,
       date: activityDate,
-      durationMs: conversationAggregateColumns().durationMs,
-      tokens: conversationAggregateColumns().tokens
-    }).from(juniorConversations).where(where).groupBy(activityDate)
+      durationMs: treeAggregateColumns.durationMs,
+      tokens: treeAggregateColumns.tokens
+    }).from(juniorConversations).innerJoin(
+      treeConversation,
+      eq7(
+        treeConversation.rootConversationId,
+        juniorConversations.conversationId
+      )
+    ).where(where).groupBy(activityDate)
   ]);
   return { actorRows, locationRows, metricRows, totals: totalsRows[0] };
 }
@@ -976,17 +1317,18 @@ async function readConversationStats() {
     await readConversationStatsFromSql()
   );
 }
-var stats_default = {
+var stats_default = defineApiRoute({
   method: "get",
   path: "/stats",
-  handler: async () => Response.json(await readConversationStats())
-};
+  responseSchema: conversationStatsReportSchema,
+  handler: readConversationStats
+});
 
 // src/api/conversations/routes.ts
 var routes = [list_default, stats_default, archive_default, detail_default];
 function createConversationRoutes() {
   const app = new Hono();
-  for (const route of routes) app.on(route.method, route.path, route.handler);
+  registerApiRoutes(app, routes);
   return app;
 }
 
@@ -994,28 +1336,10 @@ function createConversationRoutes() {
 import { Hono as Hono2 } from "hono";
 
 // src/api/locations/query.ts
-import { and as and5, asc as asc2, desc as desc2, eq as eq5, gte as gte2, isNull as isNull3, sql as sql4 } from "drizzle-orm";
+import { and as and7, asc as asc3, desc as desc2, eq as eq8, gte as gte2, isNull as isNull4, sql as sql6 } from "drizzle-orm";
+import { alias as alias4 } from "drizzle-orm/pg-core";
 
 // src/api/conversations/reporting.ts
-var PRIVATE_CONVERSATION_LABEL2 = "Private Conversation";
-function channelFromConversationId(conversationId) {
-  const [provider, channel] = conversationId.split(":");
-  return provider === "slack" && channel ? channel : void 0;
-}
-function surfaceFromRow(row) {
-  if (row.source === "api" || row.source === "scheduler" || row.source === "slack") {
-    return row.source;
-  }
-  if (row.conversationId.startsWith("slack:")) return "slack";
-  if (row.conversationId.startsWith("scheduler:")) return "scheduler";
-  if (row.conversationId.startsWith("api:")) return "api";
-  return "internal";
-}
-function statusFromRow(row) {
-  if (row.executionStatus === "failed") return "failed";
-  if (row.executionStatus === "idle") return "completed";
-  return "active";
-}
 function surfaceLabel2(surface) {
   if (surface === "scheduler") return "Scheduler";
   if (surface === "api") return "API";
@@ -1037,22 +1361,6 @@ function slackLocationLabel(args) {
   }
   return name || channelId;
 }
-function channelNameFromRow(row) {
-  if (row.destinationVisibility !== "public") {
-    return PRIVATE_CONVERSATION_LABEL2;
-  }
-  return row.channelName ?? void 0;
-}
-function titleFromRow(row, surface) {
-  if (row.destinationVisibility !== "public") {
-    return PRIVATE_CONVERSATION_LABEL2;
-  }
-  const channel = channelFromConversationId(row.conversationId);
-  return row.title ?? slackLocationLabel({
-    channel,
-    channelName: row.channelName ?? void 0
-  }) ?? surfaceLabel2(surface);
-}
 function actorFromRow(row) {
   const actor = {
     ...row.email ? { email: row.email } : {},
@@ -1062,34 +1370,42 @@ function actorFromRow(row) {
   };
   return Object.keys(actor).length ? actor : void 0;
 }
-function summaryFromRow(row) {
-  const surface = surfaceFromRow(row);
-  const channel = channelFromConversationId(row.conversationId);
-  const channelName = channelNameFromRow(row);
-  const channelNameRedacted = row.destinationVisibility !== "public";
-  const actorIdentity = actorFromRow(row);
-  return {
+function summaryFromRow(row, options = {}) {
+  const actor = actorFromRow(row);
+  const conversation = {
     conversationId: row.conversationId,
-    cumulativeDurationMs: row.durationMs,
-    displayTitle: titleFromRow(row, surface),
-    lastProgressAt: new Date(
-      row.executionUpdatedAt ?? row.updatedAt
-    ).toISOString(),
-    lastSeenAt: row.lastActivityAt.toISOString(),
-    startedAt: row.createdAt.toISOString(),
-    status: statusFromRow(row),
-    surface,
-    ...actorIdentity ? { actorIdentity } : {},
-    ...channel ? { channel } : {},
-    ...channelName ? { channelName } : {},
-    ...channelNameRedacted ? { channelNameRedacted: true } : {},
-    ...row.destinationVisibility === "public" && row.destinationId ? { locationId: row.destinationId } : {}
+    createdAtMs: row.createdAt.getTime(),
+    lastActivityAtMs: row.lastActivityAt.getTime(),
+    updatedAtMs: row.updatedAt.getTime(),
+    execution: {
+      status: row.executionStatus,
+      ...row.executionUpdatedAt ? { updatedAtMs: row.executionUpdatedAt.getTime() } : {}
+    },
+    ...actor ? { actor } : {},
+    ...row.channelName ? { channelName: row.channelName } : {},
+    ...row.source ? { source: row.source } : {},
+    ...row.title ? { title: row.title } : {}
   };
+  return conversationSummaryFromStoredConversation({
+    access: options.access,
+    conversation,
+    durationMs: options.metrics?.durationMs ?? row.durationMs,
+    ...options.access?.visibility === "public" && row.destinationId ? { locationId: row.destinationId } : {},
+    usage: options.metrics?.usage ?? row.usage ?? void 0
+  });
 }
 
 // src/api/locations/query.ts
 var RECENT_LIMIT = 25;
 var ACTIVITY_DAYS = 90;
+var treeConversation2 = alias4(
+  juniorConversations,
+  "location_tree_conversation"
+);
+var treeAggregateColumns2 = conversationAggregateColumns({
+  metrics: treeConversation2,
+  roots: juniorConversations
+});
 function emptyMetrics() {
   return {
     active: 0,
@@ -1125,13 +1441,13 @@ function emptyActor(actor) {
   };
 }
 function topLevelWhere() {
-  return isNull3(juniorConversations.parentConversationId);
+  return isNull4(juniorConversations.parentConversationId);
 }
 function publicLocationWhere(destinationId) {
-  return and5(
+  return and7(
     topLevelWhere(),
-    eq5(juniorDestinations.id, destinationId),
-    eq5(juniorDestinations.visibility, "public")
+    eq8(juniorDestinations.id, destinationId),
+    eq8(juniorDestinations.visibility, "public")
   );
 }
 function locationColumns() {
@@ -1178,26 +1494,32 @@ function locationFromAggregate(row) {
 async function directoryRows(db) {
   return db.select({
     ...locationColumns(),
-    ...conversationAggregateColumns(),
+    ...treeAggregateColumns2,
     ...conversationRangeColumns()
-  }).from(juniorConversations).leftJoin(
+  }).from(juniorConversations).innerJoin(
+    treeConversation2,
+    eq8(
+      treeConversation2.rootConversationId,
+      juniorConversations.conversationId
+    )
+  ).leftJoin(
     juniorDestinations,
-    eq5(juniorDestinations.id, juniorConversations.destinationId)
+    eq8(juniorDestinations.id, juniorConversations.destinationId)
   ).where(topLevelWhere()).groupBy(...locationGroupBy());
 }
 async function directoryActivityRows(db, start) {
-  const date = sql4`TO_CHAR(
+  const date = sql6`TO_CHAR(
     ${juniorConversations.lastActivityAt} AT TIME ZONE 'UTC',
     'YYYY-MM-DD'
   )`;
   return db.select({
-    conversations: sql4`COUNT(*)::integer`,
+    conversations: sql6`COUNT(*)::integer`,
     date,
     visibility: juniorDestinations.visibility
   }).from(juniorConversations).leftJoin(
     juniorDestinations,
-    eq5(juniorDestinations.id, juniorConversations.destinationId)
-  ).where(and5(topLevelWhere(), gte2(juniorConversations.lastActivityAt, start))).groupBy(date, juniorDestinations.visibility);
+    eq8(juniorDestinations.id, juniorConversations.destinationId)
+  ).where(and7(topLevelWhere(), gte2(juniorConversations.lastActivityAt, start))).groupBy(date, juniorDestinations.visibility);
 }
 function directoryActivityDays(rows, nowMs) {
   const days = /* @__PURE__ */ new Map();
@@ -1269,9 +1591,8 @@ async function recentLocationRows(db, locationId) {
     conversationId: juniorConversations.conversationId,
     createdAt: juniorConversations.createdAt,
     destinationId: juniorDestinations.id,
-    destinationVisibility: juniorDestinations.visibility,
     durationMs: juniorConversations.durationMs,
-    email: sql4`COALESCE(
+    email: sql6`COALESCE(
         ${juniorUsers.primaryEmailNormalized},
         ${juniorIdentities.email}
       )`,
@@ -1280,7 +1601,7 @@ async function recentLocationRows(db, locationId) {
     fullName: juniorUsers.displayName,
     handle: juniorIdentities.handle,
     lastActivityAt: juniorConversations.lastActivityAt,
-    providerSubjectId: sql4`CASE
+    providerSubjectId: sql6`CASE
         WHEN ${juniorIdentities.provider} = 'slack'
           THEN ${juniorIdentities.providerSubjectId}
         ELSE NULL
@@ -1291,44 +1612,59 @@ async function recentLocationRows(db, locationId) {
     usage: juniorConversations.usage
   }).from(juniorConversations).innerJoin(
     juniorDestinations,
-    eq5(juniorDestinations.id, juniorConversations.destinationId)
+    eq8(juniorDestinations.id, juniorConversations.destinationId)
   ).leftJoin(
     juniorIdentities,
-    eq5(juniorIdentities.id, juniorConversations.actorIdentityId)
-  ).leftJoin(juniorUsers, eq5(juniorUsers.id, juniorIdentities.userId)).where(
-    and5(
+    eq8(juniorIdentities.id, juniorConversations.actorIdentityId)
+  ).leftJoin(juniorUsers, eq8(juniorUsers.id, juniorIdentities.userId)).where(
+    and7(
       publicLocationWhere(locationId),
-      isNull3(juniorConversations.archivedAt)
+      isNull4(juniorConversations.archivedAt)
     )
   ).orderBy(
     desc2(juniorConversations.lastActivityAt),
-    asc2(juniorConversations.conversationId)
+    asc3(juniorConversations.conversationId)
   ).limit(RECENT_LIMIT);
 }
-async function readLocationDetailFromSql(locationId) {
+async function readLocationDetailFromSql(locationId, options = {}) {
   const nowMs = Date.now();
   const end = new Date(nowMs);
   end.setUTCHours(0, 0, 0, 0);
   const start = new Date(end);
   start.setUTCDate(start.getUTCDate() - (ACTIVITY_DAYS - 1));
   const where = publicLocationWhere(locationId);
-  const activityDate = sql4`TO_CHAR(
+  const activityDate = sql6`TO_CHAR(
     ${juniorConversations.lastActivityAt} AT TIME ZONE 'UTC',
     'YYYY-MM-DD'
   )`;
   const [locationRows, dayRows, actorRows, recentRows] = await Promise.all([
     getDb().select({
       ...locationColumns(),
-      ...conversationAggregateColumns(),
+      ...treeAggregateColumns2,
       ...conversationRangeColumns()
     }).from(juniorConversations).innerJoin(
+      treeConversation2,
+      eq8(
+        treeConversation2.rootConversationId,
+        juniorConversations.conversationId
+      )
+    ).innerJoin(
       juniorDestinations,
-      eq5(juniorDestinations.id, juniorConversations.destinationId)
+      eq8(juniorDestinations.id, juniorConversations.destinationId)
     ).where(where).groupBy(...locationGroupBy()),
-    getDb().select({ date: activityDate, ...conversationAggregateColumns() }).from(juniorConversations).innerJoin(
+    getDb().select({
+      date: activityDate,
+      ...treeAggregateColumns2
+    }).from(juniorConversations).innerJoin(
+      treeConversation2,
+      eq8(
+        treeConversation2.rootConversationId,
+        juniorConversations.conversationId
+      )
+    ).innerJoin(
       juniorDestinations,
-      eq5(juniorDestinations.id, juniorConversations.destinationId)
-    ).where(and5(where, gte2(juniorConversations.lastActivityAt, start))).groupBy(activityDate),
+      eq8(juniorDestinations.id, juniorConversations.destinationId)
+    ).where(and7(where, gte2(juniorConversations.lastActivityAt, start))).groupBy(activityDate),
     getDb().select({
       actorIdentityId: juniorConversations.actorIdentityId,
       email: juniorUsers.primaryEmailNormalized,
@@ -1337,14 +1673,20 @@ async function readLocationDetailFromSql(locationId) {
       identityEmail: juniorIdentities.email,
       identityProvider: juniorIdentities.provider,
       providerSubjectId: juniorIdentities.providerSubjectId,
-      ...conversationAggregateColumns()
+      ...treeAggregateColumns2
     }).from(juniorConversations).innerJoin(
+      treeConversation2,
+      eq8(
+        treeConversation2.rootConversationId,
+        juniorConversations.conversationId
+      )
+    ).innerJoin(
       juniorDestinations,
-      eq5(juniorDestinations.id, juniorConversations.destinationId)
+      eq8(juniorDestinations.id, juniorConversations.destinationId)
     ).leftJoin(
       juniorIdentities,
-      eq5(juniorIdentities.id, juniorConversations.actorIdentityId)
-    ).leftJoin(juniorUsers, eq5(juniorUsers.id, juniorIdentities.userId)).where(where).groupBy(
+      eq8(juniorIdentities.id, juniorConversations.actorIdentityId)
+    ).leftJoin(juniorUsers, eq8(juniorUsers.id, juniorIdentities.userId)).where(where).groupBy(
       juniorConversations.actorIdentityId,
       juniorUsers.primaryEmailNormalized,
       juniorUsers.displayName,
@@ -1384,6 +1726,15 @@ async function readLocationDetailFromSql(locationId) {
     actors.push(item);
   }
   const activity = activityDays(days, nowMs, ACTIVITY_DAYS);
+  const recentConversationIds = recentRows.map((row) => row.conversationId);
+  const [accessByConversation, metricsByRoot] = await Promise.all([
+    readConversationAccessFromSql(
+      getDb(),
+      recentConversationIds,
+      options.verifiedViewerEmail
+    ),
+    readRootConversationMetricsFromSql(getDb(), recentConversationIds)
+  ]);
   return {
     ...location,
     activityDays: activity,
@@ -1391,7 +1742,12 @@ async function readLocationDetailFromSql(locationId) {
       (left, right) => right.conversations - left.conversations || left.label.localeCompare(right.label)
     ),
     generatedAt: new Date(nowMs).toISOString(),
-    recentConversations: recentRows.map(summaryFromRow),
+    recentConversations: recentRows.map(
+      (row) => summaryFromRow(row, {
+        access: accessByConversation.get(row.conversationId),
+        metrics: metricsByRoot.get(row.conversationId)
+      })
+    ),
     source: "conversation_index",
     windowEnd: end.toISOString(),
     windowStart: activity[0] ? `${activity[0].date}T00:00:00.000Z` : end.toISOString()
@@ -1399,19 +1755,25 @@ async function readLocationDetailFromSql(locationId) {
 }
 
 // src/api/locations/detail.ts
-async function readLocationDetail(locationId) {
-  const report = await readLocationDetailFromSql(locationId);
+async function readLocationDetail(locationId, options = {}) {
+  const report = await readLocationDetailFromSql(locationId, options);
   return report ? locationDetailReportSchema.parse(report) : void 0;
 }
-var detail_default2 = {
+var detail_default2 = defineApiRoute({
   method: "get",
   path: "/:locationId",
+  responseSchema: locationDetailReportSchema,
   handler: async (c) => {
     const { locationId } = parseParams(locationParamsSchema, c.req.param());
-    const report = await readLocationDetail(locationId);
-    return report ? Response.json(report) : Response.json({ error: "Location not found." }, { status: 404 });
+    const verifiedViewerEmail = c.get("verifiedViewerEmail");
+    const report = await readLocationDetail(
+      locationId,
+      verifiedViewerEmail ? { verifiedViewerEmail } : {}
+    );
+    if (!report) throwApiError(404, "Location not found.");
+    return report;
   }
-};
+});
 
 // src/api/locations/list.ts
 async function readLocationDirectory() {
@@ -1419,17 +1781,18 @@ async function readLocationDirectory() {
     await readLocationDirectoryFromSql()
   );
 }
-var list_default2 = {
+var list_default2 = defineApiRoute({
   method: "get",
   path: "/",
-  handler: async () => Response.json(await readLocationDirectory())
-};
+  responseSchema: locationDirectoryReportSchema,
+  handler: readLocationDirectory
+});
 
 // src/api/locations/routes.ts
 var routes2 = [list_default2, detail_default2];
 function createLocationRoutes() {
   const app = new Hono2();
-  for (const route of routes2) app.on(route.method, route.path, route.handler);
+  registerApiRoutes(app, routes2);
   return app;
 }
 
@@ -1437,12 +1800,68 @@ function createLocationRoutes() {
 import { Hono as Hono3 } from "hono";
 
 // src/api/people/list.query.ts
-import { and as and7, eq as eq7, gte as gte3, sql as sql6 } from "drizzle-orm";
+import { and as and9, eq as eq10, gte as gte3, sql as sql8 } from "drizzle-orm";
 
 // src/api/people/shared.ts
-import { and as and6, asc as asc3, desc as desc3, eq as eq6, isNull as isNull4, sql as sql5 } from "drizzle-orm";
+import { and as and8, asc as asc4, desc as desc3, eq as eq9, isNull as isNull5, notExists, or, sql as sql7 } from "drizzle-orm";
+import { alias as alias5 } from "drizzle-orm/pg-core";
 var RECENT_LIMIT2 = 25;
 var ACTIVITY_DAYS2 = 365;
+var peopleTreeConversation = alias5(
+  juniorConversations,
+  "people_tree_conversation"
+);
+var peopleRootConversation = alias5(
+  juniorConversations,
+  "people_root_conversation"
+);
+var peopleRootIdentity = alias5(juniorIdentities, "people_root_identity");
+var peopleTreeAggregateColumns = conversationAggregateColumns({
+  metrics: peopleTreeConversation,
+  roots: juniorConversations
+});
+function peopleTreeMetricsJoin() {
+  const rootOwnedByActor = getDb().select({ conversationId: peopleRootConversation.conversationId }).from(peopleRootConversation).innerJoin(
+    peopleRootIdentity,
+    eq9(peopleRootIdentity.id, peopleRootConversation.actorIdentityId)
+  ).where(
+    and8(
+      eq9(
+        peopleRootConversation.conversationId,
+        juniorConversations.rootConversationId
+      ),
+      isNull5(peopleRootConversation.parentConversationId),
+      eq9(
+        peopleRootConversation.rootConversationId,
+        peopleRootConversation.conversationId
+      ),
+      eq9(
+        peopleRootIdentity.emailNormalized,
+        juniorUsers.primaryEmailNormalized
+      ),
+      eq9(peopleRootIdentity.emailVerified, true)
+    )
+  );
+  return and8(
+    eq9(
+      peopleTreeConversation.rootConversationId,
+      juniorConversations.rootConversationId
+    ),
+    or(
+      eq9(
+        juniorConversations.rootConversationId,
+        juniorConversations.conversationId
+      ),
+      and8(
+        eq9(
+          peopleTreeConversation.conversationId,
+          juniorConversations.conversationId
+        ),
+        notExists(rootOwnedByActor)
+      )
+    )
+  );
+}
 function normalizeEmail(email) {
   const normalized = email?.trim().toLowerCase();
   return normalized || void 0;
@@ -1484,11 +1903,11 @@ function statsItems2(map) {
 }
 function verifiedActorWhere(email) {
   const normalizedEmail = normalizeEmail(email);
-  return and6(
-    eq6(juniorIdentities.provider, "slack"),
-    eq6(juniorIdentities.emailVerified, true),
-    sql5`${juniorUsers.primaryEmailNormalized} IS NOT NULL`,
-    normalizedEmail ? eq6(juniorUsers.primaryEmailNormalized, normalizedEmail) : void 0
+  return and8(
+    eq9(juniorIdentities.provider, "slack"),
+    eq9(juniorIdentities.emailVerified, true),
+    sql7`${juniorUsers.primaryEmailNormalized} IS NOT NULL`,
+    normalizedEmail ? eq9(juniorUsers.primaryEmailNormalized, normalizedEmail) : void 0
   );
 }
 async function recentActorRows(email) {
@@ -1497,7 +1916,6 @@ async function recentActorRows(email) {
     conversationId: juniorConversations.conversationId,
     createdAt: juniorConversations.createdAt,
     destinationId: juniorDestinations.id,
-    destinationVisibility: juniorDestinations.visibility,
     durationMs: juniorConversations.durationMs,
     email: juniorUsers.primaryEmailNormalized,
     executionStatus: juniorConversations.executionStatus,
@@ -1512,15 +1930,15 @@ async function recentActorRows(email) {
     usage: juniorConversations.usage
   }).from(juniorConversations).innerJoin(
     juniorIdentities,
-    eq6(juniorIdentities.id, juniorConversations.actorIdentityId)
-  ).innerJoin(juniorUsers, eq6(juniorUsers.id, juniorIdentities.userId)).leftJoin(
+    eq9(juniorIdentities.id, juniorConversations.actorIdentityId)
+  ).innerJoin(juniorUsers, eq9(juniorUsers.id, juniorIdentities.userId)).leftJoin(
     juniorDestinations,
-    eq6(juniorDestinations.id, juniorConversations.destinationId)
+    eq9(juniorDestinations.id, juniorConversations.destinationId)
   ).where(
-    and6(verifiedActorWhere(email), isNull4(juniorConversations.archivedAt))
+    and8(verifiedActorWhere(email), isNull5(juniorConversations.archivedAt))
   ).orderBy(
     desc3(juniorConversations.lastActivityAt),
-    asc3(juniorConversations.conversationId)
+    asc4(juniorConversations.conversationId)
   ).limit(RECENT_LIMIT2);
 }
 
@@ -1546,7 +1964,7 @@ function directoryActivityDays2(rows, nowMs) {
 async function readPeopleListFromSql() {
   const nowMs = Date.now();
   const { end, start } = activityWindow(nowMs);
-  const activityDate = sql6`TO_CHAR(
+  const activityDate = sql8`TO_CHAR(
     ${juniorConversations.lastActivityAt} AT TIME ZONE 'UTC',
     'YYYY-MM-DD'
   )`;
@@ -1554,24 +1972,24 @@ async function readPeopleListFromSql() {
     getDb().select({
       email: juniorUsers.primaryEmailNormalized,
       fullName: juniorUsers.displayName,
-      slackUserId: sql6`MAX(${juniorIdentities.providerSubjectId})`,
-      slackUserName: sql6`MAX(${juniorIdentities.handle})`,
+      slackUserId: sql8`MAX(${juniorIdentities.providerSubjectId})`,
+      slackUserName: sql8`MAX(${juniorIdentities.handle})`,
       activeDays: conversationActiveDaysColumn(),
-      ...conversationAggregateColumns(),
+      ...peopleTreeAggregateColumns,
       ...conversationRangeColumns()
     }).from(juniorConversations).innerJoin(
       juniorIdentities,
-      eq7(juniorIdentities.id, juniorConversations.actorIdentityId)
-    ).innerJoin(juniorUsers, eq7(juniorUsers.id, juniorIdentities.userId)).where(verifiedActorWhere()).groupBy(juniorUsers.primaryEmailNormalized, juniorUsers.displayName),
+      eq10(juniorIdentities.id, juniorConversations.actorIdentityId)
+    ).innerJoin(juniorUsers, eq10(juniorUsers.id, juniorIdentities.userId)).leftJoin(peopleTreeConversation, peopleTreeMetricsJoin()).where(verifiedActorWhere()).groupBy(juniorUsers.primaryEmailNormalized, juniorUsers.displayName),
     getDb().select({
-      activePeople: sql6`COUNT(DISTINCT ${juniorUsers.id})::int`,
-      conversations: sql6`COUNT(*)::int`,
+      activePeople: sql8`COUNT(DISTINCT ${juniorUsers.id})::int`,
+      conversations: sql8`COUNT(*)::int`,
       date: activityDate
     }).from(juniorConversations).innerJoin(
       juniorIdentities,
-      eq7(juniorIdentities.id, juniorConversations.actorIdentityId)
-    ).innerJoin(juniorUsers, eq7(juniorUsers.id, juniorIdentities.userId)).where(
-      and7(
+      eq10(juniorIdentities.id, juniorConversations.actorIdentityId)
+    ).innerJoin(juniorUsers, eq10(juniorUsers.id, juniorIdentities.userId)).where(
+      and9(
         verifiedActorWhere(),
         gte3(juniorConversations.lastActivityAt, start)
       )
@@ -1612,14 +2030,15 @@ async function readPeopleListFromSql() {
 async function readPeopleList() {
   return actorDirectoryReportSchema.parse(await readPeopleListFromSql());
 }
-var list_default3 = {
+var list_default3 = defineApiRoute({
   method: "get",
   path: "/",
-  handler: async () => Response.json(await readPeopleList())
-};
+  responseSchema: actorDirectoryReportSchema,
+  handler: readPeopleList
+});
 
 // src/api/people/profile.query.ts
-import { and as and8, eq as eq8, gte as gte4, sql as sql7 } from "drizzle-orm";
+import { and as and10, eq as eq11, gte as gte4, sql as sql9 } from "drizzle-orm";
 function emptyProfile(email, nowMs) {
   const end = new Date(nowMs);
   end.setUTCHours(0, 0, 0, 0);
@@ -1654,7 +2073,7 @@ function addAggregate2(map, label, row) {
   map.set(label, item);
 }
 function surfaceExpression() {
-  return sql7`CASE
+  return sql9`CASE
     WHEN ${juniorConversations.source} IN ('api', 'scheduler', 'slack')
       THEN ${juniorConversations.source}
     WHEN ${juniorConversations.conversationId} LIKE 'slack:%' THEN 'slack'
@@ -1672,7 +2091,7 @@ function locationLabel2(row) {
     channelName: row.channelName ?? void 0
   }) ?? "Conversation";
 }
-async function readPeopleProfileFromSql(email) {
+async function readPeopleProfileFromSql(email, options = {}) {
   const nowMs = Date.now();
   const normalizedEmail = normalizeEmail(email);
   if (!normalizedEmail) return emptyProfile("", nowMs);
@@ -1681,53 +2100,54 @@ async function readPeopleProfileFromSql(email) {
   const start = new Date(end);
   start.setUTCDate(start.getUTCDate() - (ACTIVITY_DAYS2 - 1));
   const where = verifiedActorWhere(normalizedEmail);
+  const metricsJoin = peopleTreeMetricsJoin();
   const surface = surfaceExpression();
-  const activityDate = sql7`TO_CHAR(
+  const activityDate = sql9`TO_CHAR(
     ${juniorConversations.lastActivityAt} AT TIME ZONE 'UTC',
     'YYYY-MM-DD'
   )`;
-  const channel = sql7`SPLIT_PART(${juniorConversations.conversationId}, ':', 2)`;
+  const channel = sql9`SPLIT_PART(${juniorConversations.conversationId}, ':', 2)`;
   const [totalsRows, dayRows, locationRows, surfaceRows, recentRows] = await Promise.all([
     getDb().select({
       email: juniorUsers.primaryEmailNormalized,
       fullName: juniorUsers.displayName,
-      slackUserId: sql7`MAX(${juniorIdentities.providerSubjectId})`,
-      slackUserName: sql7`MAX(${juniorIdentities.handle})`,
+      slackUserId: sql9`MAX(${juniorIdentities.providerSubjectId})`,
+      slackUserName: sql9`MAX(${juniorIdentities.handle})`,
       activeDays: conversationActiveDaysColumn(),
-      ...conversationAggregateColumns()
+      ...peopleTreeAggregateColumns
     }).from(juniorConversations).innerJoin(
       juniorIdentities,
-      eq8(juniorIdentities.id, juniorConversations.actorIdentityId)
-    ).innerJoin(juniorUsers, eq8(juniorUsers.id, juniorIdentities.userId)).where(where).groupBy(juniorUsers.primaryEmailNormalized, juniorUsers.displayName),
+      eq11(juniorIdentities.id, juniorConversations.actorIdentityId)
+    ).innerJoin(juniorUsers, eq11(juniorUsers.id, juniorIdentities.userId)).leftJoin(peopleTreeConversation, metricsJoin).where(where).groupBy(juniorUsers.primaryEmailNormalized, juniorUsers.displayName),
     getDb().select({
       date: activityDate,
-      ...conversationAggregateColumns()
+      ...peopleTreeAggregateColumns
     }).from(juniorConversations).innerJoin(
       juniorIdentities,
-      eq8(juniorIdentities.id, juniorConversations.actorIdentityId)
-    ).innerJoin(juniorUsers, eq8(juniorUsers.id, juniorIdentities.userId)).where(and8(where, gte4(juniorConversations.lastActivityAt, start))).groupBy(activityDate),
+      eq11(juniorIdentities.id, juniorConversations.actorIdentityId)
+    ).innerJoin(juniorUsers, eq11(juniorUsers.id, juniorIdentities.userId)).leftJoin(peopleTreeConversation, metricsJoin).where(and10(where, gte4(juniorConversations.lastActivityAt, start))).groupBy(activityDate),
     getDb().select({
       channel,
       channelName: juniorConversations.channelName,
       destinationVisibility: juniorDestinations.visibility,
       surface,
-      ...conversationAggregateColumns()
+      ...peopleTreeAggregateColumns
     }).from(juniorConversations).innerJoin(
       juniorIdentities,
-      eq8(juniorIdentities.id, juniorConversations.actorIdentityId)
-    ).innerJoin(juniorUsers, eq8(juniorUsers.id, juniorIdentities.userId)).leftJoin(
+      eq11(juniorIdentities.id, juniorConversations.actorIdentityId)
+    ).innerJoin(juniorUsers, eq11(juniorUsers.id, juniorIdentities.userId)).leftJoin(peopleTreeConversation, metricsJoin).leftJoin(
       juniorDestinations,
-      eq8(juniorDestinations.id, juniorConversations.destinationId)
+      eq11(juniorDestinations.id, juniorConversations.destinationId)
     ).where(where).groupBy(
       channel,
       juniorConversations.channelName,
       juniorDestinations.visibility,
       surface
     ),
-    getDb().select({ surface, ...conversationAggregateColumns() }).from(juniorConversations).innerJoin(
+    getDb().select({ surface, ...peopleTreeAggregateColumns }).from(juniorConversations).innerJoin(
       juniorIdentities,
-      eq8(juniorIdentities.id, juniorConversations.actorIdentityId)
-    ).innerJoin(juniorUsers, eq8(juniorUsers.id, juniorIdentities.userId)).where(where).groupBy(surface),
+      eq11(juniorIdentities.id, juniorConversations.actorIdentityId)
+    ).innerJoin(juniorUsers, eq11(juniorUsers.id, juniorIdentities.userId)).leftJoin(peopleTreeConversation, metricsJoin).where(where).groupBy(surface),
     recentActorRows(normalizedEmail)
   ]);
   const totalsRow = totalsRows[0];
@@ -1761,11 +2181,25 @@ async function readPeopleProfileFromSql(email) {
       row
     );
   }
+  const recentConversationIds = recentRows.map((row) => row.conversationId);
+  const [accessByConversation, metricsByRoot] = await Promise.all([
+    readConversationAccessFromSql(
+      getDb(),
+      recentConversationIds,
+      options.verifiedViewerEmail
+    ),
+    readRootConversationMetricsFromSql(getDb(), recentConversationIds)
+  ]);
   return {
     activityDays: activityDays2(days, nowMs),
     generatedAt: new Date(nowMs).toISOString(),
     locations: statsItems2(locations),
-    recentConversations: recentRows.map(summaryFromRow),
+    recentConversations: recentRows.map(
+      (row) => summaryFromRow(row, {
+        access: accessByConversation.get(row.conversationId),
+        metrics: metricsByRoot.get(row.conversationId)
+      })
+    ),
     actor,
     source: "conversation_index",
     surfaces: statsItems2(surfaces),
@@ -1783,23 +2217,30 @@ async function readPeopleProfileFromSql(email) {
 }
 
 // src/api/people/profile.ts
-async function readPeopleProfile(email) {
-  return actorProfileReportSchema.parse(await readPeopleProfileFromSql(email));
+async function readPeopleProfile(email, options = {}) {
+  return actorProfileReportSchema.parse(
+    await readPeopleProfileFromSql(email, options)
+  );
 }
-var profile_default = {
+var profile_default = defineApiRoute({
   method: "get",
   path: "/:email",
+  responseSchema: actorProfileReportSchema,
   handler: async (c) => {
     const { email } = parseParams(personParamsSchema, c.req.param());
-    return Response.json(await readPeopleProfile(email));
+    const verifiedViewerEmail = c.get("verifiedViewerEmail");
+    return readPeopleProfile(
+      email,
+      verifiedViewerEmail ? { verifiedViewerEmail } : {}
+    );
   }
-};
+});
 
 // src/api/people/routes.ts
 var routes3 = [list_default3, profile_default];
 function createPeopleRoutes() {
   const app = new Hono3();
-  for (const route of routes3) app.on(route.method, route.path, route.handler);
+  registerApiRoutes(app, routes3);
   return app;
 }
 
@@ -1815,7 +2256,7 @@ function readDescriptionText(home) {
   }
 }
 async function readSkillReports() {
-  const { discoverSkills } = await import("./skills-ITNHBARB.js");
+  const { discoverSkills } = await import("./skills-AR4AF32L.js");
   const skills = await discoverSkills();
   return skillReportsSchema.parse(
     skills.map((skill) => ({
@@ -1825,7 +2266,7 @@ async function readSkillReports() {
   );
 }
 async function readPluginReports() {
-  const { pluginCatalogRuntime } = await import("./catalog-runtime-FOFNPR3P.js");
+  const { pluginCatalogRuntime } = await import("./catalog-runtime-4GI22PXK.js");
   return pluginReportsSchema.parse(
     pluginCatalogRuntime.getProviders().map((plugin) => ({
       name: plugin.manifest.name
@@ -1835,7 +2276,7 @@ async function readPluginReports() {
 async function readRuntimeInfoReport() {
   const [{ homeDir }, { pluginCatalogRuntime }, plugins, skills] = await Promise.all([
     import("./discovery-RMHYSRL7.js"),
-    import("./catalog-runtime-FOFNPR3P.js"),
+    import("./catalog-runtime-4GI22PXK.js"),
     readPluginReports(),
     readSkillReports()
   ]);
@@ -1851,7 +2292,7 @@ async function readRuntimeInfoReport() {
 }
 async function readPluginOperationalReportFeed() {
   const nowMs = Date.now();
-  const { getPluginOperationalReports } = await import("./agent-hooks-NU5HK3PS.js");
+  const { getPluginOperationalReports } = await import("./agent-hooks-ELT4ODFF.js");
   return pluginOperationalReportFeedSchema.parse({
     source: "plugins",
     generatedAt: new Date(nowMs).toISOString(),
@@ -1860,28 +2301,56 @@ async function readPluginOperationalReportFeed() {
 }
 
 // src/api.ts
+var routes4 = [
+  defineApiRoute({
+    method: "get",
+    path: "/api/health",
+    responseSchema: healthReportSchema,
+    handler: readHealthReport
+  }),
+  defineApiRoute({
+    method: "get",
+    path: "/api/runtime",
+    responseSchema: runtimeInfoReportSchema,
+    handler: readRuntimeInfoReport
+  }),
+  defineApiRoute({
+    method: "get",
+    path: "/api/plugins",
+    responseSchema: pluginReportsSchema,
+    handler: readPluginReports
+  }),
+  defineApiRoute({
+    method: "get",
+    path: "/api/skills",
+    responseSchema: skillReportsSchema,
+    handler: readSkillReports
+  }),
+  defineApiRoute({
+    method: "get",
+    path: "/api/plugin-reports",
+    responseSchema: pluginOperationalReportFeedSchema,
+    handler: readPluginOperationalReportFeed
+  })
+];
 function createJuniorApi() {
   const app = new Hono4();
-  app.get("/api/health", async () => {
-    return Response.json(await readHealthReport());
-  });
-  app.get("/api/runtime", async () => {
-    return Response.json(await readRuntimeInfoReport());
-  });
-  app.get("/api/plugins", async () => {
-    return Response.json(await readPluginReports());
-  });
-  app.get("/api/skills", async () => {
-    return Response.json(await readSkillReports());
-  });
-  app.get("/api/plugin-reports", async () => {
-    return Response.json(await readPluginOperationalReportFeed());
-  });
+  registerApiRoutes(app, routes4);
   app.route("/api/conversations", createConversationRoutes());
   app.route("/api/people", createPeopleRoutes());
   app.route("/api/locations", createLocationRoutes());
+  app.notFound(
+    () => jsonResponse(
+      apiErrorSchema,
+      { error: "Resource not found." },
+      {
+        status: 404
+      }
+    )
+  );
   return app;
 }
 export {
-  createJuniorApi
+  createJuniorApi,
+  jsonResponse
 };