@sentry/junior 0.193.0 → 0.195.0

package/dist/chat/slack/automated-turn-limit-notice.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Destination-visible pause notice for the consecutive automated-turn limit.
+ *
+ * Best-effort: a failed post must not fail the Turn or re-enable event wakes.
+ * The consecutive-turn limit claims the notice slot before this post. Clear that
+ * claim when the post fails or is skipped so a later paused wake can try again.
+ */
+import type { Destination } from "@sentry/junior-plugin-api";
+import { type AutomatedTurnLimitScope, type AutomatedTurnLimitUpdate } from "@/chat/services/automated-turn-limit";
+/** Post the pause notice for one Conversation Location when known. */
+export declare function postAutomatedTurnLimitNoticeForConversation(args: {
+    conversationId: string;
+    maxTurns: number;
+    nowMs?: number;
+    resumeIn?: "thread" | "channel";
+    scope?: AutomatedTurnLimitScope;
+}): Promise<boolean>;
+/** Post the pause notice for one Slack Destination. */
+export declare function postAutomatedTurnLimitNoticeForDestination(args: {
+    destination: Destination;
+    maxTurns: number;
+    nowMs?: number;
+    resumeIn?: "thread" | "channel";
+    scope?: AutomatedTurnLimitScope;
+    threadTs?: string;
+}): Promise<boolean>;
+/**
+ * Post the pause notice after a finished Turn hits the limit.
+ * Prefer the Conversation Location so thread watches stay in-thread.
+ */
+export declare function maybePostAutomatedTurnLimitNotice(args: {
+    conversationId: string;
+    destination?: Destination;
+    maxTurns: number;
+    nowMs?: number;
+    threadTs?: string;
+    update: AutomatedTurnLimitUpdate | undefined;
+}): Promise<void>;

package/dist/chat/slack/{source-link.d.ts → location-url.d.ts}

@@ -4,7 +4,7 @@ export declare function parseSlackTeamDomain(value: unknown): string | undefined
  * Build a direct Slack archive URL for a thread when the workspace domain is
  * known. Omits a link rather than falling back to `app_redirect`.
  */
-export declare function buildSlackSourceUrl(args: {
+export declare function buildSlackLocationUrl(args: {
     channelId: string;
     teamDomain: string;
     threadTs: string;

package/dist/chat/task-execution/checkpoint.d.ts

@@ -49,6 +49,8 @@ interface TurnCheckpointWrite {
     source?: Source;
     surface?: AgentTurnSurface;
     turnStartMessageIndex?: number;
+    /** Tool calls charged to this turn; survives history replacement. */
+    cumulativeToolCallCount?: number;
     trailingMessageProvenance?: ConversationMessageProvenance[];
     turnContexts?: PluginTurnContext[];
     durationMs?: number;

package/dist/chat/task-execution/turn-cursor.d.ts

@@ -32,6 +32,8 @@ export interface TurnRecord {
     version: number;
     conversationId: string;
     cumulativeDurationMs: number;
+    /** Tool calls charged to this turn; survives history replacement. */
+    cumulativeToolCallCount?: number;
     cumulativeUsage?: AgentTurnUsage;
     dispatchId?: string;
     dispatchOutcome?: AgentDispatchOutcome;
@@ -86,6 +88,7 @@ export declare function upsertTurnRecord(args: {
     channelName?: string;
     conversationId: string;
     cumulativeDurationMs?: number;
+    cumulativeToolCallCount?: number;
     cumulativeUsage?: AgentTurnUsage;
     destination?: Destination;
     dispatchId?: string;

package/dist/chat/tasks/execution-stats.d.ts

@@ -3,22 +3,34 @@ export declare const TASK_EXECUTION_TYPES: readonly ["scheduled", "event"];
 export declare const TASK_EXECUTION_STATUSES: readonly ["blocked", "completed", "failed"];
 export type TaskExecutionType = (typeof TASK_EXECUTION_TYPES)[number];
 export type TaskExecutionDay = {
+    costUsd: number;
     date: string;
     event: number;
     scheduled: number;
 };
+export type TaskRunWindows = {
+    1: number;
+    7: number;
+    30: number;
+    90: number;
+};
 export type TaskExecutionSummary = {
     lastConversationId?: string;
     lastExecutedAtMs?: number;
-    runsLast7Days: number;
+    runs: TaskRunWindows;
     totalRuns: number;
 };
+/** Empty run windows for tasks with no execution history. */
+export declare function emptyTaskRunWindows(): TaskRunWindows;
 export type TaskExecutionRecord = {
     conversationId?: string;
+    costUsd?: number;
+    durationMs?: number;
     executedAt: string;
     executionId: string;
     status: TaskExecutionStatus;
     title?: string;
+    totalTokens?: number;
 };
 export type TaskRunRecord = TaskExecutionRecord & {
     kind: TaskExecutionType;
@@ -67,9 +79,10 @@ export declare function readTaskExecutions(args: {
 }): Promise<TaskExecutionRecord[]>;
 /** Load newest-first executions for the supplied viewer-visible tasks. */
 export declare function readTaskRuns(args: {
+    conversationIds?: string[];
     limit: number;
     namespace?: string;
-    tasks: Array<{
+    tasks?: Array<{
         kind: TaskExecutionType;
         taskId: string;
     }>;

package/dist/chat/tasks/read.d.ts

@@ -1,9 +1,12 @@
 import type { User } from "@sentry/junior-plugin-api";
 import type { ConversationSourceTask } from "@/api/schema/conversation";
 import type { TaskExecutionList, TaskList, TaskRunList } from "@/api/schema/task";
-/** Read viewer-owned and public-workspace tasks as one bounded newest-first projection. */
 export declare function readViewerTasks(user: User): Promise<TaskList>;
-/** Read newest runs across the viewer-visible scheduled and event tasks. */
+/**
+ * Read newest runs across live viewer-visible tasks and deleted tasks the
+ * viewer owns. Deleted task rows stay available so history does not depend on
+ * conversation actor membership.
+ */
 export declare function readViewerTaskRuns(user: User): Promise<TaskRunList>;
 export declare class ViewerTaskNotFoundError extends Error {
     constructor();

package/dist/chat/usage.d.ts

@@ -34,5 +34,9 @@ export declare const agentTurnUsageSchema: import("zod").ZodObject<{
 export type AgentTurnUsage = Usage;
 /** Return whether any token counter is present on a usage record. */
 export declare function hasAgentTurnUsage(usage: AgentTurnUsage | undefined): usage is AgentTurnUsage;
+/** Estimated total USD cost from one usage record, when any cost field is present. */
+export declare function agentTurnCostUsd(usage: AgentTurnUsage | undefined): number | undefined;
+/** Total token count from one usage record, preferring component counters. */
+export declare function agentTurnTotalTokens(usage: AgentTurnUsage | undefined): number | undefined;
 /** Aggregate token usage across slices without double-counting provider totals. */
 export declare function addAgentTurnUsage(...usages: Array<AgentTurnUsage | undefined>): AgentTurnUsage | undefined;

package/dist/{chunk-GUKGU6R7.js → chunk-3VWIZVK7.js}

@@ -1,6 +1,6 @@
 import {
   pluginCatalogRuntime
-} from "./chunk-DXFUYLHX.js";
+} from "./chunk-RKA22BQP.js";
 
 // src/chat/plugins/validation.ts
 import { isDeepStrictEqual } from "util";

package/dist/{chunk-THYNA2QN.js → chunk-5HNXLP4W.js}

@@ -1,6 +1,6 @@
 import {
   getStateAdapter
-} from "./chunk-IOUUS6H4.js";
+} from "./chunk-7MYXH5LA.js";
 import {
   getClient
 } from "./chunk-PEQXYSSE.js";

package/dist/{chunk-GUMBIDDL.js → chunk-5NR7N567.js}

@@ -1,13 +1,17 @@
+import {
+  agentTurnCostUsd,
+  agentTurnTotalTokens
+} from "./chunk-R5BGW4WR.js";
 import {
   getDb
-} from "./chunk-2CYWEVOP.js";
+} from "./chunk-KQ3GZGBK.js";
 import {
   juniorConversations,
   juniorTaskExecutions
-} from "./chunk-5S6AQFNG.js";
+} from "./chunk-FPQPYJEG.js";
 import {
   logWarn
-} from "./chunk-QY2IU47O.js";
+} from "./chunk-HUQOXMDG.js";
 
 // src/chat/tasks/execution-stats.ts
 import {
@@ -21,19 +25,111 @@ import {
   lte,
   max,
   or,
-  sql
+  sql as sql2
 } from "drizzle-orm";
+
+// src/api/conversations/aggregate.ts
+import { sql } from "drizzle-orm";
+function usageTokenValue(source, field) {
+  return sql`CASE
+    WHEN ${source.usage}->>${field} IS NOT NULL
+      THEN (${source.usage}->>${field})::double precision
+    ELSE NULL
+  END`;
+}
+function tokenValue(source) {
+  return sql`
+    CASE
+      WHEN COALESCE(
+        ${source.usage}->>'inputTokens',
+        ${source.usage}->>'outputTokens',
+        ${source.usage}->>'cachedInputTokens',
+        ${source.usage}->>'cacheCreationTokens'
+      ) IS NOT NULL
+        THEN COALESCE((${source.usage}->>'inputTokens')::double precision, 0)
+          + COALESCE((${source.usage}->>'outputTokens')::double precision, 0)
+          + COALESCE((${source.usage}->>'cachedInputTokens')::double precision, 0)
+          + COALESCE((${source.usage}->>'cacheCreationTokens')::double precision, 0)
+      WHEN ${source.usage}->>'totalTokens' IS NOT NULL
+        THEN (${source.usage}->>'totalTokens')::double precision
+      ELSE NULL
+    END
+  `;
+}
+function costValue(source) {
+  return conversationUsageCostExpr(source.usage);
+}
+function conversationUsageCostExpr(usage) {
+  return sql`
+    CASE
+      WHEN ${usage}->'cost'->>'total' IS NOT NULL
+        THEN (${usage}->'cost'->>'total')::double precision
+      WHEN COALESCE(
+        ${usage}->'cost'->>'input',
+        ${usage}->'cost'->>'output',
+        ${usage}->'cost'->>'cacheRead',
+        ${usage}->'cost'->>'cacheWrite'
+      ) IS NOT NULL
+        THEN COALESCE((${usage}->'cost'->>'input')::double precision, 0)
+          + COALESCE((${usage}->'cost'->>'output')::double precision, 0)
+          + COALESCE((${usage}->'cost'->>'cacheRead')::double precision, 0)
+          + COALESCE((${usage}->'cost'->>'cacheWrite')::double precision, 0)
+      ELSE NULL
+    END
+  `;
+}
+function conversationAggregateColumns(sources) {
+  const metrics = sources?.metrics ?? juniorConversations;
+  const roots = sources?.roots ?? juniorConversations;
+  const conversationCount = sources ? sql`COUNT(DISTINCT ${roots.conversationId})` : sql`COUNT(*)`;
+  return {
+    active: sql`${conversationCount} FILTER (
+      WHERE ${roots.executionStatus} NOT IN ('idle', 'failed')
+    )::integer`,
+    conversations: sql`${conversationCount}::integer`,
+    cachedInputTokens: sql`SUM(${usageTokenValue(metrics, "cachedInputTokens")})::double precision`,
+    costUsd: sql`SUM(${costValue(metrics)})::double precision`,
+    durationMs: sql`COALESCE(SUM(${metrics.durationMs}), 0)::double precision`,
+    failed: sql`${conversationCount} FILTER (
+      WHERE ${roots.executionStatus} = 'failed'
+    )::integer`,
+    inputTokens: sql`SUM(${usageTokenValue(metrics, "inputTokens")})::double precision`,
+    tokens: sql`SUM(${tokenValue(metrics)})::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/chat/tasks/execution-stats.ts
 var TASK_EXECUTION_TYPES = ["scheduled", "event"];
 var TASK_EXECUTION_STATUSES = [
   "blocked",
   "completed",
   "failed"
 ];
+function addUsd(current, next) {
+  return Math.round((current + next) * 1e12) / 1e12;
+}
+var EMPTY_RUN_WINDOWS = { 1: 0, 7: 0, 30: 0, 90: 0 };
+function emptyTaskRunWindows() {
+  return { ...EMPTY_RUN_WINDOWS };
+}
 function utcDate(nowMs) {
   return new Date(nowMs).toISOString().slice(0, 10);
 }
 function emptyDay(date) {
-  return { date, event: 0, scheduled: 0 };
+  return { costUsd: 0, date, event: 0, scheduled: 0 };
 }
 function emptyStatusDay(date) {
   return { blocked: 0, completed: 0, date, failed: 0 };
@@ -70,7 +166,11 @@ async function recordTaskExecution(type, taskId, options) {
   }
 }
 async function readTaskExecutionSummaries(type, namespace, options = {}) {
-  const sevenDaysAgoMs = (options.nowMs ?? Date.now()) - 7 * 24 * 60 * 60 * 1e3;
+  const nowMs = options.nowMs ?? Date.now();
+  const oneDayAgoMs = nowMs - 1 * 24 * 60 * 60 * 1e3;
+  const sevenDaysAgoMs = nowMs - 7 * 24 * 60 * 60 * 1e3;
+  const thirtyDaysAgoMs = nowMs - 30 * 24 * 60 * 60 * 1e3;
+  const ninetyDaysAgoMs = nowMs - 90 * 24 * 60 * 60 * 1e3;
   const db = getDb();
   const latest = db.selectDistinctOn([juniorTaskExecutions.taskId], {
     conversationId: juniorTaskExecutions.conversationId,
@@ -88,9 +188,12 @@ async function readTaskExecutionSummaries(type, namespace, options = {}) {
   const rows = await db.select({
     lastConversationId: latest.conversationId,
     lastExecutedAtMs: max(juniorTaskExecutions.executedAtMs),
-    runsLast7Days: sql`count(*) filter (where ${juniorTaskExecutions.executedAtMs} >= ${sevenDaysAgoMs})::int`,
+    runsLast1Day: sql2`count(*) filter (where ${juniorTaskExecutions.executedAtMs} >= ${oneDayAgoMs})::int`,
+    runsLast7Days: sql2`count(*) filter (where ${juniorTaskExecutions.executedAtMs} >= ${sevenDaysAgoMs})::int`,
+    runsLast30Days: sql2`count(*) filter (where ${juniorTaskExecutions.executedAtMs} >= ${thirtyDaysAgoMs})::int`,
+    runsLast90Days: sql2`count(*) filter (where ${juniorTaskExecutions.executedAtMs} >= ${ninetyDaysAgoMs})::int`,
     taskId: juniorTaskExecutions.taskId,
-    totalRuns: sql`count(*)::int`
+    totalRuns: sql2`count(*)::int`
   }).from(juniorTaskExecutions).innerJoin(latest, eq(latest.taskId, juniorTaskExecutions.taskId)).where(
     and(
       eq(juniorTaskExecutions.kind, type),
@@ -103,7 +206,12 @@ async function readTaskExecutionSummaries(type, namespace, options = {}) {
       {
         ...row.lastConversationId ? { lastConversationId: row.lastConversationId } : void 0,
         ...row.lastExecutedAtMs !== null ? { lastExecutedAtMs: row.lastExecutedAtMs } : void 0,
-        runsLast7Days: row.runsLast7Days,
+        runs: {
+          1: row.runsLast1Day,
+          7: row.runsLast7Days,
+          30: row.runsLast30Days,
+          90: row.runsLast90Days
+        },
         totalRuns: row.totalRuns
       }
     ])
@@ -114,12 +222,20 @@ async function readTaskExecutionDays(dayCount = 90, options = {}) {
   const end = utcDate(nowMs);
   const endMs = Date.parse(`${end}T23:59:59.999Z`);
   const startMs = Date.parse(`${end}T00:00:00.000Z`) - (dayCount - 1) * 864e5;
-  const executionDate = sql`to_char(to_timestamp(${juniorTaskExecutions.executedAtMs} / 1000.0) at time zone 'UTC', 'YYYY-MM-DD')`;
+  const executionDate = sql2`to_char(to_timestamp(${juniorTaskExecutions.executedAtMs} / 1000.0) at time zone 'UTC', 'YYYY-MM-DD')`;
+  const conversationCost = conversationUsageCostExpr(juniorConversations.usage);
   const rows = await getDb().select({
     count: count(),
+    costUsd: sql2`SUM(${conversationCost})::double precision`,
     date: executionDate,
     kind: juniorTaskExecutions.kind
-  }).from(juniorTaskExecutions).where(
+  }).from(juniorTaskExecutions).leftJoin(
+    juniorConversations,
+    eq(
+      juniorConversations.conversationId,
+      juniorTaskExecutions.conversationId
+    )
+  ).where(
     and(
       gte(juniorTaskExecutions.executedAtMs, startMs),
       lte(juniorTaskExecutions.executedAtMs, endMs),
@@ -136,21 +252,32 @@ async function readTaskExecutionDays(dayCount = 90, options = {}) {
     if (!day) continue;
     if (row.kind === "scheduled") day.scheduled = row.count;
     else if (row.kind === "event") day.event = row.count;
+    if (row.costUsd !== null && row.costUsd > 0) {
+      day.costUsd = addUsd(day.costUsd, row.costUsd);
+    }
   }
   return [...byDate.values()];
 }
-async function readTaskExecutionHours(hourCount = 24, options = {}) {
+async function readTaskExecutionHours(hourCount = 7 * 24, options = {}) {
   const nowMs = options.nowMs ?? Date.now();
   const end = new Date(nowMs);
   end.setUTCMinutes(0, 0, 0);
   const endMs = end.getTime() + 3599999;
   const startMs = end.getTime() - (hourCount - 1) * 36e5;
-  const executionHour = sql`to_char(to_timestamp(${juniorTaskExecutions.executedAtMs} / 1000.0) at time zone 'UTC', 'YYYY-MM-DD"T"HH24')`;
+  const executionHour = sql2`to_char(to_timestamp(${juniorTaskExecutions.executedAtMs} / 1000.0) at time zone 'UTC', 'YYYY-MM-DD"T"HH24')`;
+  const conversationCost = conversationUsageCostExpr(juniorConversations.usage);
   const rows = await getDb().select({
     count: count(),
+    costUsd: sql2`SUM(${conversationCost})::double precision`,
     date: executionHour,
     kind: juniorTaskExecutions.kind
-  }).from(juniorTaskExecutions).where(
+  }).from(juniorTaskExecutions).leftJoin(
+    juniorConversations,
+    eq(
+      juniorConversations.conversationId,
+      juniorTaskExecutions.conversationId
+    )
+  ).where(
     and(
       gte(juniorTaskExecutions.executedAtMs, startMs),
       lte(juniorTaskExecutions.executedAtMs, endMs),
@@ -167,6 +294,9 @@ async function readTaskExecutionHours(hourCount = 24, options = {}) {
     if (!hour) continue;
     if (row.kind === "scheduled") hour.scheduled = row.count;
     else if (row.kind === "event") hour.event = row.count;
+    if (row.costUsd !== null && row.costUsd > 0) {
+      hour.costUsd = addUsd(hour.costUsd, row.costUsd);
+    }
   }
   return [...byHour.values()];
 }
@@ -194,10 +324,12 @@ async function readTaskExecutions(args) {
   const namespace = args.namespace ?? "junior";
   const rows = await getDb().select({
     conversationId: juniorTaskExecutions.conversationId,
+    durationMs: juniorConversations.durationMs,
     executedAtMs: juniorTaskExecutions.executedAtMs,
     executionId: juniorTaskExecutions.executionId,
     status: juniorTaskExecutions.status,
-    title: juniorConversations.title
+    title: juniorConversations.title,
+    usage: juniorConversations.usage
   }).from(juniorTaskExecutions).leftJoin(
     juniorConversations,
     eq(
@@ -214,34 +346,38 @@ async function readTaskExecutions(args) {
     desc(juniorTaskExecutions.executedAtMs),
     desc(juniorTaskExecutions.executionId)
   ).limit(args.limit);
-  return rows.map((row) => {
-    const title = row.title?.trim();
-    return {
-      ...row.conversationId ? { conversationId: row.conversationId } : void 0,
-      executedAt: new Date(row.executedAtMs).toISOString(),
-      executionId: row.executionId,
-      status: row.status,
-      ...title ? { title } : void 0
-    };
-  });
+  return rows.map((row) => mapTaskExecutionRecord(row));
 }
 async function readTaskRuns(args) {
-  if (args.tasks.length === 0) return [];
-  const namespace = args.namespace ?? "junior";
-  const selectors = args.tasks.map(
-    (task) => and(
-      eq(juniorTaskExecutions.kind, task.kind),
-      eq(juniorTaskExecutions.taskId, task.taskId)
+  const tasks = args.tasks ?? [];
+  const conversationIds = [
+    ...new Set(
+      (args.conversationIds ?? []).filter(
+        (conversationId) => conversationId.trim().length > 0
+      )
     )
-  );
+  ];
+  if (tasks.length === 0 && conversationIds.length === 0) return [];
+  const namespace = args.namespace ?? "junior";
+  const selectors = [
+    ...tasks.map(
+      (task) => and(
+        eq(juniorTaskExecutions.kind, task.kind),
+        eq(juniorTaskExecutions.taskId, task.taskId)
+      )
+    ),
+    ...conversationIds.length > 0 ? [inArray(juniorTaskExecutions.conversationId, conversationIds)] : []
+  ];
   const rows = await getDb().select({
     conversationId: juniorTaskExecutions.conversationId,
+    durationMs: juniorConversations.durationMs,
     executedAtMs: juniorTaskExecutions.executedAtMs,
     executionId: juniorTaskExecutions.executionId,
     kind: juniorTaskExecutions.kind,
     status: juniorTaskExecutions.status,
     taskId: juniorTaskExecutions.taskId,
-    title: juniorConversations.title
+    title: juniorConversations.title,
+    usage: juniorConversations.usage
   }).from(juniorTaskExecutions).leftJoin(
     juniorConversations,
     eq(
@@ -254,20 +390,31 @@ async function readTaskRuns(args) {
   ).limit(args.limit);
   return rows.flatMap((row) => {
     if (row.kind !== "scheduled" && row.kind !== "event") return [];
-    const title = row.title?.trim();
     return [
       {
-        ...row.conversationId ? { conversationId: row.conversationId } : void 0,
-        executedAt: new Date(row.executedAtMs).toISOString(),
-        executionId: row.executionId,
+        ...mapTaskExecutionRecord(row),
         kind: row.kind,
-        status: row.status,
-        taskId: row.taskId,
-        ...title ? { title } : void 0
+        taskId: row.taskId
       }
     ];
   });
 }
+function mapTaskExecutionRecord(row) {
+  const title = row.title?.trim();
+  const costUsd = agentTurnCostUsd(row.usage ?? void 0);
+  const totalTokens = agentTurnTotalTokens(row.usage ?? void 0);
+  const durationMs = typeof row.durationMs === "number" && Number.isFinite(row.durationMs) && row.durationMs > 0 ? row.durationMs : void 0;
+  return {
+    ...row.conversationId ? { conversationId: row.conversationId } : void 0,
+    ...costUsd !== void 0 ? { costUsd } : void 0,
+    ...durationMs !== void 0 ? { durationMs } : void 0,
+    executedAt: new Date(row.executedAtMs).toISOString(),
+    executionId: row.executionId,
+    status: row.status,
+    ...title ? { title } : void 0,
+    ...totalTokens !== void 0 ? { totalTokens } : void 0
+  };
+}
 async function readTaskExecutionStatusDays(args) {
   const dayCount = args.dayCount ?? 90;
   const namespace = args.namespace ?? "junior";
@@ -275,7 +422,7 @@ async function readTaskExecutionStatusDays(args) {
   const end = utcDate(nowMs);
   const endMs = Date.parse(`${end}T23:59:59.999Z`);
   const startMs = Date.parse(`${end}T00:00:00.000Z`) - (dayCount - 1) * 864e5;
-  const executionDate = sql`to_char(to_timestamp(${juniorTaskExecutions.executedAtMs} / 1000.0) at time zone 'UTC', 'YYYY-MM-DD')`;
+  const executionDate = sql2`to_char(to_timestamp(${juniorTaskExecutions.executedAtMs} / 1000.0) at time zone 'UTC', 'YYYY-MM-DD')`;
   const rows = await getDb().select({
     count: count(),
     date: executionDate,
@@ -305,14 +452,14 @@ async function readTaskExecutionStatusDays(args) {
   return [...byDate.values()];
 }
 async function readTaskExecutionStatusHours(args) {
-  const hourCount = args.hourCount ?? 24;
+  const hourCount = args.hourCount ?? 7 * 24;
   const namespace = args.namespace ?? "junior";
   const nowMs = args.nowMs ?? Date.now();
   const end = new Date(nowMs);
   end.setUTCMinutes(0, 0, 0);
   const endMs = end.getTime() + 3599999;
   const startMs = end.getTime() - (hourCount - 1) * 36e5;
-  const executionHour = sql`to_char(to_timestamp(${juniorTaskExecutions.executedAtMs} / 1000.0) at time zone 'UTC', 'YYYY-MM-DD"T"HH24')`;
+  const executionHour = sql2`to_char(to_timestamp(${juniorTaskExecutions.executedAtMs} / 1000.0) at time zone 'UTC', 'YYYY-MM-DD"T"HH24')`;
   const rows = await getDb().select({
     count: count(),
     date: executionHour,
@@ -343,6 +490,10 @@ async function readTaskExecutionStatusHours(args) {
 }
 
 export {
+  conversationAggregateColumns,
+  conversationRangeColumns,
+  conversationActiveDaysColumn,
+  emptyTaskRunWindows,
   recordTaskExecution,
   readTaskExecutionSummaries,
   readTaskExecutionDays,

package/dist/{chunk-N6Q2PNSI.js → chunk-6GGDBXXP.js}

@@ -1,6 +1,6 @@
 import {
   runWithTurnRequestDeadline
-} from "./chunk-IQCL5JGL.js";
+} from "./chunk-I4RH3KLJ.js";
 import {
   QUEUE_SIGNATURE_MAX_AGE_MS,
   createVercelQueueClient,
@@ -9,7 +9,7 @@ import {
 } from "./chunk-7H2VZTWN.js";
 import {
   logWarn
-} from "./chunk-QY2IU47O.js";
+} from "./chunk-HUQOXMDG.js";
 
 // src/chat/plugins/task-queue.ts
 import { createHash } from "crypto";
@@ -129,7 +129,7 @@ function pluginTaskCallback() {
     onRejected: logPluginTaskQueueMessageRejected,
     // Load the runner on first use so this module can send without a cycle.
     run: async (message) => {
-      const { processPluginTask } = await import("./task-runner-EEGGG2PM.js");
+      const { processPluginTask } = await import("./task-runner-LLJZTLRP.js");
       await processPluginTask(message);
     },
     topic: PLUGIN_TASK_QUEUE_TOPIC,

package/dist/{chunk-HMBTX5RK.js → chunk-6TRQLG3D.js}

@@ -5,7 +5,7 @@ import {
 } from "./chunk-N7TMSOZH.js";
 import {
   toOptionalString
-} from "./chunk-QY2IU47O.js";
+} from "./chunk-HUQOXMDG.js";
 
 // src/chat/slack/context.ts
 import { z } from "zod";

package/dist/{chunk-IOUUS6H4.js → chunk-7MYXH5LA.js}

@@ -1,6 +1,6 @@
 import {
   getChatConfig
-} from "./chunk-WJJDQLVL.js";
+} from "./chunk-LMYRF6HX.js";
 
 // src/chat/state/adapter.ts
 import { createMemoryState } from "@chat-adapter/state-memory";

package/dist/{chunk-WH5VV2RW.js → chunk-7PQMTME5.js}

@@ -1,6 +1,6 @@
 import {
   getConversationEventStore
-} from "./chunk-2CYWEVOP.js";
+} from "./chunk-KQ3GZGBK.js";
 
 // src/chat/conversations/turn-lifecycle.ts
 var ConversationTurnLifecycleService = class {