@sentry/junior 0.98.0 → 0.100.0

package/dist/chunk-QSBQJ3PA.js

@@ -0,0 +1,275 @@
+import {
+  summaryFromRow
+} from "./chunk-QOZOJNSE.js";
+import {
+  conversationAggregateColumns,
+  conversationRangeColumns
+} from "./chunk-PGGEOCQY.js";
+import {
+  activityDays
+} from "./chunk-4AQUWWEM.js";
+import {
+  getDb,
+  juniorConversations,
+  juniorIdentities,
+  juniorUsers
+} from "./chunk-VHRM6GNH.js";
+import {
+  juniorDestinations
+} from "./chunk-FXFQNHRU.js";
+
+// src/api/locations/query.ts
+import { and, asc, desc, eq, gte, isNull, sql } from "drizzle-orm";
+var RECENT_LIMIT = 25;
+var ACTIVITY_DAYS = 30;
+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 actorLabel(actor) {
+  return actor.email?.trim() || actor.fullName?.trim() || actor.slackUserName?.trim() || actor.slackUserId?.trim() || "Unknown";
+}
+function emptyActor(actor) {
+  return {
+    ...emptyMetrics(),
+    actor,
+    label: actorLabel(actor)
+  };
+}
+function topLevelWhere() {
+  return isNull(juniorConversations.parentConversationId);
+}
+function publicLocationWhere(destinationId) {
+  return and(
+    topLevelWhere(),
+    eq(juniorDestinations.id, destinationId),
+    eq(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,
+    eq(juniorDestinations.id, juniorConversations.destinationId)
+  ).where(topLevelWhere()).groupBy(...locationGroupBy());
+}
+async function readLocationDirectoryFromSql() {
+  const nowMs = Date.now();
+  const rows = await directoryRows(getDb());
+  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 {
+    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"
+  };
+}
+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: sql`COALESCE(
+        ${juniorUsers.primaryEmailNormalized},
+        ${juniorIdentities.email}
+      )`,
+    executionStatus: juniorConversations.executionStatus,
+    executionUpdatedAt: juniorConversations.executionUpdatedAt,
+    fullName: juniorUsers.displayName,
+    handle: juniorIdentities.handle,
+    lastActivityAt: juniorConversations.lastActivityAt,
+    providerSubjectId: sql`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,
+    eq(juniorDestinations.id, juniorConversations.destinationId)
+  ).leftJoin(
+    juniorIdentities,
+    eq(juniorIdentities.id, juniorConversations.actorIdentityId)
+  ).leftJoin(juniorUsers, eq(juniorUsers.id, juniorIdentities.userId)).where(publicLocationWhere(locationId)).orderBy(
+    desc(juniorConversations.lastActivityAt),
+    asc(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 = sql`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,
+      eq(juniorDestinations.id, juniorConversations.destinationId)
+    ).where(where).groupBy(...locationGroupBy()),
+    getDb().select({ date: activityDate, ...conversationAggregateColumns() }).from(juniorConversations).innerJoin(
+      juniorDestinations,
+      eq(juniorDestinations.id, juniorConversations.destinationId)
+    ).where(and(where, gte(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,
+      eq(juniorDestinations.id, juniorConversations.destinationId)
+    ).leftJoin(
+      juniorIdentities,
+      eq(juniorIdentities.id, juniorConversations.actorIdentityId)
+    ).leftJoin(juniorUsers, eq(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()
+  };
+}
+
+export {
+  readLocationDirectoryFromSql,
+  readLocationDetailFromSql
+};

package/dist/{chunk-FTTFV6DC.js → chunk-TPTJEHUE.js}

@@ -3,14 +3,14 @@ import {
   isConversationScopedChannel,
   isDmChannel,
   normalizeSlackConversationId
-} from "./chunk-WTYEKPXU.js";
+} from "./chunk-FP5N5OWZ.js";
 import {
   createPluginLogger,
   createPluginState
-} from "./chunk-EOWXRY5E.js";
+} from "./chunk-PWC24W5F.js";
 import {
   getDb
-} from "./chunk-OGHXZ4KQ.js";
+} from "./chunk-VHRM6GNH.js";
 import {
   SANDBOX_WORKSPACE_ROOT
 } from "./chunk-G3E7SCME.js";
@@ -18,7 +18,7 @@ import {
   botConfig,
   completeObject,
   embedTexts
-} from "./chunk-EEZCY5WX.js";
+} from "./chunk-A7X2FDUO.js";
 import {
   isActorUserId,
   logInfo,

package/dist/{chunk-OGHXZ4KQ.js → chunk-VHRM6GNH.js}

@@ -3,7 +3,11 @@ import {
   getConnectedStateContext,
   getStateAdapter,
   modelProfileSchema
-} from "./chunk-EEZCY5WX.js";
+} from "./chunk-A7X2FDUO.js";
+import {
+  juniorDestinations,
+  timestamptz
+} from "./chunk-FXFQNHRU.js";
 import {
   parseDestination,
   sameDestination
@@ -23,211 +27,176 @@ import { and, eq, sql as sql4 } from "drizzle-orm";
 
 // src/db/schema/agent-steps.ts
 import {
-  index as index4,
+  index as index3,
   integer as integer2,
-  jsonb as jsonb4,
-  pgTable as pgTable5,
+  jsonb as jsonb3,
+  pgTable as pgTable4,
   primaryKey,
-  text as text5
+  text as text4
 } from "drizzle-orm/pg-core";
 
 // src/db/schema/conversations.ts
 import { sql as sql2 } from "drizzle-orm";
 import {
-  index as index3,
+  index as index2,
   integer,
-  jsonb as jsonb3,
-  pgTable as pgTable4,
-  text as text4
+  jsonb as jsonb2,
+  pgTable as pgTable3,
+  text as text3
 } from "drizzle-orm/pg-core";
 
-// src/db/schema/destinations.ts
-import { index, jsonb, pgTable, text, uniqueIndex } from "drizzle-orm/pg-core";
-
-// src/db/schema/timestamps.ts
-import { timestamp } from "drizzle-orm/pg-core";
-var timestamptz = (name) => timestamp(name, { withTimezone: true });
-
-// src/db/schema/destinations.ts
-var juniorDestinations = pgTable(
-  "junior_destinations",
-  {
-    id: text("id").primaryKey(),
-    provider: text("provider").notNull(),
-    providerTenantId: text("provider_tenant_id").notNull().default(""),
-    providerDestinationId: text("provider_destination_id").notNull(),
-    kind: text("kind").$type().notNull(),
-    parentDestinationId: text("parent_destination_id"),
-    displayName: text("display_name"),
-    visibility: text("visibility").$type().notNull().default("unknown"),
-    metadata: jsonb("metadata_json"),
-    createdAt: timestamptz("created_at").notNull(),
-    updatedAt: timestamptz("updated_at").notNull()
-  },
-  (table) => [
-    uniqueIndex("junior_destinations_provider_destination_uidx").on(
-      table.provider,
-      table.providerTenantId,
-      table.providerDestinationId
-    ),
-    index("junior_destinations_provider_kind_idx").on(
-      table.provider,
-      table.kind
-    )
-  ]
-);
-
 // src/db/schema/identities.ts
 import { sql } from "drizzle-orm";
 import {
   boolean,
-  index as index2,
-  jsonb as jsonb2,
-  pgTable as pgTable3,
-  text as text3,
-  uniqueIndex as uniqueIndex3
+  index,
+  jsonb,
+  pgTable as pgTable2,
+  text as text2,
+  uniqueIndex as uniqueIndex2
 } from "drizzle-orm/pg-core";
 
 // src/db/schema/users.ts
-import { text as text2, pgTable as pgTable2, uniqueIndex as uniqueIndex2 } from "drizzle-orm/pg-core";
-var juniorUsers = pgTable2(
+import { text, pgTable, uniqueIndex } from "drizzle-orm/pg-core";
+var juniorUsers = pgTable(
   "junior_users",
   {
-    id: text2("id").primaryKey(),
-    primaryEmail: text2("primary_email").notNull(),
-    primaryEmailNormalized: text2("primary_email_normalized").notNull(),
-    displayName: text2("display_name"),
+    id: text("id").primaryKey(),
+    primaryEmail: text("primary_email").notNull(),
+    primaryEmailNormalized: text("primary_email_normalized").notNull(),
+    displayName: text("display_name"),
     createdAt: timestamptz("created_at").notNull(),
     updatedAt: timestamptz("updated_at").notNull()
   },
   (table) => [
-    uniqueIndex2("junior_users_primary_email_normalized_uidx").on(
+    uniqueIndex("junior_users_primary_email_normalized_uidx").on(
       table.primaryEmailNormalized
     )
   ]
 );
 
 // src/db/schema/identities.ts
-var juniorIdentities = pgTable3(
+var juniorIdentities = pgTable2(
   "junior_identities",
   {
-    id: text3("id").primaryKey(),
-    kind: text3("kind").$type().notNull(),
-    provider: text3("provider").notNull(),
-    providerTenantId: text3("provider_tenant_id").notNull().default(""),
-    providerSubjectId: text3("provider_subject_id").notNull(),
-    displayName: text3("display_name"),
-    handle: text3("handle"),
-    email: text3("email"),
-    avatarUrl: text3("avatar_url"),
-    metadata: jsonb2("metadata_json"),
+    id: text2("id").primaryKey(),
+    kind: text2("kind").$type().notNull(),
+    provider: text2("provider").notNull(),
+    providerTenantId: text2("provider_tenant_id").notNull().default(""),
+    providerSubjectId: text2("provider_subject_id").notNull(),
+    displayName: text2("display_name"),
+    handle: text2("handle"),
+    email: text2("email"),
+    avatarUrl: text2("avatar_url"),
+    metadata: jsonb("metadata_json"),
     createdAt: timestamptz("created_at").notNull(),
     updatedAt: timestamptz("updated_at").notNull(),
-    userId: text3("user_id").references(() => juniorUsers.id),
-    emailNormalized: text3("email_normalized"),
+    userId: text2("user_id").references(() => juniorUsers.id),
+    emailNormalized: text2("email_normalized"),
     emailVerified: boolean("email_verified").notNull().default(false)
   },
   (table) => [
-    uniqueIndex3("junior_identities_provider_subject_uidx").on(
+    uniqueIndex2("junior_identities_provider_subject_uidx").on(
       table.provider,
       table.providerTenantId,
       table.providerSubjectId
     ),
-    index2("junior_identities_user_idx").on(table.userId),
-    index2("junior_identities_verified_email_idx").on(table.emailNormalized).where(
+    index("junior_identities_user_idx").on(table.userId),
+    index("junior_identities_verified_email_idx").on(table.emailNormalized).where(
       sql`${table.emailVerified} = true AND ${table.emailNormalized} IS NOT NULL`
     ),
-    index2("junior_identities_kind_provider_idx").on(table.kind, table.provider)
+    index("junior_identities_kind_provider_idx").on(table.kind, table.provider)
   ]
 );
 
 // src/db/schema/conversations.ts
-var juniorConversations = pgTable4(
+var juniorConversations = pgTable3(
   "junior_conversations",
   {
-    conversationId: text4("conversation_id").primaryKey(),
+    conversationId: text3("conversation_id").primaryKey(),
     schemaVersion: integer("schema_version").notNull().default(1),
-    source: text4("source").$type(),
-    originType: text4("origin_type"),
-    originId: text4("origin_id"),
-    originRunId: text4("origin_run_id"),
-    destinationId: text4("destination_id").references(
+    source: text3("source").$type(),
+    originType: text3("origin_type"),
+    originId: text3("origin_id"),
+    originRunId: text3("origin_run_id"),
+    destinationId: text3("destination_id").references(
       () => juniorDestinations.id
     ),
-    destination: jsonb3("destination_json").$type(),
-    actorIdentityId: text4("actor_identity_id").references(
+    destination: jsonb2("destination_json").$type(),
+    actorIdentityId: text3("actor_identity_id").references(
       () => juniorIdentities.id
     ),
-    creatorIdentityId: text4("creator_identity_id").references(
+    creatorIdentityId: text3("creator_identity_id").references(
       () => juniorIdentities.id
     ),
-    credentialSubjectIdentityId: text4(
+    credentialSubjectIdentityId: text3(
       "credential_subject_identity_id"
     ).references(() => juniorIdentities.id),
-    actor: jsonb3("actor_json").$type(),
-    channelName: text4("channel_name"),
-    title: text4("title"),
+    actor: jsonb2("actor_json").$type(),
+    channelName: text3("channel_name"),
+    title: text3("title"),
     createdAt: timestamptz("created_at").notNull(),
     lastActivityAt: timestamptz("last_activity_at").notNull(),
     updatedAt: timestamptz("updated_at").notNull(),
     executionUpdatedAt: timestamptz("execution_updated_at"),
-    executionStatus: text4("execution_status").$type().notNull(),
-    runId: text4("run_id"),
+    executionStatus: text3("execution_status").$type().notNull(),
+    runId: text3("run_id"),
     lastCheckpointAt: timestamptz("last_checkpoint_at"),
     lastEnqueuedAt: timestamptz("last_enqueued_at"),
     // Subagent runs are child conversations; top-level listings filter
     // parent_conversation_id IS NULL. Historical advisor children use this too.
-    parentConversationId: text4("parent_conversation_id").references(
+    parentConversationId: text3("parent_conversation_id").references(
       () => juniorConversations.conversationId
     ),
     transcriptPurgedAt: timestamptz("transcript_purged_at"),
     durationMs: integer("duration_ms").notNull().default(0),
-    usage: jsonb3("usage_json").$type(),
+    usage: jsonb2("usage_json").$type(),
     executionDurationMs: integer("execution_duration_ms").notNull().default(0),
-    executionUsage: jsonb3("execution_usage_json").$type()
+    executionUsage: jsonb2("execution_usage_json").$type(),
+    metricRunId: text3("metric_run_id")
   },
   (table) => [
-    index3("junior_conversations_last_activity_idx").on(
+    index2("junior_conversations_last_activity_idx").on(
       table.lastActivityAt.desc(),
       table.conversationId
     ),
-    index3("junior_conversations_active_idx").using(
+    index2("junior_conversations_active_idx").using(
       "btree",
       sql2`coalesce(${table.executionUpdatedAt}, ${table.updatedAt})`,
       table.conversationId
     ).where(sql2`${table.executionStatus} <> 'idle'`),
-    index3("junior_conversations_destination_activity_idx").on(
+    index2("junior_conversations_destination_activity_idx").on(
       table.destinationId,
       table.lastActivityAt.desc()
     ),
-    index3("junior_conversations_actor_activity_idx").on(
+    index2("junior_conversations_actor_activity_idx").on(
       table.actorIdentityId,
       table.lastActivityAt.desc()
     ),
-    index3("junior_conversations_origin_idx").on(
+    index2("junior_conversations_origin_idx").on(
       table.originType,
       table.originId,
       table.lastActivityAt.desc()
     ),
-    index3("junior_conversations_parent_idx").on(table.parentConversationId)
+    index2("junior_conversations_parent_idx").on(table.parentConversationId)
   ]
 );
 
 // src/db/schema/agent-steps.ts
-var juniorAgentSteps = pgTable5(
+var juniorAgentSteps = pgTable4(
   "junior_agent_steps",
   {
-    conversationId: text5("conversation_id").notNull().references(() => juniorConversations.conversationId),
+    conversationId: text4("conversation_id").notNull().references(() => juniorConversations.conversationId),
     seq: integer2("seq").notNull(),
     contextEpoch: integer2("context_epoch").notNull(),
-    type: text5("type").notNull(),
-    role: text5("role"),
-    payload: jsonb4("payload").$type().notNull(),
+    type: text4("type").notNull(),
+    role: text4("role"),
+    payload: jsonb3("payload").$type().notNull(),
     createdAt: timestamptz("created_at").notNull()
   },
   (table) => [
     primaryKey({ columns: [table.conversationId, table.seq] }),
-    index4("junior_agent_steps_epoch_idx").on(
+    index3("junior_agent_steps_epoch_idx").on(
       table.conversationId,
       table.contextEpoch,
       table.seq
@@ -237,28 +206,28 @@ var juniorAgentSteps = pgTable5(
 
 // src/db/schema/conversation-messages.ts
 import { sql as sql3 } from "drizzle-orm";
-import { index as index5, jsonb as jsonb5, pgTable as pgTable6, primaryKey as primaryKey2, text as text6 } from "drizzle-orm/pg-core";
-var juniorConversationMessages = pgTable6(
+import { index as index4, jsonb as jsonb4, pgTable as pgTable5, primaryKey as primaryKey2, text as text5 } from "drizzle-orm/pg-core";
+var juniorConversationMessages = pgTable5(
   "junior_conversation_messages",
   {
-    conversationId: text6("conversation_id").notNull().references(() => juniorConversations.conversationId),
-    messageId: text6("message_id").notNull(),
-    role: text6("role").$type().notNull(),
-    authorIdentityId: text6("author_identity_id").references(
+    conversationId: text5("conversation_id").notNull().references(() => juniorConversations.conversationId),
+    messageId: text5("message_id").notNull(),
+    role: text5("role").$type().notNull(),
+    authorIdentityId: text5("author_identity_id").references(
       () => juniorIdentities.id
     ),
-    text: text6("text").notNull(),
-    meta: jsonb5("meta").$type(),
+    text: text5("text").notNull(),
+    meta: jsonb4("meta").$type(),
     repliedAt: timestamptz("replied_at"),
     createdAt: timestamptz("created_at").notNull()
   },
   (table) => [
     primaryKey2({ columns: [table.conversationId, table.messageId] }),
-    index5("junior_conversation_messages_activity_idx").on(
+    index4("junior_conversation_messages_activity_idx").on(
       table.conversationId,
       table.createdAt
     ),
-    index5("junior_conversation_messages_search_idx").using(
+    index4("junior_conversation_messages_search_idx").using(
       "gin",
       sql3`to_tsvector('english', ${table.text})`
     )
@@ -708,7 +677,8 @@ var SqlStore = class {
       const incomingExecutionAt = args.execution.updatedAtMs ?? args.updatedAtMs;
       const existingExecutionAt = existing?.execution.updatedAtMs ?? existing?.updatedAtMs ?? 0;
       const incomingIsFresh = incomingExecutionAt >= existingExecutionAt;
-      const sameRun = Boolean(existing?.execution.runId) && existing?.execution.runId === args.execution.runId;
+      const metricRunId = existingRow?.conversation.metricRunId;
+      const sameRun = Boolean(metricRunId) && metricRunId === args.execution.runId;
       const execution = incomingIsFresh ? args.execution : existing?.execution ?? args.execution;
       await this.upsertConversation({
         conversation: {
@@ -736,14 +706,10 @@ var SqlStore = class {
         await this.executor.db().update(juniorConversations).set({
           durationMs: (row?.durationMs ?? 0) - (sameRun ? row?.executionDurationMs ?? 0 : 0) + args.metrics.durationMs,
           usage: usage ?? null,
+          metricRunId: args.execution.runId ?? null,
           executionDurationMs: args.metrics.durationMs,
           executionUsage: args.metrics.usage ?? (sameRun ? row?.executionUsage ?? null : null)
         }).where(eq2(juniorConversations.conversationId, args.conversationId));
-      } else if (incomingIsFresh && !sameRun) {
-        await this.executor.db().update(juniorConversations).set({
-          executionDurationMs: 0,
-          executionUsage: null
-        }).where(eq2(juniorConversations.conversationId, args.conversationId));
       }
     });
   }
@@ -811,6 +777,7 @@ var SqlStore = class {
             durationMs: metrics.durationMs,
             usage: metrics.usage ?? null,
             ...refreshExecutionFromSource ? {
+              metricRunId: conversation.execution.runId ?? null,
               executionDurationMs: metrics.executionDurationMs,
               executionUsage: metrics.executionUsage ?? null
             } : {}
@@ -2053,7 +2020,6 @@ async function closeDb() {
 }
 
 export {
-  juniorDestinations,
   juniorUsers,
   juniorIdentities,
   juniorConversations,

package/dist/{chunk-NG2AV7IB.js → chunk-VVIXK2BX.js}

@@ -1,6 +1,6 @@
 import {
   normalizeSlackConversationId
-} from "./chunk-WTYEKPXU.js";
+} from "./chunk-FP5N5OWZ.js";
 import {
   parseSlackThreadId
 } from "./chunk-LVA4I4H7.js";