@sentry/junior 0.103.0 → 0.104.0

package/dist/api.js

@@ -1,29 +1,2200 @@
 import {
+  activityDays,
+  actorDirectoryReportSchema,
+  actorProfileReportSchema,
+  conversationDetailReportSchema,
   conversationFeedQuerySchema,
+  conversationFeedSchema,
   conversationParamsSchema,
+  conversationStatsReportSchema,
+  conversationSubagentTranscriptReportSchema,
+  locationDetailReportSchema,
+  locationDirectoryReportSchema,
   locationParamsSchema,
   personParamsSchema,
   subagentParamsSchema
-} from "./chunk-2RNOB32R.js";
-import "./chunk-GCGRQJR5.js";
-import "./chunk-6LBNXC4F.js";
-import "./chunk-7LLRS2OK.js";
+} from "./chunk-AIRE7Q2W.js";
 import {
-  readHealthReport
-} from "./chunk-QNVHH5PU.js";
+  buildSentryConversationUrl,
+  buildSentryTraceUrl,
+  formatSlackConversationRedactedLabel,
+  readHealthReport,
+  resolveSlackConversationContextFromThreadId
+} from "./chunk-O7ILGCMJ.js";
 import {
   pluginOperationalReportFeedSchema,
   pluginReportsSchema,
   runtimeInfoReportSchema,
   skillReportsSchema
 } from "./chunk-CEA3A3UA.js";
+import {
+  listBoundedAgentTurnSessionSummariesForConversation,
+  loadProjection,
+  projectSteps
+} from "./chunk-QDKRE3LS.js";
+import "./chunk-RYDF4GOX.js";
 import "./chunk-PDO5BLNM.js";
-import "./chunk-FXFQNHRU.js";
+import "./chunk-CCTCIISK.js";
+import {
+  getAgentStepStore,
+  getConversationMessageStore,
+  getDb,
+  juniorConversations,
+  juniorIdentities,
+  juniorUsers
+} from "./chunk-BCULHGZK.js";
+import "./chunk-4ZNGQH7C.js";
+import {
+  stripRuntimeTurnContext,
+  unescapeXml,
+  unwrapCurrentInstruction
+} from "./chunk-M3UAVLEN.js";
+import {
+  juniorDestinations
+} from "./chunk-FXFQNHRU.js";
+import {
+  canExposeConversationPayload,
+  parseSlackThreadId,
+  resolveConversationPrivacy
+} from "./chunk-RT5BUHR5.js";
+import "./chunk-B7PUBQQM.js";
+import {
+  logException
+} from "./chunk-AEWZ7F65.js";
+import {
+  isRecord
+} from "./chunk-OB42YVAE.js";
+import "./chunk-6GWA276C.js";
+import "./chunk-7FBGKXPE.js";
 import "./chunk-MLKGABMK.js";
 
 // src/api.ts
+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 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."
+  });
+}
+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."
+  });
+}
+
+// src/api/conversations/archive.ts
+var archiveBodySchema = z.object({ archived: z.boolean(), lastSeenAt: z.string().datetime() }).strict();
+async function archiveIfUnchanged(args) {
+  const db = getDb();
+  const rows = await db.update(juniorConversations).set({ archivedAt: args.archived ? /* @__PURE__ */ new Date() : null }).where(
+    and(
+      eq(juniorConversations.conversationId, args.conversationId),
+      args.archived ? eq(juniorConversations.lastActivityAt, new Date(args.lastSeenAt)) : isNotNull(juniorConversations.archivedAt)
+    )
+  ).returning({ conversationId: juniorConversations.conversationId });
+  if (rows.length > 0) return "updated";
+  const [existing] = await db.select({
+    archivedAt: juniorConversations.archivedAt,
+    conversationId: juniorConversations.conversationId
+  }).from(juniorConversations).where(eq(juniorConversations.conversationId, args.conversationId)).limit(1);
+  if (!existing) return "not_found";
+  if (!args.archived && existing.archivedAt === null) return "updated";
+  return "conflict";
+}
+var archive_default = {
+  method: "patch",
+  path: "/:conversationId/archive",
+  handler: async (c) => {
+    const { conversationId } = parseParams(
+      conversationParamsSchema,
+      c.req.param()
+    );
+    let input;
+    try {
+      input = await c.req.json();
+    } catch (error) {
+      throw new HTTPException2(400, {
+        cause: error,
+        message: "Invalid request body."
+      });
+    }
+    const parsed = archiveBodySchema.safeParse(input);
+    if (!parsed.success) {
+      throw new HTTPException2(400, {
+        cause: parsed.error,
+        message: "Invalid request body."
+      });
+    }
+    const body = parsed.data;
+    const result = await archiveIfUnchanged({ ...body, conversationId });
+    if (result === "not_found") {
+      return Response.json(
+        { error: "Conversation not found." },
+        { status: 404 }
+      );
+    }
+    if (result === "conflict") {
+      return Response.json(
+        { error: "Conversation received new activity." },
+        { status: 409 }
+      );
+    }
+    return Response.json({ archived: body.archived });
+  }
+};
+
+// src/api/conversations/detail-projection.ts
+import { isDeepStrictEqual } from "util";
+
+// src/api/conversations/transcript.ts
+var SAFE_METADATA_KEY_LIMIT = 20;
+var LEGACY_ADVISOR_TASK_OPEN = "<advisor-task>\n";
+var LEGACY_ADVISOR_TASK_CLOSE = "\n</advisor-task>";
+var LEGACY_EXECUTOR_CONTEXT_OPEN = "<executor-context>\n";
+var LEGACY_EXECUTOR_CONTEXT_CLOSE = "\n</executor-context>";
+function unwrapLegacyAdvisorTask(text) {
+  if (!text.startsWith(LEGACY_ADVISOR_TASK_OPEN) || !text.endsWith(LEGACY_EXECUTOR_CONTEXT_CLOSE)) {
+    return void 0;
+  }
+  const taskEnd = text.indexOf(
+    LEGACY_ADVISOR_TASK_CLOSE,
+    LEGACY_ADVISOR_TASK_OPEN.length
+  );
+  if (taskEnd < 0) return void 0;
+  const contextStart = taskEnd + LEGACY_ADVISOR_TASK_CLOSE.length + 2;
+  if (!text.startsWith(LEGACY_EXECUTOR_CONTEXT_OPEN, contextStart)) {
+    return void 0;
+  }
+  const task = text.slice(LEGACY_ADVISOR_TASK_OPEN.length, taskEnd);
+  const context = text.slice(
+    contextStart + LEGACY_EXECUTOR_CONTEXT_OPEN.length,
+    -LEGACY_EXECUTOR_CONTEXT_CLOSE.length
+  );
+  return `${unescapeXml(task)}
+
+Executor context:
+${unescapeXml(context)}`;
+}
+function textPart(text) {
+  return { type: "text", text };
+}
+function recordField(value, names) {
+  for (const name of names) {
+    if (value[name] !== void 0) {
+      return value[name];
+    }
+  }
+  return void 0;
+}
+function thinkingOutput(part) {
+  const output = recordField(part, ["thinking", "text", "content", "output"]);
+  return isRecord(output) ? recordField(output, ["thinking", "text", "content", "output"]) : output;
+}
+function isDisplayableTranscriptPart(part) {
+  if (part.type !== "thinking") return true;
+  return typeof part.output === "string" && part.output.trim().length > 0;
+}
+function normalizeTranscriptPart(part, options = {}) {
+  const displayText = (text) => {
+    if (options.unwrapCurrentTask) {
+      const instruction = unwrapCurrentInstruction(text);
+      if (instruction !== void 0) return instruction;
+    }
+    if (options.unwrapLegacyAdvisorTask) {
+      return unwrapLegacyAdvisorTask(text) ?? text;
+    }
+    return text;
+  };
+  if (typeof part === "string") {
+    return textPart(displayText(part));
+  }
+  if (!isRecord(part)) {
+    return { type: "unknown", output: part };
+  }
+  const rawType = typeof part.type === "string" ? part.type : "unknown";
+  if (rawType === "text") {
+    const text = recordField(part, ["text", "content"]);
+    return textPart(
+      typeof text === "string" ? displayText(text) : JSON.stringify(text) ?? ""
+    );
+  }
+  if (rawType === "toolCall") {
+    return {
+      type: "tool_call",
+      ...typeof part.id === "string" ? { id: part.id } : {},
+      ...typeof part.name === "string" ? { name: part.name } : {},
+      input: recordField(part, ["arguments", "input", "args"])
+    };
+  }
+  if (rawType === "toolResult") {
+    return {
+      type: "tool_result",
+      ...typeof part.id === "string" ? { id: part.id } : {},
+      ...typeof part.name === "string" ? { name: part.name } : {},
+      output: recordField(part, ["result", "output", "content"])
+    };
+  }
+  if (rawType === "thinking") {
+    return {
+      type: "thinking",
+      output: thinkingOutput(part)
+    };
+  }
+  return {
+    type: "unknown",
+    ...rawType !== "unknown" ? { sourceType: rawType } : {},
+    output: part
+  };
+}
+function normalizeToolResultMessage(record) {
+  const content = record.content;
+  let output = content;
+  if (Array.isArray(content) && content.length === 1 && isRecord(content[0])) {
+    const extracted = recordField(content[0], [
+      "text",
+      "content",
+      "output",
+      "result"
+    ]);
+    output = extracted !== void 0 ? extracted : content;
+  }
+  return {
+    type: "tool_result",
+    ...typeof record.toolCallId === "string" ? { id: record.toolCallId } : {},
+    ...typeof record.name === "string" ? { name: record.name } : typeof record.toolName === "string" ? { name: record.toolName } : {},
+    output
+  };
+}
+function normalizeTranscriptMessage(message) {
+  return normalizeMessage(message);
+}
+function normalizeSubagentTranscriptMessage(message, subagentKind) {
+  return normalizeMessage(message, {
+    unwrapLegacyAdvisorTask: subagentKind === "advisor"
+  });
+}
+function normalizeMessage(message, options = {}) {
+  const record = message;
+  const content = record.content;
+  const role = transcriptRole(record.role);
+  return {
+    role,
+    ...role === "assistant" && (record.stopReason === "error" || record.stopReason === "aborted") ? { outcome: record.stopReason } : {},
+    ...typeof record.timestamp === "number" ? { timestamp: record.timestamp } : {},
+    parts: role === "toolResult" ? [normalizeToolResultMessage(record)] : Array.isArray(content) ? content.map(
+      (part) => normalizeTranscriptPart(part, {
+        unwrapCurrentTask: role === "user",
+        unwrapLegacyAdvisorTask: options.unwrapLegacyAdvisorTask && role === "user"
+      })
+    ).filter(isDisplayableTranscriptPart) : [
+      normalizeTranscriptPart(content, {
+        unwrapCurrentTask: role === "user",
+        unwrapLegacyAdvisorTask: options.unwrapLegacyAdvisorTask && role === "user"
+      })
+    ]
+  };
+}
+function transcriptRole(role) {
+  return role === "assistant" || role === "system" || role === "tool" || role === "toolResult" || role === "user" ? role : "unknown";
+}
+function serializedChars(value) {
+  if (typeof value === "string") return value.length;
+  return JSON.stringify(value)?.length ?? 0;
+}
+function serializedBytes(value) {
+  const serialized = typeof value === "string" ? value : JSON.stringify(value);
+  return new TextEncoder().encode(serialized ?? "").byteLength;
+}
+function payloadType(value) {
+  return Array.isArray(value) ? "array" : typeof value;
+}
+function payloadKeys(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return void 0;
+  }
+  const keys = Object.keys(value).slice(
+    0,
+    SAFE_METADATA_KEY_LIMIT
+  );
+  return keys.length > 0 ? keys : void 0;
+}
+function redactedPayloadFields(prefix, value) {
+  const keys = payloadKeys(value);
+  return {
+    [`${prefix}Type`]: payloadType(value),
+    [`${prefix}SizeBytes`]: serializedBytes(value),
+    [`${prefix}SizeChars`]: serializedChars(value),
+    ...keys ? { [`${prefix}Keys`]: keys } : {}
+  };
+}
+function redactTranscriptPart(part) {
+  if (part.type === "text") {
+    return {
+      type: "text",
+      redacted: true,
+      bytes: serializedBytes(part.text ?? ""),
+      chars: serializedChars(part.text ?? "")
+    };
+  }
+  if (part.type === "thinking") {
+    return {
+      type: "thinking",
+      redacted: true,
+      ...redactedPayloadFields("output", part.output)
+    };
+  }
+  if (part.type === "tool_call") {
+    return {
+      type: "tool_call",
+      redacted: true,
+      ...part.id ? { id: part.id } : {},
+      ...part.name ? { name: part.name } : {},
+      ...redactedPayloadFields("input", part.input)
+    };
+  }
+  if (part.type === "tool_result") {
+    return {
+      type: "tool_result",
+      redacted: true,
+      ...part.id ? { id: part.id } : {},
+      ...part.name ? { name: part.name } : {},
+      ...redactedPayloadFields("output", part.output)
+    };
+  }
+  return {
+    type: "unknown",
+    redacted: true,
+    ...part.sourceType ? { sourceType: part.sourceType } : {},
+    ...redactedPayloadFields("output", part.output ?? part.input ?? part.text)
+  };
+}
+function redactTranscriptMessage(message) {
+  return {
+    role: message.role,
+    ...message.outcome ? { outcome: message.outcome } : {},
+    ...typeof message.timestamp === "number" ? { timestamp: message.timestamp } : {},
+    parts: message.parts.map(redactTranscriptPart)
+  };
+}
+function isConversationMessageRole(role) {
+  return role === "user" || role === "assistant";
+}
+function hasTextPart(message) {
+  return message.parts.some((part) => {
+    if (part.type !== "text") return false;
+    if (part.redacted) return true;
+    return typeof part.text === "string" && part.text.trim().length > 0;
+  });
+}
+function isConversationMessage(message) {
+  if (!isConversationMessageRole(message.role)) return false;
+  if (message.role === "assistant") return hasTextPart(message);
+  return message.parts.length > 0;
+}
+function countConversationMessages(transcript) {
+  return transcript.filter(isConversationMessage).length;
+}
+function traceIdFromTranscript(transcript) {
+  for (const message of transcript) {
+    for (const part of message.parts) {
+      const text = part.text ?? (typeof part.output === "string" ? part.output : typeof part.input === "string" ? part.input : void 0);
+      const match = text?.match(
+        /\btrace[_-]?id["']?\s*[:=]\s*["']?([a-f0-9]{16,32})\b/i
+      );
+      if (match?.[1]) {
+        return match[1];
+      }
+    }
+  }
+  return void 0;
+}
+function subagentTranscriptReport(activity, options = {}) {
+  return {
+    type: "subagent",
+    ...options.subagentConversationId ? { subagentConversationId: options.subagentConversationId } : {},
+    createdAt: activity.createdAt,
+    id: activity.id,
+    ...activity.modelId ? { modelId: activity.modelId } : {},
+    status: activity.status,
+    ...options.subagentSentryConversationUrl ? { subagentSentryConversationUrl: options.subagentSentryConversationUrl } : {},
+    subagentKind: activity.subagentKind,
+    transcript: options.transcript ?? [],
+    transcriptAvailable: Boolean(options.transcript?.length),
+    ...activity.endedAt ? { endedAt: activity.endedAt } : {},
+    ...activity.outcome ? { outcome: activity.outcome } : {},
+    ...activity.parentToolCallId ? { parentToolCallId: activity.parentToolCallId } : {},
+    ...activity.reasoningLevel ? { reasoningLevel: activity.reasoningLevel } : {},
+    ...options.transcriptMessageCount !== void 0 ? { transcriptMessageCount: options.transcriptMessageCount } : {},
+    ...options.transcriptRedacted ? { transcriptRedacted: options.transcriptRedacted } : {},
+    ...options.transcriptRedactionReason ? { transcriptRedactionReason: options.transcriptRedactionReason } : {},
+    ...options.transcriptExpired ? { transcriptExpired: options.transcriptExpired } : {},
+    ...options.transcriptExpiredAt ? { transcriptExpiredAt: options.transcriptExpiredAt } : {},
+    ...options.unavailableReason ? { unavailableReason: options.unavailableReason } : {}
+  };
+}
+
+// src/api/conversations/activity.ts
+function toolResultStatuses(messages) {
+  const statuses = /* @__PURE__ */ new Map();
+  for (const message of messages) {
+    const record = message;
+    if (record.role !== "toolResult" || typeof record.toolCallId !== "string") {
+      continue;
+    }
+    statuses.set(record.toolCallId, record.isError ? "error" : "completed");
+  }
+  return statuses;
+}
+function activityPayloadFields(args, canExposePayload) {
+  if (args === void 0) {
+    return {};
+  }
+  return canExposePayload ? { args } : { redacted: true, ...redactedPayloadFields("input", args) };
+}
+function buildConversationActivityFromSteps(args) {
+  const toolStatuses = toolResultStatuses(args.messages);
+  const subagentEnds = /* @__PURE__ */ new Map();
+  const subagentsByToolCallId = /* @__PURE__ */ new Map();
+  const orphanSubagents = [];
+  for (const step of args.steps) {
+    if (step.entry.type === "subagent_ended") {
+      subagentEnds.set(
+        step.entry.subagentInvocationId,
+        step
+      );
+    }
+  }
+  for (const step of args.steps) {
+    if (step.entry.type !== "subagent_started") {
+      continue;
+    }
+    const start = step;
+    const parentStatus = start.entry.parentToolCallId ? toolStatuses.get(start.entry.parentToolCallId) : void 0;
+    const activity = subagentActivityFromSteps(
+      start,
+      subagentEnds.get(start.entry.subagentInvocationId),
+      { canExposeTranscript: args.canExposePayload, parentStatus }
+    );
+    if (start.entry.parentToolCallId) {
+      subagentsByToolCallId.set(start.entry.parentToolCallId, [
+        ...subagentsByToolCallId.get(start.entry.parentToolCallId) ?? [],
+        activity
+      ]);
+      continue;
+    }
+    orphanSubagents.push(activity);
+  }
+  const rows = [];
+  for (const step of args.steps) {
+    if (step.entry.type !== "tool_execution_started") {
+      continue;
+    }
+    rows.push({
+      type: "tool_execution",
+      id: step.entry.toolCallId,
+      toolCallId: step.entry.toolCallId,
+      toolName: step.entry.toolName,
+      createdAt: new Date(step.createdAtMs).toISOString(),
+      status: toolStatuses.get(step.entry.toolCallId) ?? "running",
+      subagents: subagentsByToolCallId.get(step.entry.toolCallId) ?? [],
+      ...activityPayloadFields(step.entry.args, args.canExposePayload)
+    });
+  }
+  return [...rows, ...orphanSubagents].sort(
+    (left, right) => Date.parse(left.createdAt) - Date.parse(right.createdAt) || left.id.localeCompare(right.id)
+  );
+}
+function subagentActivityFromSteps(start, end, options = {}) {
+  return {
+    type: "subagent",
+    id: start.entry.subagentInvocationId,
+    subagentKind: start.entry.subagentKind,
+    ...start.entry.modelId ? { modelId: start.entry.modelId } : {},
+    ...start.entry.parentToolCallId ? { parentToolCallId: start.entry.parentToolCallId } : {},
+    ...start.entry.reasoningLevel ? { reasoningLevel: start.entry.reasoningLevel } : {},
+    createdAt: new Date(start.createdAtMs).toISOString(),
+    ...end ? {
+      endedAt: new Date(end.createdAtMs).toISOString(),
+      outcome: end.entry.outcome,
+      status: end.entry.outcome,
+      // Every subagent is a child conversation whose transcript loads on
+      // demand; expose the affordance only when the parent is public.
+      ...options.canExposeTranscript ? { transcriptAvailable: true } : {}
+    } : { status: options.parentStatus ?? "running" }
+  };
+}
+
+// src/api/conversations/shared.ts
+function slackStatsLocationLabel(input) {
+  const channelId = input.channel;
+  if (!channelId) return void 0;
+  if (input.channelNameRedacted && input.channelName) {
+    return input.channelName;
+  }
+  const name = input.channelName?.replace(/^#/, "");
+  if (channelId.startsWith("D")) return "Direct Message";
+  if (channelId.startsWith("C")) return name ? `#${name}` : "Public Channel";
+  if (channelId.startsWith("G")) {
+    if (name?.startsWith("mpdm-")) return "Group DM";
+    return "Private Channel";
+  }
+  return name || channelId;
+}
+function surfaceFallbackLabel(surface) {
+  if (surface === "scheduler") return "Scheduler";
+  if (surface === "api") return "API";
+  if (surface === "internal") return "Internal";
+  return "Conversation";
+}
+
+// src/api/conversations/projection.ts
+var PRIVATE_CONVERSATION_LABEL = "Private Conversation";
+function privateConversationLabel(slackConversation) {
+  if (!slackConversation) {
+    return PRIVATE_CONVERSATION_LABEL;
+  }
+  return slackConversation.visibility === "private" ? formatSlackConversationRedactedLabel(slackConversation) ?? PRIVATE_CONVERSATION_LABEL : PRIVATE_CONVERSATION_LABEL;
+}
+function surfaceFromConversationId(conversationId) {
+  if (parseSlackThreadId(conversationId)) return "slack";
+  if (conversationId.startsWith("scheduler:")) return "scheduler";
+  if (conversationId.startsWith("api:")) return "api";
+  return "internal";
+}
+function surfaceFromSource(source, conversationId) {
+  if (source === "slack" || source === "api" || source === "scheduler") {
+    return source;
+  }
+  return surfaceFromConversationId(conversationId);
+}
+function actorIdentityReport(actor) {
+  if (!actor) return void 0;
+  const identity = {
+    ...actor.email !== void 0 ? { email: actor.email } : {},
+    ...actor.fullName !== void 0 ? { fullName: actor.fullName } : {},
+    ...actor.slackUserId !== void 0 ? { slackUserId: actor.slackUserId } : {},
+    ...actor.slackUserName !== void 0 ? { slackUserName: actor.slackUserName } : {}
+  };
+  return Object.keys(identity).length > 0 ? identity : void 0;
+}
+function statusFromConversation(conversation) {
+  if (conversation.execution.status === "idle") {
+    return "completed";
+  }
+  if (conversation.execution.status === "failed") {
+    return "failed";
+  }
+  return "active";
+}
+function titleFromConversation(args) {
+  const slackThread = parseSlackThreadId(args.conversation.conversationId);
+  const effectiveChannelName = args.conversation.channelName;
+  const slackConversation = resolveSlackConversationContextFromThreadId({
+    threadId: args.conversation.conversationId,
+    channelName: effectiveChannelName
+  });
+  const privateLabel = resolveConversationPrivacy({
+    conversationId: args.conversation.conversationId,
+    visibility: args.conversation.visibility
+  }) !== "public" ? privateConversationLabel(slackConversation) : void 0;
+  return privateLabel ?? args.conversation.title ?? slackStatsLocationLabel({
+    channel: slackThread?.channelId,
+    channelName: effectiveChannelName
+  }) ?? surfaceFallbackLabel(args.surface);
+}
+function channelNameFromConversation(conversation) {
+  const effectiveChannelName = conversation.channelName;
+  const slackThread = parseSlackThreadId(conversation.conversationId);
+  if (!effectiveChannelName && !slackThread) {
+    return void 0;
+  }
+  const slackConversation = resolveSlackConversationContextFromThreadId({
+    threadId: conversation.conversationId,
+    channelName: effectiveChannelName
+  });
+  if (resolveConversationPrivacy({
+    conversationId: conversation.conversationId,
+    visibility: conversation.visibility
+  }) !== "public") {
+    return privateConversationLabel(slackConversation);
+  }
+  return effectiveChannelName;
+}
+function channelNameRedactedFromConversation(conversation) {
+  const effectiveChannelName = conversation.channelName;
+  const slackThread = parseSlackThreadId(conversation.conversationId);
+  if (!effectiveChannelName && !slackThread) {
+    return false;
+  }
+  return resolveConversationPrivacy({
+    conversationId: conversation.conversationId,
+    visibility: conversation.visibility
+  }) !== "public";
+}
+function conversationSummaryFromStoredConversation(args) {
+  const { conversation, durationMs, usage } = args;
+  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);
+  return {
+    conversationId: conversation.conversationId,
+    cumulativeDurationMs: durationMs,
+    displayTitle: titleFromConversation({ conversation, surface }),
+    lastProgressAt: new Date(
+      conversation.execution.updatedAtMs ?? conversation.updatedAtMs
+    ).toISOString(),
+    lastSeenAt: new Date(conversation.lastActivityAtMs).toISOString(),
+    startedAt: new Date(conversation.createdAtMs).toISOString(),
+    status: statusFromConversation(conversation),
+    surface,
+    ...usage ? { cumulativeUsage: usage } : {},
+    ...actorIdentity ? { actorIdentity } : {},
+    ...conversation.archivedAtMs ? { archivedAt: new Date(conversation.archivedAtMs).toISOString() } : {},
+    ...slackThread ? { channel: slackThread.channelId } : {},
+    ...channelName ? { channelName } : {},
+    ...channelNameRedacted ? { channelNameRedacted: true } : {},
+    ...args.locationId && !channelNameRedacted ? { locationId: args.locationId } : {}
+  };
+}
+
+// src/api/conversations/detail-projection.ts
+var COMPACTION_SUMMARY_PREFIXES = [
+  "Context compaction summary for future Junior turns:",
+  "Context handoff summary for future Junior turns:"
+];
+var MODEL_HANDOFF_SUMMARY_PREFIX = "Model handoff checkpoint. Continue the outstanding request now using this summary as the complete prior context:";
+function messageText(message) {
+  return normalizeTranscriptMessage(message).parts.filter((part) => part.type === "text").map((part) => part.text ?? "").join("\n").trim();
+}
+function summaryAfterPrefix(message, prefixes) {
+  const text = messageText(message);
+  const prefix = prefixes.find((candidate) => text.startsWith(candidate));
+  if (!prefix) return void 0;
+  return text.slice(prefix.length).trim();
+}
+function summaryIndex(messages, provenance, prefixes) {
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    if (provenance[index]?.authority === "context" && summaryAfterPrefix(messages[index], prefixes) !== void 0) {
+      return index;
+    }
+  }
+  return -1;
+}
+function matchingPrefix(left, right) {
+  const limit = Math.min(left.length, right.length);
+  for (let index = 0; index < limit; index += 1) {
+    if (!isDeepStrictEqual(left[index], right[index])) return index;
+  }
+  return limit;
+}
+function historyContent(args) {
+  const contextEvents = [];
+  const messages = [];
+  const epochs = /* @__PURE__ */ new Map();
+  for (const step of args.steps) {
+    const epoch = epochs.get(step.contextEpoch);
+    if (epoch) epoch.push(step);
+    else epochs.set(step.contextEpoch, [step]);
+  }
+  let previousModelId;
+  let previousProjection = [];
+  for (const steps of epochs.values()) {
+    const marker = steps.find(
+      (step) => step.entry.type === "context_epoch_started"
+    );
+    const projection = projectSteps(steps);
+    const projected = [];
+    const projectedProvenance = [];
+    projection.messages.forEach((message, index) => {
+      for (const retained of stripRuntimeTurnContext([message])) {
+        projected.push(retained);
+        projectedProvenance.push(projection.provenance[index]);
+      }
+    });
+    const replacementSummaryIndex = marker?.entry.reason === "compaction" ? summaryIndex(
+      projected,
+      projectedProvenance,
+      COMPACTION_SUMMARY_PREFIXES
+    ) : marker?.entry.reason === "handoff" ? summaryIndex(projected, projectedProvenance, [
+      MODEL_HANDOFF_SUMMARY_PREFIX
+    ]) : -1;
+    const summary = marker?.entry.reason === "compaction" && replacementSummaryIndex >= 0 ? summaryAfterPrefix(
+      projected[replacementSummaryIndex],
+      COMPACTION_SUMMARY_PREFIXES
+    ) : void 0;
+    const handoffMessage = marker?.entry.reason === "handoff" && replacementSummaryIndex >= 0 ? messageText(projected[replacementSummaryIndex]) || void 0 : void 0;
+    if (marker?.entry.reason === "compaction") {
+      contextEvents.push({
+        type: "context_compacted",
+        createdAt: new Date(marker.createdAtMs).toISOString(),
+        ...marker.entry.modelId ? { modelId: marker.entry.modelId } : {},
+        ...args.canExposePayload && summary ? { summary } : {},
+        transcriptIndex: messages.length
+      });
+    } else if (marker?.entry.reason === "handoff") {
+      contextEvents.push({
+        type: "model_handoff",
+        createdAt: new Date(marker.createdAtMs).toISOString(),
+        ...previousModelId ? { fromModelId: previousModelId } : {},
+        toModelId: marker.entry.modelId,
+        ...args.canExposePayload && handoffMessage ? { message: handoffMessage } : {},
+        transcriptIndex: messages.length
+      });
+    }
+    if (marker?.entry.reason === "rollback") {
+      messages.push(
+        ...projected.slice(matchingPrefix(previousProjection, projected))
+      );
+    } else {
+      const copiedMessageIndexes = /* @__PURE__ */ new Set();
+      projected.forEach((message, index) => {
+        if (index === replacementSummaryIndex) return;
+        let copiedCompactionMessage = false;
+        if (marker?.entry.reason === "compaction" && replacementSummaryIndex >= 0 && index < replacementSummaryIndex) {
+          const copiedIndex = messages.findIndex(
+            (candidate, candidateIndex) => !copiedMessageIndexes.has(candidateIndex) && isDeepStrictEqual(candidate, message)
+          );
+          copiedCompactionMessage = copiedIndex >= 0;
+          if (copiedCompactionMessage) copiedMessageIndexes.add(copiedIndex);
+        }
+        if (!copiedCompactionMessage) messages.push(message);
+      });
+    }
+    previousModelId = marker?.entry.modelId ?? previousModelId;
+    previousProjection = projected;
+  }
+  return { contextEvents, messages };
+}
+async function conversationContent(args) {
+  const steps = await args.stepStore.loadHistory(args.conversationId);
+  const history = historyContent({
+    canExposePayload: args.canExposePayload,
+    steps
+  });
+  const messages = history.messages;
+  const transcript = messages.length > 0 ? messages.map((message) => normalizeTranscriptMessage(message)) : (await args.messageStore.list(args.conversationId)).map(
+    visibleMessageTranscript
+  );
+  return {
+    activity: buildConversationActivityFromSteps({
+      canExposePayload: args.canExposePayload,
+      steps,
+      messages
+    }),
+    contextEvents: history.contextEvents,
+    transcript
+  };
+}
+function visibleMessageTranscript(message) {
+  return {
+    role: message.role,
+    timestamp: message.createdAtMs,
+    parts: [{ type: "text", text: message.text }]
+  };
+}
+async function buildConversationDetail(args) {
+  const { conversation } = args;
+  const conversationId = conversation.conversationId;
+  const nowMs = Date.now();
+  const stepStore = getAgentStepStore();
+  const messageStore = getConversationMessageStore();
+  const transcriptPurgedAtMs = conversation.transcriptPurgedAtMs;
+  const transcriptExpiredAt = transcriptPurgedAtMs !== void 0 ? new Date(transcriptPurgedAtMs).toISOString() : void 0;
+  const canExposeSqlContent = canExposeConversationPayload({
+    conversationId,
+    visibility: conversation.visibility
+  });
+  const currentContent = transcriptPurgedAtMs === void 0 ? await conversationContent({
+    conversationId,
+    messageStore,
+    stepStore,
+    canExposePayload: canExposeSqlContent
+  }) : { activity: [], contextEvents: [], transcript: [] };
+  const currentTranscript = currentContent.transcript;
+  const traceId = canExposeSqlContent ? traceIdFromTranscript(currentTranscript) : void 0;
+  const sentryTraceUrl = traceId ? buildSentryTraceUrl(traceId) : void 0;
+  const sentryConversationUrl = buildSentryConversationUrl(conversationId);
+  return {
+    ...conversationSummaryFromStoredConversation({
+      conversation,
+      durationMs: args.durationMs,
+      ...args.locationId ? { locationId: args.locationId } : {},
+      usage: args.usage
+    }),
+    ...traceId ? { traceId } : {},
+    ...sentryTraceUrl ? { sentryTraceUrl } : {},
+    activity: currentContent.activity,
+    contextEvents: currentContent.contextEvents,
+    transcriptAvailable: transcriptExpiredAt === void 0 && canExposeSqlContent && currentTranscript.length > 0,
+    ...currentTranscript.length > 0 ? {
+      transcriptMessageCount: countConversationMessages(currentTranscript)
+    } : {},
+    ...!canExposeSqlContent && transcriptExpiredAt === void 0 ? {
+      transcriptMetadata: currentTranscript.map(redactTranscriptMessage),
+      transcriptRedacted: true,
+      transcriptRedactionReason: "non_public_conversation"
+    } : {},
+    ...transcriptExpiredAt !== void 0 ? {
+      transcriptExpired: true,
+      transcriptExpiredAt,
+      transcriptMetadata: []
+    } : {},
+    transcript: transcriptExpiredAt === void 0 && canExposeSqlContent ? currentTranscript : [],
+    generatedAt: new Date(nowMs).toISOString(),
+    ...sentryConversationUrl ? { sentryConversationUrl } : {}
+  };
+}
+async function buildConversationSubagent(conversation, subagentId) {
+  const conversationId = conversation.conversationId;
+  const stepStore = getAgentStepStore();
+  const parentSteps = await stepStore.loadHistory(conversationId);
+  if (conversation?.transcriptPurgedAtMs !== void 0) {
+    return {
+      type: "subagent",
+      createdAt: (/* @__PURE__ */ new Date(0)).toISOString(),
+      id: subagentId,
+      status: "completed",
+      subagentKind: "unknown",
+      transcript: [],
+      transcriptAvailable: false,
+      transcriptExpired: true,
+      transcriptExpiredAt: new Date(
+        conversation.transcriptPurgedAtMs
+      ).toISOString()
+    };
+  }
+  const start = parentSteps.find(
+    (step) => step.entry.type === "subagent_started" && step.entry.subagentInvocationId === subagentId
+  );
+  if (!start) {
+    return {
+      type: "subagent",
+      createdAt: (/* @__PURE__ */ new Date(0)).toISOString(),
+      id: subagentId,
+      status: "error",
+      subagentKind: "unknown",
+      transcript: [],
+      transcriptAvailable: false,
+      unavailableReason: "not_found"
+    };
+  }
+  const end = parentSteps.find(
+    (step) => step.entry.type === "subagent_ended" && step.entry.subagentInvocationId === subagentId
+  );
+  const childConversationId = start.entry.childConversationId;
+  const activity = subagentActivityFromSteps(start, end);
+  const subagentSentryConversationUrl = buildSentryConversationUrl(childConversationId);
+  const conversationFields = {
+    subagentConversationId: childConversationId,
+    ...subagentSentryConversationUrl ? { subagentSentryConversationUrl } : {}
+  };
+  const canExposeTranscript = canExposeConversationPayload({
+    conversationId,
+    visibility: conversation?.visibility
+  });
+  if (!canExposeTranscript) {
+    return subagentTranscriptReport(activity, {
+      ...conversationFields,
+      transcriptRedacted: true,
+      transcriptRedactionReason: "non_public_conversation"
+    });
+  }
+  const childMessages = await loadProjection({
+    conversationId: childConversationId
+  });
+  if (childMessages.length === 0) {
+    return subagentTranscriptReport(activity, {
+      ...conversationFields,
+      unavailableReason: "missing_transcript_ref"
+    });
+  }
+  const transcript = childMessages.map(
+    (message) => normalizeSubagentTranscriptMessage(message, activity.subagentKind)
+  );
+  return subagentTranscriptReport(activity, {
+    ...conversationFields,
+    transcript,
+    transcriptMessageCount: countConversationMessages(transcript)
+  });
+}
+
+// src/api/conversations/list.ts
+import { and as and2, asc, desc, eq as eq2, isNull } from "drizzle-orm";
+var CONVERSATION_FEED_LIMIT = 50;
+async function conversationRows(db, limit, actorEmail) {
+  return db.select({
+    conversation: juniorConversations,
+    destinationId: juniorDestinations.id,
+    destinationVisibility: juniorDestinations.visibility,
+    identityDisplayName: juniorIdentities.displayName,
+    identityEmail: juniorIdentities.email,
+    identityHandle: juniorIdentities.handle,
+    identityProvider: juniorIdentities.provider,
+    identitySubjectId: juniorIdentities.providerSubjectId,
+    identityTenantId: juniorIdentities.providerTenantId
+  }).from(juniorConversations).leftJoin(
+    juniorDestinations,
+    eq2(juniorDestinations.id, juniorConversations.destinationId)
+  ).leftJoin(
+    juniorIdentities,
+    eq2(juniorIdentities.id, juniorConversations.actorIdentityId)
+  ).where(
+    and2(
+      isNull(juniorConversations.parentConversationId),
+      isNull(juniorConversations.archivedAt),
+      actorEmail ? and2(
+        eq2(juniorIdentities.emailNormalized, actorEmail),
+        eq2(juniorIdentities.emailVerified, true)
+      ) : void 0
+    )
+  ).orderBy(
+    desc(juniorConversations.lastActivityAt),
+    asc(juniorConversations.conversationId)
+  ).limit(limit);
+}
+function conversationFromRow(row) {
+  const value = row.conversation;
+  const actor = row.identityProvider === "slack" ? {
+    platform: "slack",
+    ...row.identityEmail ? { email: row.identityEmail } : {},
+    ...row.identityDisplayName ? { fullName: row.identityDisplayName } : {},
+    ...row.identitySubjectId ? { slackUserId: row.identitySubjectId } : {},
+    ...row.identityHandle ? { slackUserName: row.identityHandle } : {},
+    ...row.identityTenantId ? { teamId: row.identityTenantId } : {}
+  } : void 0;
+  return {
+    schemaVersion: 1,
+    conversationId: value.conversationId,
+    createdAtMs: value.createdAt.getTime(),
+    lastActivityAtMs: value.lastActivityAt.getTime(),
+    updatedAtMs: value.updatedAt.getTime(),
+    execution: {
+      status: value.executionStatus,
+      ...value.runId ? { runId: value.runId } : {},
+      ...value.executionUpdatedAt ? { updatedAtMs: value.executionUpdatedAt.getTime() } : {}
+    },
+    ...actor ? { actor } : {},
+    ...value.archivedAt ? { archivedAtMs: value.archivedAt.getTime() } : {},
+    ...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"
+    } : {}
+  };
+}
+async function readConversationRecordFromSql(conversationId) {
+  const db = getDb();
+  const rows = await db.select({
+    conversation: juniorConversations,
+    destinationId: juniorDestinations.id,
+    destinationVisibility: juniorDestinations.visibility,
+    identityDisplayName: juniorIdentities.displayName,
+    identityEmail: juniorIdentities.email,
+    identityHandle: juniorIdentities.handle,
+    identityProvider: juniorIdentities.provider,
+    identitySubjectId: juniorIdentities.providerSubjectId,
+    identityTenantId: juniorIdentities.providerTenantId
+  }).from(juniorConversations).leftJoin(
+    juniorDestinations,
+    eq2(juniorDestinations.id, juniorConversations.destinationId)
+  ).leftJoin(
+    juniorIdentities,
+    eq2(juniorIdentities.id, juniorConversations.actorIdentityId)
+  ).where(eq2(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
+  } : void 0;
+}
+async function readConversationFeedFromSql(options = {}) {
+  const nowMs = Date.now();
+  const rows = await conversationRows(
+    getDb(),
+    options.limit ?? CONVERSATION_FEED_LIMIT,
+    options.actorEmail
+  );
+  return {
+    conversations: rows.map(
+      (row) => conversationSummaryFromStoredConversation({
+        conversation: conversationFromRow(row),
+        durationMs: row.conversation.durationMs,
+        ...row.destinationVisibility === "public" && row.destinationId ? { locationId: row.destinationId } : {},
+        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 })
+  );
+}
+var list_default = {
+  method: "get",
+  path: "/",
+  handler: async (c) => {
+    const { actorEmail } = parseQuery(
+      conversationFeedQuerySchema,
+      c.req.query()
+    );
+    return Response.json(await readConversationFeed({ actorEmail }));
+  }
+};
+
+// src/api/conversations/detail.query.ts
+async function readLatestRun(conversationId) {
+  try {
+    return (await listBoundedAgentTurnSessionSummariesForConversation(conversationId)).find((summary) => summary.modelId || summary.reasoningLevel);
+  } catch (error) {
+    logException(error, "conversation_execution_settings_read_failed", {
+      conversationId
+    });
+    return void 0;
+  }
+}
+async function readConversationDetailFromSql(conversationId) {
+  const record = await readConversationRecordFromSql(conversationId);
+  if (!record) return void 0;
+  const [report, latestRun] = await Promise.all([
+    buildConversationDetail({
+      ...record,
+      usage: record.usage ?? void 0
+    }),
+    readLatestRun(conversationId)
+  ]);
+  return {
+    ...report,
+    ...latestRun?.modelId ? { modelId: latestRun.modelId } : {},
+    ...latestRun?.reasoningLevel ? { reasoningLevel: latestRun.reasoningLevel } : {}
+  };
+}
+
+// src/api/conversations/detail.ts
+async function readConversationDetail(conversationId) {
+  const report = await readConversationDetailFromSql(conversationId);
+  return report ? conversationDetailReportSchema.parse(report) : void 0;
+}
+var detail_default = {
+  method: "get",
+  path: "/:conversationId",
+  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 });
+  }
+};
+
+// src/api/conversations/stats.query.ts
+import { and as and3, eq as eq3, gte, isNull as isNull2, lte } from "drizzle-orm";
+
+// src/api/conversations/aggregate.ts
+import { sql } from "drizzle-orm";
+function tokenValue() {
+  return sql`
+    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'
+      ) 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)
+      ELSE NULL
+    END
+  `;
+}
+function costValue() {
+  return sql`
+    CASE
+      WHEN ${juniorConversations.usage}->'cost'->>'total' IS NOT NULL
+        THEN (${juniorConversations.usage}->'cost'->>'total')::double precision
+      WHEN COALESCE(
+        ${juniorConversations.usage}->'cost'->>'input',
+        ${juniorConversations.usage}->'cost'->>'output',
+        ${juniorConversations.usage}->'cost'->>'cacheRead',
+        ${juniorConversations.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)
+      ELSE NULL
+    END
+  `;
+}
+function conversationAggregateColumns() {
+  return {
+    active: sql`COUNT(*) FILTER (
+      WHERE ${juniorConversations.executionStatus} NOT IN ('idle', 'failed')
+    )::integer`,
+    conversations: sql`COUNT(*)::integer`,
+    costUsd: sql`SUM(${costValue()})::double precision`,
+    durationMs: sql`COALESCE(SUM(${juniorConversations.durationMs}), 0)::double precision`,
+    failed: sql`COUNT(*) FILTER (
+      WHERE ${juniorConversations.executionStatus} = 'failed'
+    )::integer`,
+    tokens: sql`SUM(${tokenValue()})::double precision`
+  };
+}
+function conversationRangeColumns() {
+  return {
+    firstSeenAt: sql`MIN(${juniorConversations.createdAt})`.mapWith(
+      juniorConversations.createdAt
+    ),
+    lastSeenAt: sql`MAX(${juniorConversations.lastActivityAt})`.mapWith(
+      juniorConversations.lastActivityAt
+    )
+  };
+}
+function conversationActiveDaysColumn() {
+  return sql`COUNT(DISTINCT (${juniorConversations.lastActivityAt} AT TIME ZONE 'UTC')::date)::integer`;
+}
+
+// src/api/conversations/stats.query.ts
+var WINDOW_MS = 90 * 24 * 60 * 60 * 1e3;
+function emptyStatsItem(label) {
+  return {
+    active: 0,
+    conversations: 0,
+    durationMs: 0,
+    failed: 0,
+    label
+  };
+}
+function addUsd(current, next) {
+  return Math.round(((current ?? 0) + next) * 1e12) / 1e12;
+}
+function actorLabel(row) {
+  return row.userEmail?.trim() || row.identityEmail?.trim() || row.userDisplayName?.trim() || row.identityDisplayName?.trim() || row.identityHandle?.trim() || row.identitySubjectId?.trim() || "Unknown";
+}
+function surfaceLabel(source) {
+  if (source === "scheduler") return "Scheduler";
+  if (source === "api") return "API";
+  if (source === "internal" || source === "local") return "Internal";
+  return "Conversation";
+}
+function locationLabel(row) {
+  if (row.destinationProvider !== "slack") {
+    return surfaceLabel(row.source);
+  }
+  if (row.destinationKind === "dm") {
+    return "Direct Message";
+  }
+  if (row.destinationVisibility !== "public") {
+    return "Private Conversation";
+  }
+  const name = (row.channelName ?? row.destinationDisplayName)?.trim().replace(/^#/, "");
+  return name ? `#${name}` : "Public Channel";
+}
+function addAggregate(map, label, row) {
+  const item = map.get(label) ?? emptyStatsItem(label);
+  item.active += row.active;
+  item.conversations += row.conversations;
+  item.durationMs += row.durationMs;
+  item.failed += row.failed;
+  if (row.tokens !== null) {
+    item.tokens = (item.tokens ?? 0) + row.tokens;
+  }
+  if (row.costUsd !== null) {
+    item.costUsd = addUsd(item.costUsd, row.costUsd);
+  }
+  map.set(label, item);
+}
+function statsItems(map) {
+  return [...map.values()].sort(
+    (left, right) => right.conversations - left.conversations || left.label.localeCompare(right.label)
+  );
+}
+function statsWhere(start, end) {
+  return and3(
+    isNull2(juniorConversations.parentConversationId),
+    gte(juniorConversations.lastActivityAt, start),
+    lte(juniorConversations.lastActivityAt, end)
+  );
+}
+async function aggregateStats(db, start, end) {
+  const where = statsWhere(start, end);
+  const [totalsRows, actorRows, locationRows] = await Promise.all([
+    db.select(conversationAggregateColumns()).from(juniorConversations).where(where),
+    db.select({
+      identityDisplayName: juniorIdentities.displayName,
+      identityEmail: juniorIdentities.emailNormalized,
+      identityHandle: juniorIdentities.handle,
+      identitySubjectId: juniorIdentities.providerSubjectId,
+      userDisplayName: juniorUsers.displayName,
+      userEmail: juniorUsers.primaryEmailNormalized,
+      ...conversationAggregateColumns()
+    }).from(juniorConversations).leftJoin(
+      juniorIdentities,
+      eq3(juniorIdentities.id, juniorConversations.actorIdentityId)
+    ).leftJoin(juniorUsers, eq3(juniorUsers.id, juniorIdentities.userId)).where(where).groupBy(
+      juniorIdentities.displayName,
+      juniorIdentities.emailNormalized,
+      juniorIdentities.handle,
+      juniorIdentities.providerSubjectId,
+      juniorUsers.displayName,
+      juniorUsers.primaryEmailNormalized
+    ),
+    db.select({
+      channelName: juniorConversations.channelName,
+      destinationDisplayName: juniorDestinations.displayName,
+      destinationKind: juniorDestinations.kind,
+      destinationProvider: juniorDestinations.provider,
+      destinationVisibility: juniorDestinations.visibility,
+      source: juniorConversations.source,
+      ...conversationAggregateColumns()
+    }).from(juniorConversations).leftJoin(
+      juniorDestinations,
+      eq3(juniorDestinations.id, juniorConversations.destinationId)
+    ).where(where).groupBy(
+      juniorConversations.channelName,
+      juniorConversations.source,
+      juniorDestinations.displayName,
+      juniorDestinations.kind,
+      juniorDestinations.provider,
+      juniorDestinations.visibility
+    )
+  ]);
+  return { actorRows, locationRows, totals: totalsRows[0] };
+}
+async function readConversationStatsFromSql() {
+  const nowMs = Date.now();
+  const windowStartMs = nowMs - WINDOW_MS;
+  const { actorRows, locationRows, totals } = await aggregateStats(
+    getDb(),
+    new Date(windowStartMs),
+    new Date(nowMs)
+  );
+  const actors = /* @__PURE__ */ new Map();
+  const locations = /* @__PURE__ */ new Map();
+  for (const row of actorRows) {
+    addAggregate(actors, actorLabel(row), row);
+  }
+  for (const row of locationRows) {
+    addAggregate(locations, locationLabel(row), row);
+  }
+  return {
+    active: totals?.active ?? 0,
+    conversations: totals?.conversations ?? 0,
+    durationMs: totals?.durationMs ?? 0,
+    failed: totals?.failed ?? 0,
+    generatedAt: new Date(nowMs).toISOString(),
+    locations: statsItems(locations),
+    actors: statsItems(actors),
+    source: "conversation_index",
+    ...totals?.costUsd !== null && totals?.costUsd !== void 0 ? { costUsd: addUsd(void 0, totals.costUsd) } : {},
+    ...totals?.tokens !== null && totals?.tokens !== void 0 ? { tokens: totals.tokens } : {},
+    windowEnd: new Date(nowMs).toISOString(),
+    windowStart: new Date(windowStartMs).toISOString()
+  };
+}
+
+// src/api/conversations/stats.ts
+async function readConversationStats() {
+  return conversationStatsReportSchema.parse(
+    await readConversationStatsFromSql()
+  );
+}
+var stats_default = {
+  method: "get",
+  path: "/stats",
+  handler: async () => Response.json(await readConversationStats())
+};
+
+// src/api/conversations/subagent.ts
+async function readConversationSubagent(conversationId, subagentId) {
+  const record = await readConversationRecordFromSql(conversationId);
+  if (!record) {
+    return conversationSubagentTranscriptReportSchema.parse({
+      type: "subagent",
+      createdAt: (/* @__PURE__ */ new Date(0)).toISOString(),
+      id: subagentId,
+      status: "error",
+      subagentKind: "unknown",
+      transcript: [],
+      transcriptAvailable: false,
+      unavailableReason: "not_found"
+    });
+  }
+  return conversationSubagentTranscriptReportSchema.parse(
+    await buildConversationSubagent(record.conversation, subagentId)
+  );
+}
+var subagent_default = {
+  method: "get",
+  path: "/:conversationId/subagents/:subagentId",
+  handler: async (c) => {
+    const { conversationId, subagentId } = parseParams(
+      subagentParamsSchema,
+      c.req.param()
+    );
+    const report = await readConversationSubagent(conversationId, subagentId);
+    return report.unavailableReason === "not_found" ? Response.json(report, { status: 404 }) : Response.json(report);
+  }
+};
+
+// src/api/conversations/routes.ts
+var routes = [
+  list_default,
+  stats_default,
+  archive_default,
+  detail_default,
+  subagent_default
+];
+function createConversationRoutes() {
+  const app = new Hono();
+  for (const route of routes) app.on(route.method, route.path, route.handler);
+  return app;
+}
+
+// src/api/locations/routes.ts
+import { Hono as Hono2 } from "hono";
+
+// src/api/locations/query.ts
+import { and as and4, asc as asc2, desc as desc2, eq as eq4, gte as gte2, isNull as isNull3, sql as sql2 } from "drizzle-orm";
+
+// 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";
+  if (surface === "internal") return "Internal";
+  return "Conversation";
+}
+function slackLocationLabel(args) {
+  const channelId = args.channel;
+  if (!channelId) return void 0;
+  if (args.channelNameRedacted && args.channelName) return args.channelName;
+  const name = args.channelName?.replace(/^#/, "");
+  if (channelId.startsWith("D")) return "Direct Message";
+  if (channelId.startsWith("C")) {
+    return name ? `#${name}` : "Public Channel";
+  }
+  if (channelId.startsWith("G")) {
+    if (name?.startsWith("mpdm-")) return "Group DM";
+    return "Private Channel";
+  }
+  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 } : {},
+    ...row.fullName ? { fullName: row.fullName } : {},
+    ...row.providerSubjectId ? { slackUserId: row.providerSubjectId } : {},
+    ...row.handle ? { slackUserName: row.handle } : {}
+  };
+  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 {
+    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 } : {}
+  };
+}
+
+// src/api/locations/query.ts
+var RECENT_LIMIT = 25;
+var ACTIVITY_DAYS = 90;
+function emptyMetrics() {
+  return {
+    active: 0,
+    conversations: 0,
+    durationMs: 0,
+    failed: 0
+  };
+}
+function addMetrics(target, row) {
+  target.active += row.active;
+  target.conversations += row.conversations;
+  target.durationMs += row.durationMs;
+  target.failed += row.failed;
+  if (row.tokens !== null) {
+    target.tokens = (target.tokens ?? 0) + row.tokens;
+  }
+  if (row.costUsd !== null) {
+    target.costUsd = Math.round(((target.costUsd ?? 0) + row.costUsd) * 1e12) / 1e12;
+  }
+}
+function publicLabel(input) {
+  const name = input.displayName?.trim().replace(/^#/, "");
+  return name ? `#${name}` : `Public channel ${input.providerDestinationId}`;
+}
+function actorLabel2(actor) {
+  return actor.email?.trim() || actor.fullName?.trim() || actor.slackUserName?.trim() || actor.slackUserId?.trim() || "Unknown";
+}
+function emptyActor(actor) {
+  return {
+    ...emptyMetrics(),
+    actor,
+    label: actorLabel2(actor)
+  };
+}
+function topLevelWhere() {
+  return isNull3(juniorConversations.parentConversationId);
+}
+function publicLocationWhere(destinationId) {
+  return and4(
+    topLevelWhere(),
+    eq4(juniorDestinations.id, destinationId),
+    eq4(juniorDestinations.visibility, "public")
+  );
+}
+function locationColumns() {
+  return {
+    destinationDisplayName: juniorDestinations.displayName,
+    destinationId: juniorDestinations.id,
+    destinationKind: juniorDestinations.kind,
+    destinationProvider: juniorDestinations.provider,
+    destinationProviderId: juniorDestinations.providerDestinationId,
+    destinationVisibility: juniorDestinations.visibility
+  };
+}
+function locationGroupBy() {
+  return [
+    juniorDestinations.displayName,
+    juniorDestinations.id,
+    juniorDestinations.kind,
+    juniorDestinations.provider,
+    juniorDestinations.providerDestinationId,
+    juniorDestinations.visibility
+  ];
+}
+function locationFromAggregate(row) {
+  if (row.destinationVisibility !== "public" || !row.destinationId || !row.destinationProvider || !row.destinationProviderId || !row.destinationKind) {
+    return void 0;
+  }
+  const location = {
+    ...emptyMetrics(),
+    firstSeenAt: row.firstSeenAt.toISOString(),
+    id: row.destinationId,
+    kind: row.destinationKind,
+    label: publicLabel({
+      displayName: row.destinationDisplayName,
+      providerDestinationId: row.destinationProviderId
+    }),
+    lastSeenAt: row.lastSeenAt.toISOString(),
+    provider: row.destinationProvider,
+    providerDestinationId: row.destinationProviderId,
+    visibility: "public"
+  };
+  addMetrics(location, row);
+  return location;
+}
+async function directoryRows(db) {
+  return db.select({
+    ...locationColumns(),
+    ...conversationAggregateColumns(),
+    ...conversationRangeColumns()
+  }).from(juniorConversations).leftJoin(
+    juniorDestinations,
+    eq4(juniorDestinations.id, juniorConversations.destinationId)
+  ).where(topLevelWhere()).groupBy(...locationGroupBy());
+}
+async function directoryActivityRows(db, start) {
+  const date = sql2`TO_CHAR(
+    ${juniorConversations.lastActivityAt} AT TIME ZONE 'UTC',
+    'YYYY-MM-DD'
+  )`;
+  return db.select({
+    conversations: sql2`COUNT(*)::integer`,
+    date,
+    visibility: juniorDestinations.visibility
+  }).from(juniorConversations).leftJoin(
+    juniorDestinations,
+    eq4(juniorDestinations.id, juniorConversations.destinationId)
+  ).where(and4(topLevelWhere(), gte2(juniorConversations.lastActivityAt, start))).groupBy(date, juniorDestinations.visibility);
+}
+function directoryActivityDays(rows, nowMs) {
+  const days = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const day = days.get(row.date) ?? {
+      date: row.date,
+      privateConversations: 0,
+      publicConversations: 0
+    };
+    if (row.visibility === "public") {
+      day.publicConversations += row.conversations;
+    } else {
+      day.privateConversations += row.conversations;
+    }
+    days.set(row.date, day);
+  }
+  const end = new Date(nowMs);
+  end.setUTCHours(0, 0, 0, 0);
+  const start = new Date(end);
+  start.setUTCDate(start.getUTCDate() - (ACTIVITY_DAYS - 1));
+  const activity = [];
+  for (const cursor = new Date(start); cursor.getTime() <= end.getTime(); cursor.setUTCDate(cursor.getUTCDate() + 1)) {
+    const date = cursor.toISOString().slice(0, 10);
+    activity.push(
+      days.get(date) ?? {
+        date,
+        privateConversations: 0,
+        publicConversations: 0
+      }
+    );
+  }
+  return activity;
+}
+async function readLocationDirectoryFromSql() {
+  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 [rows, activityRows] = await Promise.all([
+    directoryRows(getDb()),
+    directoryActivityRows(getDb(), start)
+  ]);
+  const locations = [];
+  const privateActivity = {
+    ...emptyMetrics(),
+    label: "Private activity"
+  };
+  for (const row of rows) {
+    const location = locationFromAggregate(row);
+    if (location) locations.push(location);
+    else addMetrics(privateActivity, row);
+  }
+  return {
+    activityDays: directoryActivityDays(activityRows, nowMs),
+    generatedAt: new Date(nowMs).toISOString(),
+    locations: locations.sort(
+      (left, right) => Date.parse(right.lastSeenAt) - Date.parse(left.lastSeenAt) || right.conversations - left.conversations || left.label.localeCompare(right.label)
+    ),
+    privateActivity,
+    source: "conversation_index",
+    windowEnd: end.toISOString(),
+    windowStart: start.toISOString()
+  };
+}
+async function recentLocationRows(db, locationId) {
+  return db.select({
+    channelName: juniorConversations.channelName,
+    conversationId: juniorConversations.conversationId,
+    createdAt: juniorConversations.createdAt,
+    destinationId: juniorDestinations.id,
+    destinationVisibility: juniorDestinations.visibility,
+    durationMs: juniorConversations.durationMs,
+    email: sql2`COALESCE(
+        ${juniorUsers.primaryEmailNormalized},
+        ${juniorIdentities.email}
+      )`,
+    executionStatus: juniorConversations.executionStatus,
+    executionUpdatedAt: juniorConversations.executionUpdatedAt,
+    fullName: juniorUsers.displayName,
+    handle: juniorIdentities.handle,
+    lastActivityAt: juniorConversations.lastActivityAt,
+    providerSubjectId: sql2`CASE
+        WHEN ${juniorIdentities.provider} = 'slack'
+          THEN ${juniorIdentities.providerSubjectId}
+        ELSE NULL
+      END`,
+    source: juniorConversations.source,
+    title: juniorConversations.title,
+    updatedAt: juniorConversations.updatedAt,
+    usage: juniorConversations.usage
+  }).from(juniorConversations).innerJoin(
+    juniorDestinations,
+    eq4(juniorDestinations.id, juniorConversations.destinationId)
+  ).leftJoin(
+    juniorIdentities,
+    eq4(juniorIdentities.id, juniorConversations.actorIdentityId)
+  ).leftJoin(juniorUsers, eq4(juniorUsers.id, juniorIdentities.userId)).where(
+    and4(
+      publicLocationWhere(locationId),
+      isNull3(juniorConversations.archivedAt)
+    )
+  ).orderBy(
+    desc2(juniorConversations.lastActivityAt),
+    asc2(juniorConversations.conversationId)
+  ).limit(RECENT_LIMIT);
+}
+async function readLocationDetailFromSql(locationId) {
+  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 = sql2`TO_CHAR(
+    ${juniorConversations.lastActivityAt} AT TIME ZONE 'UTC',
+    'YYYY-MM-DD'
+  )`;
+  const [locationRows, dayRows, actorRows, recentRows] = await Promise.all([
+    getDb().select({
+      ...locationColumns(),
+      ...conversationAggregateColumns(),
+      ...conversationRangeColumns()
+    }).from(juniorConversations).innerJoin(
+      juniorDestinations,
+      eq4(juniorDestinations.id, juniorConversations.destinationId)
+    ).where(where).groupBy(...locationGroupBy()),
+    getDb().select({ date: activityDate, ...conversationAggregateColumns() }).from(juniorConversations).innerJoin(
+      juniorDestinations,
+      eq4(juniorDestinations.id, juniorConversations.destinationId)
+    ).where(and4(where, gte2(juniorConversations.lastActivityAt, start))).groupBy(activityDate),
+    getDb().select({
+      actorIdentityId: juniorConversations.actorIdentityId,
+      email: juniorUsers.primaryEmailNormalized,
+      fullName: juniorUsers.displayName,
+      handle: juniorIdentities.handle,
+      identityEmail: juniorIdentities.email,
+      identityProvider: juniorIdentities.provider,
+      providerSubjectId: juniorIdentities.providerSubjectId,
+      ...conversationAggregateColumns()
+    }).from(juniorConversations).innerJoin(
+      juniorDestinations,
+      eq4(juniorDestinations.id, juniorConversations.destinationId)
+    ).leftJoin(
+      juniorIdentities,
+      eq4(juniorIdentities.id, juniorConversations.actorIdentityId)
+    ).leftJoin(juniorUsers, eq4(juniorUsers.id, juniorIdentities.userId)).where(where).groupBy(
+      juniorConversations.actorIdentityId,
+      juniorUsers.primaryEmailNormalized,
+      juniorUsers.displayName,
+      juniorIdentities.handle,
+      juniorIdentities.email,
+      juniorIdentities.provider,
+      juniorIdentities.providerSubjectId
+    ),
+    recentLocationRows(getDb(), locationId)
+  ]);
+  const locationRow = locationRows[0];
+  const location = locationRow ? locationFromAggregate(locationRow) : void 0;
+  if (!location) return void 0;
+  const days = /* @__PURE__ */ new Map();
+  for (const row of dayRows) {
+    days.set(row.date, {
+      active: row.active,
+      conversations: row.conversations,
+      date: row.date,
+      durationMs: row.durationMs,
+      failed: row.failed,
+      ...row.tokens !== null ? { tokens: row.tokens } : {}
+    });
+  }
+  const actors = [];
+  for (const row of actorRows) {
+    if (!row.actorIdentityId) continue;
+    const actor = {
+      ...row.email ?? row.identityEmail ? { email: row.email ?? row.identityEmail ?? void 0 } : {},
+      ...row.fullName ? { fullName: row.fullName } : {},
+      ...row.identityProvider === "slack" && row.providerSubjectId ? { slackUserId: row.providerSubjectId } : {},
+      ...row.handle ? { slackUserName: row.handle } : {}
+    };
+    if (!actor.email && !actor.slackUserId) continue;
+    const item = emptyActor(actor);
+    addMetrics(item, row);
+    actors.push(item);
+  }
+  const activity = activityDays(days, nowMs, ACTIVITY_DAYS);
+  return {
+    ...location,
+    activityDays: activity,
+    actors: actors.sort(
+      (left, right) => right.conversations - left.conversations || left.label.localeCompare(right.label)
+    ),
+    generatedAt: new Date(nowMs).toISOString(),
+    recentConversations: recentRows.map(summaryFromRow),
+    source: "conversation_index",
+    windowEnd: end.toISOString(),
+    windowStart: activity[0] ? `${activity[0].date}T00:00:00.000Z` : end.toISOString()
+  };
+}
+
+// src/api/locations/detail.ts
+async function readLocationDetail(locationId) {
+  const report = await readLocationDetailFromSql(locationId);
+  return report ? locationDetailReportSchema.parse(report) : void 0;
+}
+var detail_default2 = {
+  method: "get",
+  path: "/:locationId",
+  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 });
+  }
+};
+
+// src/api/locations/list.ts
+async function readLocationDirectory() {
+  return locationDirectoryReportSchema.parse(
+    await readLocationDirectoryFromSql()
+  );
+}
+var list_default2 = {
+  method: "get",
+  path: "/",
+  handler: async () => Response.json(await 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);
+  return app;
+}
+
+// src/api/people/routes.ts
+import { Hono as Hono3 } from "hono";
+
+// src/api/people/list.query.ts
+import { and as and6, eq as eq6, gte as gte3, sql as sql4 } from "drizzle-orm";
+
+// src/api/people/shared.ts
+import { and as and5, asc as asc3, desc as desc3, eq as eq5, isNull as isNull4, sql as sql3 } from "drizzle-orm";
+var RECENT_LIMIT2 = 25;
+var ACTIVITY_DAYS2 = 365;
+function normalizeEmail(email) {
+  const normalized = email?.trim().toLowerCase();
+  return normalized || void 0;
+}
+function emptyTotals() {
+  return {
+    active: 0,
+    activeDays: 0,
+    conversations: 0,
+    durationMs: 0,
+    failed: 0
+  };
+}
+function emptyActivityDay(date) {
+  return {
+    active: 0,
+    conversations: 0,
+    date,
+    durationMs: 0,
+    failed: 0
+  };
+}
+function activityDays2(days, nowMs) {
+  const items = [];
+  const end = new Date(nowMs);
+  end.setUTCHours(0, 0, 0, 0);
+  const start = new Date(end);
+  start.setUTCDate(start.getUTCDate() - (ACTIVITY_DAYS2 - 1));
+  for (const cursor = new Date(start); cursor.getTime() <= end.getTime(); cursor.setUTCDate(cursor.getUTCDate() + 1)) {
+    const date = cursor.toISOString().slice(0, 10);
+    items.push(days.get(date) ?? emptyActivityDay(date));
+  }
+  return items;
+}
+function statsItems2(map) {
+  return [...map.values()].sort(
+    (left, right) => right.conversations - left.conversations || right.durationMs - left.durationMs || left.label.localeCompare(right.label)
+  );
+}
+function verifiedActorWhere(email) {
+  const normalizedEmail = normalizeEmail(email);
+  return and5(
+    eq5(juniorIdentities.provider, "slack"),
+    eq5(juniorIdentities.emailVerified, true),
+    sql3`${juniorUsers.primaryEmailNormalized} IS NOT NULL`,
+    normalizedEmail ? eq5(juniorUsers.primaryEmailNormalized, normalizedEmail) : void 0
+  );
+}
+async function recentActorRows(email) {
+  return getDb().select({
+    channelName: juniorConversations.channelName,
+    conversationId: juniorConversations.conversationId,
+    createdAt: juniorConversations.createdAt,
+    destinationId: juniorDestinations.id,
+    destinationVisibility: juniorDestinations.visibility,
+    durationMs: juniorConversations.durationMs,
+    email: juniorUsers.primaryEmailNormalized,
+    executionStatus: juniorConversations.executionStatus,
+    executionUpdatedAt: juniorConversations.executionUpdatedAt,
+    fullName: juniorUsers.displayName,
+    handle: juniorIdentities.handle,
+    lastActivityAt: juniorConversations.lastActivityAt,
+    providerSubjectId: juniorIdentities.providerSubjectId,
+    source: juniorConversations.source,
+    title: juniorConversations.title,
+    updatedAt: juniorConversations.updatedAt,
+    usage: juniorConversations.usage
+  }).from(juniorConversations).innerJoin(
+    juniorIdentities,
+    eq5(juniorIdentities.id, juniorConversations.actorIdentityId)
+  ).innerJoin(juniorUsers, eq5(juniorUsers.id, juniorIdentities.userId)).leftJoin(
+    juniorDestinations,
+    eq5(juniorDestinations.id, juniorConversations.destinationId)
+  ).where(
+    and5(verifiedActorWhere(email), isNull4(juniorConversations.archivedAt))
+  ).orderBy(
+    desc3(juniorConversations.lastActivityAt),
+    asc3(juniorConversations.conversationId)
+  ).limit(RECENT_LIMIT2);
+}
+
+// src/api/people/list.query.ts
+var DIRECTORY_ACTIVITY_DAYS = 90;
+function activityWindow(nowMs) {
+  const end = new Date(nowMs);
+  end.setUTCHours(0, 0, 0, 0);
+  const start = new Date(end);
+  start.setUTCDate(start.getUTCDate() - (DIRECTORY_ACTIVITY_DAYS - 1));
+  return { end, start };
+}
+function directoryActivityDays2(rows, nowMs) {
+  const days = new Map(rows.map((row) => [row.date, row]));
+  const { end, start } = activityWindow(nowMs);
+  const items = [];
+  for (const cursor = new Date(start); cursor.getTime() <= end.getTime(); cursor.setUTCDate(cursor.getUTCDate() + 1)) {
+    const date = cursor.toISOString().slice(0, 10);
+    items.push(days.get(date) ?? { activePeople: 0, conversations: 0, date });
+  }
+  return items;
+}
+async function readPeopleListFromSql() {
+  const nowMs = Date.now();
+  const { end, start } = activityWindow(nowMs);
+  const activityDate = sql4`TO_CHAR(
+    ${juniorConversations.lastActivityAt} AT TIME ZONE 'UTC',
+    'YYYY-MM-DD'
+  )`;
+  const [rows, activityRows] = await Promise.all([
+    getDb().select({
+      email: juniorUsers.primaryEmailNormalized,
+      fullName: juniorUsers.displayName,
+      slackUserId: sql4`MAX(${juniorIdentities.providerSubjectId})`,
+      slackUserName: sql4`MAX(${juniorIdentities.handle})`,
+      activeDays: conversationActiveDaysColumn(),
+      ...conversationAggregateColumns(),
+      ...conversationRangeColumns()
+    }).from(juniorConversations).innerJoin(
+      juniorIdentities,
+      eq6(juniorIdentities.id, juniorConversations.actorIdentityId)
+    ).innerJoin(juniorUsers, eq6(juniorUsers.id, juniorIdentities.userId)).where(verifiedActorWhere()).groupBy(juniorUsers.primaryEmailNormalized, juniorUsers.displayName),
+    getDb().select({
+      activePeople: sql4`COUNT(DISTINCT ${juniorUsers.id})::int`,
+      conversations: sql4`COUNT(*)::int`,
+      date: activityDate
+    }).from(juniorConversations).innerJoin(
+      juniorIdentities,
+      eq6(juniorIdentities.id, juniorConversations.actorIdentityId)
+    ).innerJoin(juniorUsers, eq6(juniorUsers.id, juniorIdentities.userId)).where(
+      and6(
+        verifiedActorWhere(),
+        gte3(juniorConversations.lastActivityAt, start)
+      )
+    ).groupBy(activityDate)
+  ]);
+  const people = rows.map((row) => {
+    const actor = {
+      email: row.email,
+      ...row.fullName ? { fullName: row.fullName } : {},
+      ...row.slackUserId ? { slackUserId: row.slackUserId } : {},
+      ...row.slackUserName ? { slackUserName: row.slackUserName } : {}
+    };
+    return {
+      active: row.active,
+      activeDays: row.activeDays,
+      conversations: row.conversations,
+      durationMs: row.durationMs,
+      failed: row.failed,
+      firstSeenAt: row.firstSeenAt.toISOString(),
+      lastSeenAt: row.lastSeenAt.toISOString(),
+      actor,
+      ...row.tokens !== null ? { tokens: row.tokens } : {}
+    };
+  });
+  return {
+    activityDays: directoryActivityDays2(activityRows, nowMs),
+    generatedAt: new Date(nowMs).toISOString(),
+    people: people.sort(
+      (left, right) => Date.parse(right.lastSeenAt) - Date.parse(left.lastSeenAt) || right.conversations - left.conversations || left.actor.email.localeCompare(right.actor.email)
+    ),
+    source: "conversation_index",
+    windowEnd: end.toISOString(),
+    windowStart: start.toISOString()
+  };
+}
+
+// src/api/people/list.ts
+async function readPeopleList() {
+  return actorDirectoryReportSchema.parse(await readPeopleListFromSql());
+}
+var list_default3 = {
+  method: "get",
+  path: "/",
+  handler: async () => Response.json(await readPeopleList())
+};
+
+// src/api/people/profile.query.ts
+import { and as and7, eq as eq7, gte as gte4, sql as sql5 } from "drizzle-orm";
+function emptyProfile(email, nowMs) {
+  const end = new Date(nowMs);
+  end.setUTCHours(0, 0, 0, 0);
+  const start = new Date(end);
+  start.setUTCDate(start.getUTCDate() - (ACTIVITY_DAYS2 - 1));
+  return {
+    activityDays: activityDays2(/* @__PURE__ */ new Map(), nowMs),
+    generatedAt: new Date(nowMs).toISOString(),
+    locations: [],
+    recentConversations: [],
+    actor: { email },
+    source: "conversation_index",
+    surfaces: [],
+    totals: emptyTotals(),
+    windowEnd: end.toISOString(),
+    windowStart: start.toISOString()
+  };
+}
+function addAggregate2(map, label, row) {
+  const item = map.get(label) ?? {
+    active: 0,
+    conversations: 0,
+    durationMs: 0,
+    failed: 0,
+    label
+  };
+  item.active += row.active;
+  item.conversations += row.conversations;
+  item.durationMs += row.durationMs;
+  item.failed += row.failed;
+  if (row.tokens !== null) item.tokens = (item.tokens ?? 0) + row.tokens;
+  map.set(label, item);
+}
+function surfaceExpression() {
+  return sql5`CASE
+    WHEN ${juniorConversations.source} IN ('api', 'scheduler', 'slack')
+      THEN ${juniorConversations.source}
+    WHEN ${juniorConversations.conversationId} LIKE 'slack:%' THEN 'slack'
+    WHEN ${juniorConversations.conversationId} LIKE 'scheduler:%' THEN 'scheduler'
+    WHEN ${juniorConversations.conversationId} LIKE 'api:%' THEN 'api'
+    ELSE 'internal'
+  END`;
+}
+function locationLabel2(row) {
+  if (row.surface !== "slack")
+    return surfaceLabel2(row.surface);
+  if (row.destinationVisibility !== "public") return "Private Conversation";
+  return slackLocationLabel({
+    channel: row.channel || void 0,
+    channelName: row.channelName ?? void 0
+  }) ?? "Conversation";
+}
+async function readPeopleProfileFromSql(email) {
+  const nowMs = Date.now();
+  const normalizedEmail = normalizeEmail(email);
+  if (!normalizedEmail) return emptyProfile("", nowMs);
+  const end = new Date(nowMs);
+  end.setUTCHours(0, 0, 0, 0);
+  const start = new Date(end);
+  start.setUTCDate(start.getUTCDate() - (ACTIVITY_DAYS2 - 1));
+  const where = verifiedActorWhere(normalizedEmail);
+  const surface = surfaceExpression();
+  const activityDate = sql5`TO_CHAR(
+    ${juniorConversations.lastActivityAt} AT TIME ZONE 'UTC',
+    'YYYY-MM-DD'
+  )`;
+  const channel = sql5`SPLIT_PART(${juniorConversations.conversationId}, ':', 2)`;
+  const [totalsRows, dayRows, locationRows, surfaceRows, recentRows] = await Promise.all([
+    getDb().select({
+      email: juniorUsers.primaryEmailNormalized,
+      fullName: juniorUsers.displayName,
+      slackUserId: sql5`MAX(${juniorIdentities.providerSubjectId})`,
+      slackUserName: sql5`MAX(${juniorIdentities.handle})`,
+      activeDays: conversationActiveDaysColumn(),
+      ...conversationAggregateColumns()
+    }).from(juniorConversations).innerJoin(
+      juniorIdentities,
+      eq7(juniorIdentities.id, juniorConversations.actorIdentityId)
+    ).innerJoin(juniorUsers, eq7(juniorUsers.id, juniorIdentities.userId)).where(where).groupBy(juniorUsers.primaryEmailNormalized, juniorUsers.displayName),
+    getDb().select({
+      date: activityDate,
+      ...conversationAggregateColumns()
+    }).from(juniorConversations).innerJoin(
+      juniorIdentities,
+      eq7(juniorIdentities.id, juniorConversations.actorIdentityId)
+    ).innerJoin(juniorUsers, eq7(juniorUsers.id, juniorIdentities.userId)).where(and7(where, gte4(juniorConversations.lastActivityAt, start))).groupBy(activityDate),
+    getDb().select({
+      channel,
+      channelName: juniorConversations.channelName,
+      destinationVisibility: juniorDestinations.visibility,
+      surface,
+      ...conversationAggregateColumns()
+    }).from(juniorConversations).innerJoin(
+      juniorIdentities,
+      eq7(juniorIdentities.id, juniorConversations.actorIdentityId)
+    ).innerJoin(juniorUsers, eq7(juniorUsers.id, juniorIdentities.userId)).leftJoin(
+      juniorDestinations,
+      eq7(juniorDestinations.id, juniorConversations.destinationId)
+    ).where(where).groupBy(
+      channel,
+      juniorConversations.channelName,
+      juniorDestinations.visibility,
+      surface
+    ),
+    getDb().select({ surface, ...conversationAggregateColumns() }).from(juniorConversations).innerJoin(
+      juniorIdentities,
+      eq7(juniorIdentities.id, juniorConversations.actorIdentityId)
+    ).innerJoin(juniorUsers, eq7(juniorUsers.id, juniorIdentities.userId)).where(where).groupBy(surface),
+    recentActorRows(normalizedEmail)
+  ]);
+  const totalsRow = totalsRows[0];
+  if (!totalsRow) return emptyProfile(normalizedEmail, nowMs);
+  const actor = {
+    email: totalsRow.email,
+    ...totalsRow.fullName ? { fullName: totalsRow.fullName } : {},
+    ...totalsRow.slackUserId ? { slackUserId: totalsRow.slackUserId } : {},
+    ...totalsRow.slackUserName ? { slackUserName: totalsRow.slackUserName } : {}
+  };
+  const days = /* @__PURE__ */ new Map();
+  for (const row of dayRows) {
+    days.set(row.date, {
+      active: row.active,
+      conversations: row.conversations,
+      date: row.date,
+      durationMs: row.durationMs,
+      failed: row.failed,
+      ...row.tokens !== null ? { tokens: row.tokens } : {}
+    });
+  }
+  const locations = /* @__PURE__ */ new Map();
+  for (const row of locationRows) {
+    addAggregate2(locations, locationLabel2(row), row);
+  }
+  const surfaces = /* @__PURE__ */ new Map();
+  for (const row of surfaceRows) {
+    addAggregate2(
+      surfaces,
+      surfaceLabel2(row.surface),
+      row
+    );
+  }
+  return {
+    activityDays: activityDays2(days, nowMs),
+    generatedAt: new Date(nowMs).toISOString(),
+    locations: statsItems2(locations),
+    recentConversations: recentRows.map(summaryFromRow),
+    actor,
+    source: "conversation_index",
+    surfaces: statsItems2(surfaces),
+    totals: {
+      active: totalsRow.active,
+      activeDays: totalsRow.activeDays,
+      conversations: totalsRow.conversations,
+      durationMs: totalsRow.durationMs,
+      failed: totalsRow.failed,
+      ...totalsRow.tokens !== null ? { tokens: totalsRow.tokens } : {}
+    },
+    windowEnd: end.toISOString(),
+    windowStart: start.toISOString()
+  };
+}
+
+// src/api/people/profile.ts
+async function readPeopleProfile(email) {
+  return actorProfileReportSchema.parse(await readPeopleProfileFromSql(email));
+}
+var profile_default = {
+  method: "get",
+  path: "/:email",
+  handler: async (c) => {
+    const { email } = parseParams(personParamsSchema, c.req.param());
+    return Response.json(await readPeopleProfile(email));
+  }
+};
+
+// 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);
+  return app;
+}
 
 // src/reporting.ts
 import { readFileSync } from "fs";
@@ -72,44 +2243,18 @@ async function readRuntimeInfoReport() {
   });
 }
 async function readPluginOperationalReportFeed() {
-  const listRecent = async (listOptions) => {
-    const { listRecentConversationSummaries } = await import("./plugin-conversations-DTUP4RH6.js");
-    return listRecentConversationSummaries(listOptions?.limit);
-  };
   const nowMs = Date.now();
-  const { getPluginOperationalReports } = await import("./agent-hooks-NHIXBJW3.js");
+  const { getPluginOperationalReports } = await import("./agent-hooks-EOFSY2PD.js");
   return pluginOperationalReportFeedSchema.parse({
     source: "plugins",
     generatedAt: new Date(nowMs).toISOString(),
-    reports: await getPluginOperationalReports(nowMs, {
-      listRecent
-    })
+    reports: await getPluginOperationalReports(nowMs)
   });
 }
 
 // src/api.ts
-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."
-  });
-}
-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."
-  });
-}
 function createJuniorApi() {
-  const app = new Hono();
+  const app = new Hono4();
   app.get("/api/health", async () => {
     return Response.json(await readHealthReport());
   });
@@ -125,58 +2270,9 @@ function createJuniorApi() {
   app.get("/api/plugin-reports", async () => {
     return Response.json(await readPluginOperationalReportFeed());
   });
-  app.get("/api/conversations", async (c) => {
-    const { readConversationFeed } = await import("./list-ZOUSMSEH.js");
-    const { actorEmail } = parseQuery(
-      conversationFeedQuerySchema,
-      c.req.query()
-    );
-    return Response.json(await readConversationFeed({ actorEmail }));
-  });
-  app.get("/api/conversations/stats", async () => {
-    const { readConversationStats } = await import("./stats-NZIET4LT.js");
-    return Response.json(await readConversationStats());
-  });
-  app.get("/api/conversations/:conversationId", async (c) => {
-    const { readConversationDetail } = await import("./detail-ENVV4HIY.js");
-    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 });
-  });
-  app.get(
-    "/api/conversations/:conversationId/subagents/:subagentId",
-    async (c) => {
-      const { readConversationSubagent } = await import("./subagent-DY6XKTJ5.js");
-      const { conversationId, subagentId } = parseParams(
-        subagentParamsSchema,
-        c.req.param()
-      );
-      const report = await readConversationSubagent(conversationId, subagentId);
-      return report.unavailableReason === "not_found" ? Response.json(report, { status: 404 }) : Response.json(report);
-    }
-  );
-  app.get("/api/people", async () => {
-    const { readPeopleList } = await import("./list-XZ4HKQ4R.js");
-    return Response.json(await readPeopleList());
-  });
-  app.get("/api/people/:email", async (c) => {
-    const { email } = parseParams(personParamsSchema, c.req.param());
-    const { readPeopleProfile } = await import("./profile-UO2N3XXG.js");
-    return Response.json(await readPeopleProfile(email));
-  });
-  app.get("/api/locations", async () => {
-    const { readLocationDirectory } = await import("./list-WR5U6JVM.js");
-    return Response.json(await readLocationDirectory());
-  });
-  app.get("/api/locations/:locationId", async (c) => {
-    const { locationId } = parseParams(locationParamsSchema, c.req.param());
-    const { readLocationDetail } = await import("./detail-UIOKVIET.js");
-    const report = await readLocationDetail(locationId);
-    return report ? Response.json(report) : Response.json({ error: "Location not found." }, { status: 404 });
-  });
+  app.route("/api/conversations", createConversationRoutes());
+  app.route("/api/people", createPeopleRoutes());
+  app.route("/api/locations", createLocationRoutes());
   return app;
 }
 export {