@sentry/junior 0.71.3 → 0.73.0

package/dist/reporting.js

@@ -2,73 +2,57 @@ import {
   GET,
   buildSentryConversationUrl,
   buildSentryTraceUrl,
-  buildSystemPrompt,
   formatSlackConversationRedactedLabel,
-  getAgentPluginOperationalReports,
-  getAgentTurnSessionRecord,
   getConversationDetails,
   getConversationDetailsForIds,
-  listAgentTurnSessionSummaries,
-  listAgentTurnSessionSummariesForConversation,
   resolveSlackConversationContextFromThreadId
-} from "./chunk-HOGQL2H6.js";
+} from "./chunk-ZDA2HYX5.js";
+import {
+  buildSystemPrompt,
+  getAgentPluginOperationalReports,
+  getAgentTurnSessionRecord,
+  listAgentTurnSessionSummariesForConversation
+} from "./chunk-UZVHXZ7V.js";
 import {
   discoverSkills
-} from "./chunk-GT67ZWZQ.js";
-import "./chunk-R62YWUNO.js";
+} from "./chunk-OR6NQJ5E.js";
+import {
+  getConversation,
+  listConversationsByActivity
+} from "./chunk-AL5T52ZD.js";
+import "./chunk-V4VYUY4A.js";
+import "./chunk-G3E7SCME.js";
 import {
   getPluginPackageContent,
   getPluginProviders
-} from "./chunk-UXG6TU2U.js";
-import "./chunk-76YMBKW7.js";
+} from "./chunk-7Q5YOUUT.js";
+import {
+  homeDir
+} from "./chunk-KVZL5NZS.js";
+import "./chunk-DIMX5F3T.js";
 import {
   canExposeConversationPayload,
   parseSlackThreadId,
   resolveConversationPrivacy
-} from "./chunk-JS4HURDT.js";
+} from "./chunk-WS2EG3GW.js";
+import "./chunk-CYUI7JU5.js";
 import {
-  homeDir,
   isRecord
-} from "./chunk-BBXYXOJW.js";
-import "./chunk-Z3YD6NHK.js";
+} from "./chunk-3BYAPS6B.js";
+import "./chunk-SJHUF3DP.js";
 import "./chunk-2KG3PWR4.js";
 
 // src/reporting.ts
 import { readFileSync } from "fs";
 import path from "path";
+
+// src/reporting/conversations.ts
 var HUNG_TURN_PROGRESS_MS = 5 * 60 * 1e3;
 var SAFE_METADATA_KEY_LIMIT = 20;
 var PRIVATE_CONVERSATION_LABEL = "Private Conversation";
-var DASHBOARD_SESSION_FEED_LIMIT = 50;
-var DASHBOARD_CONVERSATION_STATS_LIMIT = 5e3;
+var CONVERSATION_FEED_LIMIT = 50;
+var CONVERSATION_STATS_LIMIT = 5e3;
 var RECENT_CONVERSATION_STATS_WINDOW_MS = 7 * 24 * 60 * 60 * 1e3;
-function readDescriptionText() {
-  try {
-    const raw = readFileSync(
-      path.join(homeDir(), "DESCRIPTION.md"),
-      "utf8"
-    ).trim();
-    return raw || void 0;
-  } catch {
-    return void 0;
-  }
-}
-async function readHealth() {
-  const res = GET();
-  return await res.json();
-}
-async function readSkills() {
-  const skills = await discoverSkills();
-  return skills.map((skill) => ({
-    name: skill.name,
-    pluginProvider: skill.pluginProvider
-  }));
-}
-async function readPlugins() {
-  return getPluginProviders().map((plugin) => ({
-    name: plugin.manifest.name
-  }));
-}
 function statusFromCheckpoint(summary, nowMs = Date.now()) {
   const state = summary.state;
   if (state === "running" && nowMs - summary.lastProgressAtMs > HUNG_TURN_PROGRESS_MS) {
@@ -91,6 +75,12 @@ function surfaceFromConversationId(conversationId) {
 function surfaceFromSummary(summary) {
   return summary.surface ?? surfaceFromConversationId(summary.conversationId);
 }
+function surfaceFromSource(source, conversationId) {
+  if (source === "slack" || source === "api" || source === "scheduler") {
+    return source;
+  }
+  return surfaceFromConversationId(conversationId);
+}
 function requesterIdentityReport(requester) {
   if (!requester) return void 0;
   const identity = {
@@ -101,7 +91,7 @@ function requesterIdentityReport(requester) {
   };
   return Object.keys(identity).length > 0 ? identity : void 0;
 }
-function turnUsageReport(usage) {
+function usageReport(usage) {
   if (!usage) return void 0;
   const report = {
     ...usage.inputTokens !== void 0 ? { inputTokens: usage.inputTokens } : {},
@@ -135,7 +125,7 @@ function sessionReportFromSummary(summary, nowMs = Date.now(), details) {
   );
   const sentryTraceUrl = summary.traceId ? buildSentryTraceUrl(summary.traceId) : void 0;
   const requesterIdentity = requesterIdentityReport(effectiveRequester);
-  const cumulativeUsage = turnUsageReport(summary.cumulativeUsage);
+  const cumulativeUsage = usageReport(summary.cumulativeUsage);
   return {
     conversationId: summary.conversationId,
     displayTitle,
@@ -156,6 +146,98 @@ function sessionReportFromSummary(summary, nowMs = Date.now(), details) {
     ...sentryTraceUrl ? { sentryTraceUrl } : {}
   };
 }
+function statusFromConversation(conversation, fallback, nowMs) {
+  if (conversation.execution.status === "idle") {
+    if (fallback === "failed" || fallback === "superseded") {
+      return fallback;
+    }
+    return "completed";
+  }
+  const updatedAtMs = conversation.execution.updatedAtMs ?? conversation.updatedAtMs;
+  if (conversation.execution.status === "running" && nowMs - updatedAtMs > HUNG_TURN_PROGRESS_MS) {
+    return "hung";
+  }
+  return "active";
+}
+function titleFromConversation(args) {
+  const slackThread = parseSlackThreadId(args.conversation.conversationId);
+  const effectiveChannelName = args.details?.channelName ?? args.conversation.channelName;
+  const slackConversation = resolveSlackConversationContextFromThreadId({
+    threadId: args.conversation.conversationId,
+    channelName: effectiveChannelName
+  });
+  const privateLabel = resolveConversationPrivacy({
+    conversationId: args.conversation.conversationId
+  }) !== "public" ? slackConversation ? formatSlackConversationRedactedLabel(slackConversation) : PRIVATE_CONVERSATION_LABEL : void 0;
+  return privateLabel ?? args.details?.displayTitle ?? args.conversation.title ?? slackStatsLocationLabel({
+    channel: slackThread?.channelId,
+    channelName: effectiveChannelName
+  }) ?? surfaceFallbackLabel(args.surface);
+}
+function applyConversationIndexMetadata(args) {
+  const surface = args.details?.originSurface ?? (args.conversation.source ? surfaceFromSource(
+    args.conversation.source,
+    args.conversation.conversationId
+  ) : args.report.surface);
+  const slackThread = parseSlackThreadId(args.conversation.conversationId);
+  const effectiveChannelName = args.details?.channelName ?? args.conversation.channelName ?? args.report.channelName;
+  const requesterIdentity = requesterIdentityReport(args.details?.originRequester) ?? args.report.requesterIdentity ?? requesterIdentityReport(args.conversation.requester);
+  const status = statusFromConversation(
+    args.conversation,
+    args.report.status,
+    args.nowMs
+  );
+  const lastSeenAtMs = Math.max(
+    reportTime(args.report.lastSeenAt) ?? 0,
+    args.conversation.lastActivityAtMs
+  );
+  const lastProgressAtMs = Math.max(
+    reportTime(args.report.lastProgressAt) ?? 0,
+    args.conversation.execution.updatedAtMs ?? args.conversation.updatedAtMs
+  );
+  return {
+    ...args.report,
+    displayTitle: titleFromConversation({
+      conversation: args.conversation,
+      details: args.details,
+      surface
+    }),
+    status,
+    lastSeenAt: new Date(lastSeenAtMs).toISOString(),
+    lastProgressAt: new Date(lastProgressAtMs).toISOString(),
+    surface,
+    ...requesterIdentity ? { requesterIdentity } : {},
+    ...slackThread ? { channel: slackThread.channelId } : {},
+    ...effectiveChannelName ? { channelName: effectiveChannelName } : {}
+  };
+}
+function sessionReportFromConversation(conversation, nowMs, details) {
+  const surface = details?.originSurface ?? surfaceFromSource(conversation.source, conversation.conversationId);
+  const sentryConversationUrl = buildSentryConversationUrl(
+    conversation.conversationId
+  );
+  const requesterIdentity = requesterIdentityReport(
+    details?.originRequester ?? conversation.requester
+  );
+  const slackThread = parseSlackThreadId(conversation.conversationId);
+  return {
+    conversationId: conversation.conversationId,
+    cumulativeDurationMs: 0,
+    displayTitle: titleFromConversation({ conversation, details, surface }),
+    id: conversation.execution.runId ?? conversation.conversationId,
+    lastProgressAt: new Date(
+      conversation.execution.updatedAtMs ?? conversation.updatedAtMs
+    ).toISOString(),
+    lastSeenAt: new Date(conversation.lastActivityAtMs).toISOString(),
+    startedAt: new Date(conversation.createdAtMs).toISOString(),
+    status: statusFromConversation(conversation, void 0, nowMs),
+    surface,
+    ...requesterIdentity ? { requesterIdentity } : {},
+    ...slackThread ? { channel: slackThread.channelId } : {},
+    ...details?.channelName ?? conversation.channelName ? { channelName: details?.channelName ?? conversation.channelName } : {},
+    ...sentryConversationUrl ? { sentryConversationUrl } : {}
+  };
+}
 function reportTime(value) {
   const time = Date.parse(value);
   return Number.isFinite(time) ? time : void 0;
@@ -176,18 +258,18 @@ function usageTokenTotal(usage) {
   }
   return typeof usage.totalTokens === "number" && Number.isFinite(usage.totalTokens) ? Math.max(0, Math.floor(usage.totalTokens)) : void 0;
 }
-function turnDurationSnapshot(turn) {
-  return typeof turn.cumulativeDurationMs === "number" && Number.isFinite(turn.cumulativeDurationMs) ? Math.max(0, Math.floor(turn.cumulativeDurationMs)) : void 0;
+function runDurationSnapshot(run) {
+  return typeof run.cumulativeDurationMs === "number" && Number.isFinite(run.cumulativeDurationMs) ? Math.max(0, Math.floor(run.cumulativeDurationMs)) : void 0;
 }
-function turnContributions(turns) {
+function runContributions(runs) {
   let previousDuration = 0;
   let previousTokens = 0;
-  return turns.map((turn) => {
-    const duration = turnDurationSnapshot(turn);
-    const tokens = usageTokenTotal(turn.cumulativeUsage);
+  return runs.map((run) => {
+    const duration = runDurationSnapshot(run);
+    const tokens = usageTokenTotal(run.cumulativeUsage);
     const contribution = {
       durationMs: duration === void 0 ? 0 : Math.max(0, duration - previousDuration),
-      turn
+      run
     };
     if (tokens !== void 0) {
       contribution.tokens = Math.max(0, tokens - previousTokens);
@@ -257,8 +339,8 @@ function displayTitleFromDetails(conversationId, details) {
     channelName: details.channelName
   }) ?? (details.originSurface ? surfaceFallbackLabel(details.originSurface) : void 0);
 }
-function locationLabel(turn) {
-  return slackStatsLocationLabel(turn) ?? surfaceFallbackLabel(turn.surface);
+function locationLabel(run) {
+  return slackStatsLocationLabel(run) ?? surfaceFallbackLabel(run.surface);
 }
 function emptyStatsItem(label) {
   return {
@@ -268,7 +350,7 @@ function emptyStatsItem(label) {
     failed: 0,
     hung: 0,
     label,
-    turns: 0
+    runs: 0
   };
 }
 function addItemTokens(item, tokens) {
@@ -276,20 +358,20 @@ function addItemTokens(item, tokens) {
     item.tokens = (item.tokens ?? 0) + tokens;
   }
 }
-function statusSignals(turns) {
+function statusSignals(runs) {
   return {
-    active: turns.some((turn) => turn.status === "active"),
-    failed: turns.some((turn) => turn.status === "failed"),
-    hung: turns.some((turn) => turn.status === "hung")
+    active: runs.some((run) => run.status === "active"),
+    failed: runs.some((run) => run.status === "failed"),
+    hung: runs.some((run) => run.status === "hung")
   };
 }
 function statsItems(map) {
   return [...map.values()].sort(
-    (left, right) => right.conversations - left.conversations || right.turns - left.turns || right.durationMs - left.durationMs || left.label.localeCompare(right.label)
+    (left, right) => right.conversations - left.conversations || right.runs - left.runs || right.durationMs - left.durationMs || left.label.localeCompare(right.label)
   );
 }
-function newestTurn(turns) {
-  return [...turns].sort(
+function newestRun(runs) {
+  return [...runs].sort(
     (left, right) => (reportTime(right.lastSeenAt) ?? 0) - (reportTime(left.lastSeenAt) ?? 0) || right.id.localeCompare(left.id)
   )[0];
 }
@@ -303,19 +385,19 @@ function recentConversationGroups(args) {
     ]);
   }
   return [...groups.values()].map(
-    (turns) => [...turns].sort(
+    (runs) => [...runs].sort(
       (left, right) => (reportTime(left.startedAt) ?? 0) - (reportTime(right.startedAt) ?? 0) || left.id.localeCompare(right.id)
     )
-  ).filter((turns) => {
-    const activityAt = reportTime(newestTurn(turns).lastSeenAt);
+  ).filter((runs) => {
+    const activityAt = reportTime(newestRun(runs).lastSeenAt);
     return activityAt !== void 0 && activityAt >= startMs && activityAt <= args.nowMs;
   });
 }
-function conversationDurationMs(turns) {
-  if (!turns.some((turn) => turnDurationSnapshot(turn) !== void 0)) {
+function conversationDurationMs(runs) {
+  if (!runs.some((run) => runDurationSnapshot(run) !== void 0)) {
     return 0;
   }
-  return contributionDurationTotal(turnContributions(turns));
+  return contributionDurationTotal(runContributions(runs));
 }
 function buildConversationStatsReport(args) {
   const conversations = recentConversationGroups(args);
@@ -326,30 +408,30 @@ function buildConversationStatsReport(args) {
   let active = 0;
   let failed = 0;
   let hung = 0;
-  for (const turns of conversations) {
-    const contributions = turnContributions(turns);
-    const conversationSignals = statusSignals(turns);
+  for (const runs of conversations) {
+    const contributions = runContributions(runs);
+    const conversationSignals = statusSignals(runs);
     const conversationTokens = contributionTokenTotal(contributions);
     durationMs += contributionDurationTotal(contributions);
     tokens = addTokenTotal(tokens, conversationTokens);
     active += conversationSignals.active ? 1 : 0;
     failed += conversationSignals.failed ? 1 : 0;
     hung += conversationSignals.hung ? 1 : 0;
-    const requesterTurns = /* @__PURE__ */ new Map();
+    const requesterRuns = /* @__PURE__ */ new Map();
     for (const contribution of contributions) {
-      const requester = requesterLabel(contribution.turn.requesterIdentity) ?? "Unknown";
-      requesterTurns.set(requester, [
-        ...requesterTurns.get(requester) ?? [],
+      const requester = requesterLabel(contribution.run.requesterIdentity) ?? "Unknown";
+      requesterRuns.set(requester, [
+        ...requesterRuns.get(requester) ?? [],
         contribution
       ]);
     }
-    for (const [requester, requesterContributions] of requesterTurns) {
+    for (const [requester, requesterContributions] of requesterRuns) {
       const item = requesters.get(requester) ?? emptyStatsItem(requester);
       const signals = statusSignals(
-        requesterContributions.map((contribution) => contribution.turn)
+        requesterContributions.map((contribution) => contribution.run)
       );
       item.conversations += 1;
-      item.turns += requesterContributions.length;
+      item.runs += requesterContributions.length;
       item.durationMs += contributionDurationTotal(requesterContributions);
       item.active += signals.active ? 1 : 0;
       item.failed += signals.failed ? 1 : 0;
@@ -357,11 +439,11 @@ function buildConversationStatsReport(args) {
       addItemTokens(item, contributionTokenTotal(requesterContributions));
       requesters.set(requester, item);
     }
-    const location = locationLabel(newestTurn(turns));
+    const location = locationLabel(newestRun(runs));
     const locationItem = locations.get(location) ?? emptyStatsItem(location);
     locationItem.conversations += 1;
-    locationItem.turns += turns.length;
-    locationItem.durationMs += conversationDurationMs(turns);
+    locationItem.runs += runs.length;
+    locationItem.durationMs += conversationDurationMs(runs);
     locationItem.active += conversationSignals.active ? 1 : 0;
     locationItem.failed += conversationSignals.failed ? 1 : 0;
     locationItem.hung += conversationSignals.hung ? 1 : 0;
@@ -379,41 +461,16 @@ function buildConversationStatsReport(args) {
     requesters: statsItems(requesters),
     sampleLimit: args.sampleLimit,
     sampleSize: args.sampleSize,
-    source: "turn_session_records",
+    source: "conversation_index",
     ...tokens !== void 0 ? { tokens } : {},
     truncated: args.truncated,
-    turns: conversations.reduce((sum, turns) => sum + turns.length, 0),
+    runs: conversations.reduce((sum, runs) => sum + runs.length, 0),
     windowEnd: new Date(args.nowMs).toISOString(),
     windowStart: new Date(
       args.nowMs - RECENT_CONVERSATION_STATS_WINDOW_MS
     ).toISOString()
   };
 }
-async function completeSampledConversationSummaries(args) {
-  if (!args.truncated) {
-    return args.summaries;
-  }
-  const conversationIds = [
-    ...new Set(args.summaries.map((summary) => summary.conversationId))
-  ];
-  const groups = await Promise.all(
-    conversationIds.map(
-      (conversationId) => listAgentTurnSessionSummariesForConversation(conversationId)
-    )
-  );
-  const summariesByTurn = /* @__PURE__ */ new Map();
-  for (const group of groups) {
-    for (const summary of group) {
-      summariesByTurn.set(
-        `${summary.conversationId}:${summary.sessionId}`,
-        summary
-      );
-    }
-  }
-  return [...summariesByTurn.values()].sort(
-    (left, right) => right.updatedAtMs - left.updatedAtMs
-  );
-}
 function canExposeConversationTranscript(summary) {
   return canExposeConversationPayload({
     conversationId: summary.conversationId
@@ -600,13 +657,19 @@ function isConversationMessage(message) {
 function countConversationMessages(transcript) {
   return transcript.filter(isConversationMessage).length;
 }
-function systemPromptMessage() {
+function systemPromptMessage(destination) {
   return {
     role: "system",
-    parts: [{ type: "text", text: buildSystemPrompt() }]
+    parts: [{ type: "text", text: buildSystemPrompt({ source: destination }) }]
   };
 }
-function turnScopedMessages(messages) {
+function turnScopedMessages(messages, turnStartMessageIndex) {
+  if (turnStartMessageIndex !== void 0 && turnStartMessageIndex >= 0 && turnStartMessageIndex < messages.length) {
+    return {
+      messages: messages.slice(turnStartMessageIndex),
+      startsAtRunBoundary: turnStartMessageIndex === 0
+    };
+  }
   for (let index = messages.length - 1; index >= 0; index -= 1) {
     const record = messages[index];
     if (record.role === "user") {
@@ -635,96 +698,134 @@ function traceIdFromTranscript(transcript) {
   }
   return void 0;
 }
-async function readSessions() {
-  const nowMs = Date.now();
-  const summaries = await listAgentTurnSessionSummaries(
-    DASHBOARD_SESSION_FEED_LIMIT
+async function summariesByConversation(conversations) {
+  const entries = await Promise.all(
+    conversations.map(async (conversation) => {
+      const summaries = await listAgentTurnSessionSummariesForConversation(
+        conversation.conversationId
+      );
+      return [conversation.conversationId, summaries];
+    })
   );
+  return new Map(entries);
+}
+async function reportsFromConversations(args) {
+  const summaries = await summariesByConversation(args.conversations);
+  const reports = /* @__PURE__ */ new Map();
+  for (const conversation of args.conversations) {
+    const details = args.detailsByConversationId.get(
+      conversation.conversationId
+    );
+    const conversationSummaries = summaries.get(conversation.conversationId) ?? [];
+    const conversationReports = conversationSummaries.length > 0 ? conversationSummaries.map(
+      (summary) => applyConversationIndexMetadata({
+        conversation,
+        details,
+        nowMs: args.nowMs,
+        report: sessionReportFromSummary(summary, args.nowMs, details)
+      })
+    ) : [sessionReportFromConversation(conversation, args.nowMs, details)];
+    reports.set(conversation.conversationId, conversationReports);
+  }
+  return reports;
+}
+async function readConversationFeed() {
+  const nowMs = Date.now();
+  const conversations = await listConversationsByActivity({
+    limit: CONVERSATION_FEED_LIMIT
+  });
   const detailsByConversationId = await getConversationDetailsForIds(
-    summaries.map((s) => s.conversationId)
+    conversations.map((conversation) => conversation.conversationId)
   );
+  const reportsByConversation = await reportsFromConversations({
+    conversations,
+    detailsByConversationId,
+    nowMs
+  });
   return {
-    source: "turn_session_records",
+    source: "conversation_index",
     generatedAt: new Date(nowMs).toISOString(),
-    sessions: summaries.map(
-      (summary) => sessionReportFromSummary(
-        summary,
-        nowMs,
-        detailsByConversationId.get(summary.conversationId)
+    sessions: conversations.map(
+      (conversation) => newestRun(
+        reportsByConversation.get(conversation.conversationId) ?? [
+          sessionReportFromConversation(
+            conversation,
+            nowMs,
+            detailsByConversationId.get(conversation.conversationId)
+          )
+        ]
       )
     )
   };
 }
-async function readConversationStats() {
+async function readConversationStatsReport() {
   const nowMs = Date.now();
   const generatedAt = new Date(nowMs).toISOString();
-  const summaries = await listAgentTurnSessionSummaries(
-    DASHBOARD_CONVERSATION_STATS_LIMIT + 1
-  );
-  const truncated = summaries.length >= DASHBOARD_CONVERSATION_STATS_LIMIT;
-  const sampledSummaries = summaries.slice(
-    0,
-    DASHBOARD_CONVERSATION_STATS_LIMIT
-  );
-  const reportSummaries = await completeSampledConversationSummaries({
-    summaries: sampledSummaries,
-    truncated
+  const conversations = await listConversationsByActivity({
+    limit: CONVERSATION_STATS_LIMIT + 1
   });
+  const truncated = conversations.length > CONVERSATION_STATS_LIMIT;
+  const sampledConversations = conversations.slice(0, CONVERSATION_STATS_LIMIT);
   const detailsByConversationId = await getConversationDetailsForIds(
-    reportSummaries.map((summary) => summary.conversationId)
+    sampledConversations.map((conversation) => conversation.conversationId)
+  );
+  const reportsByConversation = await reportsFromConversations({
+    conversations: sampledConversations,
+    detailsByConversationId,
+    nowMs
+  });
+  const sessions = sampledConversations.flatMap(
+    (conversation) => reportsByConversation.get(conversation.conversationId) ?? [
+      sessionReportFromConversation(
+        conversation,
+        nowMs,
+        detailsByConversationId.get(conversation.conversationId)
+      )
+    ]
   );
   return buildConversationStatsReport({
     generatedAt,
     nowMs,
-    sampleLimit: DASHBOARD_CONVERSATION_STATS_LIMIT,
-    sampleSize: sampledSummaries.length,
-    sessions: reportSummaries.map(
-      (summary) => sessionReportFromSummary(
-        summary,
-        nowMs,
-        detailsByConversationId.get(summary.conversationId)
-      )
-    ),
+    sampleLimit: CONVERSATION_STATS_LIMIT,
+    sampleSize: sampledConversations.length,
+    sessions,
     truncated
   });
 }
-async function readPluginOperationalReports() {
+async function readConversationReport(conversationId) {
   const nowMs = Date.now();
-  return {
-    source: "plugins",
-    generatedAt: new Date(nowMs).toISOString(),
-    reports: await getAgentPluginOperationalReports(nowMs)
-  };
-}
-async function readConversation(conversationId) {
-  const [rawSummaries, details] = await Promise.all([
+  const [rawSummaries, details, conversation] = await Promise.all([
     listAgentTurnSessionSummariesForConversation(conversationId),
-    getConversationDetails(conversationId)
+    getConversationDetails(conversationId),
+    getConversation({ conversationId })
   ]);
   const summaries = rawSummaries.sort(
     (left, right) => left.startedAtMs - right.startedAtMs || left.updatedAtMs - right.updatedAtMs || left.sessionId.localeCompare(right.sessionId)
   );
-  const turns = await Promise.all(
+  const runs = await Promise.all(
     summaries.map(async (summary) => {
       const sessionRecord = await getAgentTurnSessionRecord(
         summary.conversationId,
         summary.sessionId
       );
-      const scopedMessages = sessionRecord?.piMessages ? turnScopedMessages(sessionRecord.piMessages) : { messages: [], startsAtRunBoundary: false };
+      const scopedMessages = sessionRecord?.piMessages ? turnScopedMessages(
+        sessionRecord.piMessages,
+        sessionRecord.turnStartMessageIndex
+      ) : { messages: [], startsAtRunBoundary: false };
       const canExposeTranscript = canExposeConversationTranscript(summary);
       const normalizedTranscript = scopedMessages.messages.map(
         normalizeTranscriptMessage
       );
       const transcriptMessageCount = countConversationMessages(normalizedTranscript);
       const transcript = canExposeTranscript ? [
-        ...scopedMessages.startsAtRunBoundary && normalizedTranscript.length > 0 ? [systemPromptMessage()] : [],
+        ...scopedMessages.startsAtRunBoundary && normalizedTranscript.length > 0 && sessionRecord?.destination ? [systemPromptMessage(sessionRecord.destination)] : [],
         ...normalizedTranscript
       ] : [];
       const transcriptMetadata = canExposeTranscript ? void 0 : normalizedTranscript.map(redactTranscriptMessage);
       const traceId = summary.traceId ?? sessionRecord?.traceId ?? (canExposeTranscript ? traceIdFromTranscript(transcript) : void 0);
       const sentryTraceUrl = traceId ? buildSentryTraceUrl(traceId) : void 0;
-      return {
-        ...sessionReportFromSummary(summary, Date.now(), details),
+      const report = {
+        ...sessionReportFromSummary(summary, nowMs, details),
         ...traceId ? { traceId } : {},
         ...sentryTraceUrl ? { sentryTraceUrl } : {},
         transcriptAvailable: Boolean(sessionRecord) && canExposeTranscript,
@@ -736,15 +837,68 @@ async function readConversation(conversationId) {
         } : {},
         transcript
       };
+      return conversation ? {
+        ...report,
+        ...applyConversationIndexMetadata({
+          conversation,
+          details,
+          nowMs,
+          report
+        })
+      } : report;
     })
   );
-  const firstTurn = turns[0];
-  const displayTitle = firstTurn?.displayTitle ?? displayTitleFromDetails(conversationId, details) ?? surfaceFallbackLabel(firstTurn?.surface ?? "slack");
+  const effectiveRuns = runs.length > 0 || !conversation ? runs : [
+    {
+      ...sessionReportFromConversation(conversation, nowMs, details),
+      transcriptAvailable: false,
+      transcript: []
+    }
+  ];
+  const firstRun = effectiveRuns[0];
+  const displayTitle = firstRun?.displayTitle ?? displayTitleFromDetails(conversationId, details) ?? surfaceFallbackLabel(firstRun?.surface ?? "slack");
   return {
     conversationId,
     displayTitle,
-    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    turns
+    generatedAt: new Date(nowMs).toISOString(),
+    runs: effectiveRuns
+  };
+}
+
+// src/reporting.ts
+function readDescriptionText() {
+  try {
+    const raw = readFileSync(
+      path.join(homeDir(), "DESCRIPTION.md"),
+      "utf8"
+    ).trim();
+    return raw || void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function readHealth() {
+  const res = GET();
+  return await res.json();
+}
+async function readSkills() {
+  const skills = await discoverSkills();
+  return skills.map((skill) => ({
+    name: skill.name,
+    pluginProvider: skill.pluginProvider
+  }));
+}
+async function readPlugins() {
+  return getPluginProviders().map((plugin) => ({
+    name: plugin.manifest.name
+  }));
+}
+async function readPluginOperationalReports() {
+  const nowMs = Date.now();
+  return {
+    source: "plugins",
+    generatedAt: new Date(nowMs).toISOString(),
+    reports: await getAgentPluginOperationalReports(nowMs)
   };
 }
 function createJuniorReporting() {
@@ -766,10 +920,10 @@ function createJuniorReporting() {
     },
     getPlugins: readPlugins,
     getSkills: readSkills,
-    getSessions: readSessions,
-    getConversationStats: readConversationStats,
+    getSessions: readConversationFeed,
+    getConversationStats: readConversationStatsReport,
     getPluginOperationalReports: readPluginOperationalReports,
-    getConversation: readConversation
+    getConversation: readConversationReport
   };
 }
 export {