@sentry/junior 0.204.0 → 0.206.0

package/dist/schema-8GXFfclK.js

@@ -0,0 +1,559 @@
+import { t as juniorDestinationKindSchema } from "./destinations-BeBiJeEM.js";
+import { E as conversationSummaryReportSchema, n as actorIdentitySchema, w as conversationStatsItemSchema } from "./conversation-AA4R1VUn.js";
+import "./reporting-schema-DosTN__Q.js";
+import { z } from "zod";
+import { codeChangeStateSchema, taskOutcomeSchema } from "@sentry/junior-plugin-api";
+//#region src/api/schema/common.ts
+/** Stable error body returned by Junior-owned REST endpoints. */
+const apiErrorSchema = z.object({ error: z.string().min(1) }).strict();
+//#endregion
+//#region src/api/reporting-window.ts
+/** Shared UTC day/hour/six-hour windows for dashboard activity series. */
+const HOUR_MS = 36e5;
+const SIX_HOUR_MS = 6 * HOUR_MS;
+const DAY_MS = 24 * HOUR_MS;
+/** Start of the UTC calendar day containing `valueMs`. */
+function startOfUtcDay(valueMs) {
+	const date = new Date(valueMs);
+	date.setUTCHours(0, 0, 0, 0);
+	return date;
+}
+/** Start of the UTC hour containing `valueMs`. */
+function startOfUtcHour(valueMs) {
+	const date = new Date(valueMs);
+	date.setUTCMinutes(0, 0, 0);
+	return date;
+}
+/** Start of the UTC 6-hour bucket containing `valueMs` (00/06/12/18). */
+function startOfUtcSixHour(valueMs) {
+	const date = startOfUtcHour(valueMs);
+	date.setUTCHours(Math.floor(date.getUTCHours() / 6) * 6, 0, 0, 0);
+	return date;
+}
+/** UTC day key `YYYY-MM-DD`. */
+function utcDayKey(value) {
+	return (typeof value === "number" ? new Date(value) : value).toISOString().slice(0, 10);
+}
+/** UTC hour key `YYYY-MM-DDTHH`. */
+function utcHourKey(value) {
+	return (typeof value === "number" ? new Date(value) : value).toISOString().slice(0, 13);
+}
+/** UTC 6-hour bucket key `YYYY-MM-DDTHH` at 00/06/12/18. */
+function utcSixHourKey(value) {
+	return utcHourKey(startOfUtcSixHour(typeof value === "number" ? value : value.getTime()));
+}
+/** Inclusive trailing UTC day window ending on today's UTC day. */
+function trailingUtcDayWindow(nowMs, dayCount) {
+	const end = startOfUtcDay(nowMs);
+	const start = new Date(end);
+	start.setUTCDate(start.getUTCDate() - (dayCount - 1));
+	return {
+		end,
+		start
+	};
+}
+/** Inclusive trailing UTC hour window ending on the current UTC hour. */
+function trailingUtcHourWindow(nowMs, hourCount = 24) {
+	const end = startOfUtcHour(nowMs);
+	return {
+		end,
+		start: /* @__PURE__ */ new Date(end.getTime() - (hourCount - 1) * HOUR_MS)
+	};
+}
+/** Inclusive trailing UTC 6-hour window ending on the current 6h bucket. */
+function trailingUtcSixHourWindow(nowMs, bucketCount = 28) {
+	const end = startOfUtcSixHour(nowMs);
+	return {
+		end,
+		start: /* @__PURE__ */ new Date(end.getTime() - (bucketCount - 1) * SIX_HOUR_MS)
+	};
+}
+/** Fill a fixed UTC day window from a sparse map. */
+function fillUtcDays(args) {
+	const { end, start } = trailingUtcDayWindow(args.nowMs, args.count);
+	const items = [];
+	for (const cursor = new Date(start); cursor.getTime() <= end.getTime(); cursor.setUTCDate(cursor.getUTCDate() + 1)) {
+		const date = utcDayKey(cursor);
+		items.push(args.rows.get(date) ?? args.empty(date));
+	}
+	return items;
+}
+/** Fill a fixed UTC hour window from a sparse map. */
+function fillUtcHours(args) {
+	const hourCount = args.count ?? 24;
+	const { end, start } = trailingUtcHourWindow(args.nowMs, hourCount);
+	const items = [];
+	for (const cursor = new Date(start); cursor.getTime() <= end.getTime(); cursor.setTime(cursor.getTime() + HOUR_MS)) {
+		const date = utcHourKey(cursor);
+		items.push(args.rows.get(date) ?? args.empty(date));
+	}
+	return items;
+}
+/** Fill a fixed UTC 6-hour window from a map of known rows. */
+function fillUtcSixHours(args) {
+	const bucketCount = args.count ?? 28;
+	const { end, start } = trailingUtcSixHourWindow(args.nowMs, bucketCount);
+	const items = [];
+	for (const cursor = new Date(start); cursor.getTime() <= end.getTime(); cursor.setTime(cursor.getTime() + SIX_HOUR_MS)) {
+		const date = utcSixHourKey(cursor);
+		items.push(args.rows.get(date) ?? args.empty(date));
+	}
+	return items;
+}
+/**
+* Sum hour rows into trailing 6-hour buckets.
+* Adds number fields. Keeps other fields from the first row in the bucket.
+* Sets `date` to the 6-hour bucket key.
+*/
+function sumUtcHoursIntoSixHours(args) {
+	const bucketCount = args.count ?? 28;
+	const bySix = /* @__PURE__ */ new Map();
+	for (const hour of args.hours) {
+		const key = utcSixHourKey(Date.parse(`${hour.date}:00:00.000Z`));
+		const next = {
+			...bySix.get(key) ?? args.empty(key),
+			date: key
+		};
+		for (const [field, value] of Object.entries(hour)) {
+			if (field === "date") continue;
+			if (typeof value === "number") {
+				const prior = next[field];
+				next[field] = (typeof prior === "number" ? prior : 0) + value;
+			}
+		}
+		bySix.set(key, next);
+	}
+	return fillUtcSixHours({
+		count: bucketCount,
+		empty: args.empty,
+		nowMs: args.nowMs,
+		rows: bySix
+	});
+}
+//#endregion
+//#region src/api/schema/code.ts
+const codeChangeSummarySchema = z.object({
+	closed: z.number().int().nonnegative(),
+	costUsd: z.number().nonnegative().optional(),
+	created: z.number().int().nonnegative(),
+	medianCostUsd: z.number().nonnegative().optional(),
+	medianMergeTimeMs: z.number().nonnegative().optional(),
+	merged: z.number().int().nonnegative(),
+	mergeRate: z.number().min(0).max(1).optional(),
+	open: z.number().int().nonnegative()
+}).strict();
+/** UTC day (`YYYY-MM-DD`) or hour (`YYYY-MM-DDTHH`) activity bucket key. */
+const codeMetricBucketSchema = z.string().regex(/^\d{4}-\d{2}-\d{2}(T\d{2})?$/);
+const codeActivityDaySchema = z.object({
+	closed: z.number().int().nonnegative(),
+	created: z.number().int().nonnegative(),
+	date: codeMetricBucketSchema,
+	merged: z.number().int().nonnegative()
+}).strict();
+const codeRepositorySummarySchema = z.object({
+	closed: z.number().int().nonnegative(),
+	created: z.number().int().nonnegative(),
+	id: z.string().uuid(),
+	medianCostUsd: z.number().nonnegative().optional(),
+	merged: z.number().int().nonnegative(),
+	mergeRate: z.number().min(0).max(1).optional(),
+	name: z.string().min(1),
+	open: z.number().int().nonnegative(),
+	provider: z.string().min(1),
+	url: z.string().url().optional()
+}).strict();
+const codeChangeSummaryReportSchema = z.object({
+	closedAt: z.string().optional(),
+	id: z.string().uuid(),
+	mergedAt: z.string().optional(),
+	number: z.number().int().positive(),
+	openedAt: z.string(),
+	provider: z.string().min(1),
+	repository: z.string().min(1),
+	state: codeChangeStateSchema,
+	title: z.string().optional(),
+	url: z.string().url().optional()
+}).strict();
+const codeOverviewReportSchema = z.object({
+	activityDays: z.array(codeActivityDaySchema),
+	activityHours: z.array(codeActivityDaySchema).optional(),
+	activitySixHours: z.array(codeActivityDaySchema).optional(),
+	changes: z.array(codeChangeSummaryReportSchema),
+	generatedAt: z.string(),
+	repositories: z.array(codeRepositorySummarySchema),
+	summary: codeChangeSummarySchema,
+	windowEnd: z.string(),
+	windowStart: z.string()
+}).strict();
+/** Person-scoped code activity for one People profile. */
+const codePersonReportSchema = z.object({
+	activityDays: z.array(codeActivityDaySchema),
+	activityHours: z.array(codeActivityDaySchema).optional(),
+	activitySixHours: z.array(codeActivityDaySchema).optional(),
+	generatedAt: z.string(),
+	summary: codeChangeSummarySchema,
+	windowEnd: z.string(),
+	windowStart: z.string()
+}).strict();
+//#endregion
+//#region src/api/activity.ts
+const dailyConversationActivitySchema = z.object({
+	active: z.number(),
+	conversations: z.number(),
+	date: z.string(),
+	durationMs: z.number(),
+	failed: z.number(),
+	tokens: z.number().optional()
+}).strict();
+/** Build a zeroed day for conversation activity projections. */
+function emptyActivityDay(date) {
+	return {
+		active: 0,
+		conversations: 0,
+		date,
+		durationMs: 0,
+		failed: 0
+	};
+}
+/** Fill a fixed UTC day window from sparse conversation activity. */
+function activityDays(days, nowMs, count) {
+	return fillUtcDays({
+		count,
+		empty: emptyActivityDay,
+		nowMs,
+		rows: days
+	});
+}
+/**
+* Fill the trailing 7-day UTC hour window from known hour rows.
+* 24h charts use the last 24 points. 7d charts sum hours into 6-hour buckets.
+*/
+function activityHours(hours, nowMs) {
+	return fillUtcHours({
+		count: 168,
+		empty: emptyActivityDay,
+		nowMs,
+		rows: hours
+	});
+}
+/**
+* Fill trailing 6-hour buckets from hour keys or hour rows.
+* Hour keys must be summed into 6-hour keys first.
+*/
+function activitySixHours(hours, nowMs) {
+	return sumUtcHoursIntoSixHours({
+		empty: emptyActivityDay,
+		hours: hours instanceof Map ? activityHours(hours, nowMs) : [...hours],
+		nowMs
+	});
+}
+//#endregion
+//#region src/api/schema/location.ts
+const locationParamsSchema = z.object({ locationId: z.string().min(1) }).strict();
+const locationSummaryReportSchema = conversationStatsItemSchema.extend({
+	id: z.string(),
+	firstSeenAt: z.string(),
+	kind: juniorDestinationKindSchema,
+	lastSeenAt: z.string(),
+	provider: z.string(),
+	providerDestinationId: z.string(),
+	visibility: z.literal("public")
+}).strict();
+const locationActorSummaryReportSchema = conversationStatsItemSchema.extend({ actor: actorIdentitySchema }).strict();
+/** UTC day (`YYYY-MM-DD`) or hour (`YYYY-MM-DDTHH`) activity bucket key. */
+const locationMetricBucketSchema = z.string().regex(/^\d{4}-\d{2}-\d{2}(T\d{2})?$/);
+const locationActivityDayReportSchema = z.object({
+	date: locationMetricBucketSchema,
+	privateConversations: z.number(),
+	publicConversations: z.number()
+}).strict();
+const locationDirectoryReportSchema = z.object({
+	activityDays: z.array(locationActivityDayReportSchema),
+	activityHours: z.array(locationActivityDayReportSchema).optional(),
+	activitySixHours: z.array(locationActivityDayReportSchema).optional(),
+	generatedAt: z.string(),
+	locations: z.array(locationSummaryReportSchema),
+	privateActivity: conversationStatsItemSchema,
+	source: z.literal("conversation_index"),
+	windowEnd: z.string(),
+	windowStart: z.string()
+}).strict();
+const locationDetailReportSchema = locationSummaryReportSchema.extend({
+	activityDays: z.array(dailyConversationActivitySchema),
+	activityHours: z.array(dailyConversationActivitySchema).optional(),
+	activitySixHours: z.array(dailyConversationActivitySchema).optional(),
+	actors: z.array(locationActorSummaryReportSchema),
+	generatedAt: z.string(),
+	recentConversations: z.array(conversationSummaryReportSchema),
+	source: z.literal("conversation_index"),
+	windowEnd: z.string(),
+	windowStart: z.string()
+}).strict();
+//#endregion
+//#region src/api/schema/person.ts
+const personParamsSchema = z.object({ email: z.string().trim().min(1) }).strict();
+const peopleConversationStatsItemSchema = conversationStatsItemSchema.omit({ costUsd: true });
+/** UTC day (`YYYY-MM-DD`) or hour (`YYYY-MM-DDTHH`) activity bucket key. */
+const peopleMetricBucketSchema = z.string().regex(/^\d{4}-\d{2}-\d{2}(T\d{2})?$/);
+const actorActivityDayReportSchema = z.object({
+	active: z.number(),
+	conversations: z.number(),
+	costUsd: z.number().optional(),
+	date: peopleMetricBucketSchema,
+	durationMs: z.number(),
+	failed: z.number(),
+	tokens: z.number().optional()
+}).strict();
+const peopleActivityDayReportSchema = z.object({
+	activePeople: z.number(),
+	conversations: z.number(),
+	date: peopleMetricBucketSchema
+}).strict();
+const actorTotalsReportSchema = z.object({
+	active: z.number(),
+	activeDays: z.number(),
+	conversations: z.number(),
+	durationMs: z.number(),
+	failed: z.number(),
+	tokens: z.number().optional()
+}).strict();
+/** Spend and activity for one people-directory range, plus the prior period's spend. */
+const actorWindowMetricsSchema = z.object({
+	conversations: z.number().int().nonnegative(),
+	costUsd: z.number().finite().nonnegative(),
+	durationMs: z.number().finite().nonnegative(),
+	priorCostUsd: z.number().finite().nonnegative()
+}).strict();
+/** People-directory ranges that match the dashboard range control. */
+const actorDirectoryWindowsSchema = z.object({
+	1: actorWindowMetricsSchema,
+	7: actorWindowMetricsSchema,
+	30: actorWindowMetricsSchema,
+	90: actorWindowMetricsSchema
+}).strict();
+const identifiedActorSchema = actorIdentitySchema.extend({ email: z.string().min(1) }).strict();
+const actorSummaryReportSchema = actorTotalsReportSchema.extend({
+	firstSeenAt: z.string(),
+	lastSeenAt: z.string(),
+	actor: identifiedActorSchema,
+	windows: actorDirectoryWindowsSchema
+}).strict();
+const actorDirectoryReportSchema = z.object({
+	activityDays: z.array(peopleActivityDayReportSchema),
+	activityHours: z.array(peopleActivityDayReportSchema).optional(),
+	activitySixHours: z.array(peopleActivityDayReportSchema).optional(),
+	generatedAt: z.string(),
+	people: z.array(actorSummaryReportSchema),
+	source: z.literal("conversation_index"),
+	windowEnd: z.string(),
+	windowStart: z.string()
+}).strict();
+const actorProfileReportSchema = z.object({
+	activityDays: z.array(actorActivityDayReportSchema),
+	activityHours: z.array(actorActivityDayReportSchema).optional(),
+	activitySixHours: z.array(actorActivityDayReportSchema).optional(),
+	generatedAt: z.string(),
+	locations: z.array(peopleConversationStatsItemSchema),
+	recentConversations: z.array(conversationSummaryReportSchema),
+	actor: identifiedActorSchema,
+	source: z.literal("conversation_index"),
+	surfaces: z.array(peopleConversationStatsItemSchema),
+	totals: actorTotalsReportSchema,
+	windowEnd: z.string(),
+	windowStart: z.string()
+}).strict();
+const personalSpendReportSchema = z.object({
+	generatedAt: z.string(),
+	sevenDaysUsd: z.number().finite().nonnegative(),
+	source: z.literal("conversation_index"),
+	thirtyDaysUsd: z.number().finite().nonnegative(),
+	windowEnd: z.string(),
+	windowStart: z.string()
+}).strict();
+//#endregion
+//#region src/api/schema/personal-token.ts
+const personalTokenMetadataSchema = z.object({
+	id: z.string().uuid(),
+	name: z.string(),
+	tokenSuffix: z.string(),
+	createdAt: z.string().datetime(),
+	expiresAt: z.string().datetime(),
+	lastUsedAt: z.string().datetime().nullable()
+}).strict();
+const personalTokenListSchema = z.object({ tokens: z.array(personalTokenMetadataSchema) }).strict();
+const createPersonalTokenBodySchema = z.object({ name: z.string().trim().min(1).max(80) }).strict();
+const createdPersonalTokenSchema = personalTokenMetadataSchema.extend({ token: z.string().startsWith("jr_pat_") }).strict();
+const personalTokenParamsSchema = z.object({ id: z.string().uuid() }).strict();
+const revokePersonalTokenResponseSchema = z.object({ revoked: z.literal(true) }).strict();
+//#endregion
+//#region src/api/schema/task.ts
+const taskDestinationSchema = z.object({
+	channelId: z.string().min(1),
+	label: z.string().min(1),
+	teamId: z.string().min(1),
+	visibility: z.enum(["private", "public"])
+}).strict();
+/** Task run counts for the dashboard range control (24h/7d/30d/90d). */
+const taskRunWindowsSchema = z.object({
+	1: z.number().int().nonnegative(),
+	7: z.number().int().nonnegative(),
+	30: z.number().int().nonnegative(),
+	90: z.number().int().nonnegative()
+}).strict();
+const taskSummaryBaseSchema = z.object({
+	createdAt: z.string().datetime(),
+	createdBy: z.string().min(1),
+	createdByEmail: z.string().trim().email().optional(),
+	destination: taskDestinationSchema,
+	id: z.string().min(1),
+	instruction: z.string().min(1),
+	lastConversationId: z.string().min(1).optional(),
+	lastRunAt: z.string().datetime().optional(),
+	ownedByViewer: z.boolean(),
+	runs: taskRunWindowsSchema,
+	outcomes: z.array(taskOutcomeSchema).max(5),
+	/** Short display title; falls back from instruction when unset. */
+	title: z.string().min(1),
+	totalRuns: z.number().int().nonnegative()
+});
+const scheduledTaskSummarySchema = taskSummaryBaseSchema.extend({
+	kind: z.literal("scheduled"),
+	nextRunAt: z.string().datetime().optional(),
+	schedule: z.string().min(1),
+	status: z.enum([
+		"active",
+		"blocked",
+		"completed"
+	])
+}).strict();
+const eventTaskSummarySchema = taskSummaryBaseSchema.extend({
+	events: z.array(z.string().min(1)).min(1),
+	kind: z.literal("event"),
+	resource: z.string().min(1),
+	source: z.string().min(1),
+	triggerAvailable: z.boolean()
+}).strict();
+const taskSummarySchema = z.discriminatedUnion("kind", [scheduledTaskSummarySchema, eventTaskSummarySchema]);
+/** UTC day (`YYYY-MM-DD`) or hour (`YYYY-MM-DDTHH`) execution bucket key. */
+const taskMetricBucketSchema = z.string().regex(/^\d{4}-\d{2}-\d{2}(T\d{2})?$/);
+/** One UTC day/hour of completed task executions stacked by task type. */
+const taskExecutionDaySchema = z.object({
+	/** Linked conversation spend for executions in this bucket. */
+	costUsd: z.number().finite().nonnegative(),
+	date: taskMetricBucketSchema,
+	event: z.number().int().nonnegative(),
+	scheduled: z.number().int().nonnegative()
+}).strict();
+const taskListQuerySchema = z.object({ q: z.string().trim().max(200).optional() }).strict();
+const taskListSchema = z.object({
+	executionDays: z.array(taskExecutionDaySchema),
+	executionHours: z.array(taskExecutionDaySchema).optional(),
+	executionSixHours: z.array(taskExecutionDaySchema).optional(),
+	tasks: z.array(taskSummarySchema),
+	truncated: z.boolean()
+}).strict();
+const taskParamsSchema = z.object({
+	id: z.string().min(1),
+	kind: z.enum(["scheduled", "event"])
+}).strict();
+const taskExecutionStatusSchema = z.enum([
+	"blocked",
+	"completed",
+	"failed"
+]);
+const taskExecutionSchema = z.object({
+	conversationId: z.string().min(1).optional(),
+	/** Estimated model cost for the linked conversation, when known. */
+	costUsd: z.number().finite().nonnegative().optional(),
+	/** Cumulative conversation runtime in milliseconds, when known. */
+	durationMs: z.number().finite().nonnegative().optional(),
+	executedAt: z.string().datetime(),
+	executionId: z.string().min(1),
+	status: taskExecutionStatusSchema,
+	title: z.string().min(1).optional(),
+	/** Cumulative conversation token total, when known. */
+	totalTokens: z.number().int().nonnegative().optional()
+}).strict();
+/** One UTC day/hour of terminal executions for a single task, stacked by status. */
+const taskExecutionStatusDaySchema = z.object({
+	blocked: z.number().int().nonnegative(),
+	completed: z.number().int().nonnegative(),
+	date: taskMetricBucketSchema,
+	failed: z.number().int().nonnegative()
+}).strict();
+const taskExecutionListSchema = z.object({
+	executionDays: z.array(taskExecutionStatusDaySchema),
+	executionHours: z.array(taskExecutionStatusDaySchema).optional(),
+	executionSixHours: z.array(taskExecutionStatusDaySchema).optional(),
+	executions: z.array(taskExecutionSchema),
+	task: taskSummarySchema,
+	truncated: z.boolean()
+}).strict();
+const taskRunSchema = taskExecutionSchema.extend({
+	kind: z.enum(["scheduled", "event"]),
+	taskId: z.string().min(1),
+	taskTitle: z.string().min(1)
+}).strict();
+const taskRunListSchema = z.object({
+	runs: z.array(taskRunSchema),
+	truncated: z.boolean()
+}).strict();
+//#endregion
+//#region src/api/schema/workspace.ts
+const workspaceRepoInputSchema = z.object({
+	provider: z.string(),
+	repo: z.string()
+}).strict();
+const workspaceRepoSchema = z.object({
+	provider: z.string(),
+	repo: z.string(),
+	checkoutPath: z.string()
+}).strict();
+const workspaceSnapshotSchema = z.object({
+	id: z.string(),
+	generatedAt: z.iso.datetime(),
+	buildDurationMs: z.number().int().nonnegative(),
+	sizeBytes: z.number().int().nonnegative().nullable()
+}).strict();
+/** Install-wide baseline Sandbox snapshot used when no Workspace recipe is selected. */
+const baselineSnapshotSchema = z.object({
+	id: z.string(),
+	generatedAt: z.iso.datetime(),
+	buildDurationMs: z.number().int().nonnegative(),
+	dependencyCount: z.number().int().nonnegative()
+}).strict();
+const workspaceSchema = z.object({
+	id: z.string().uuid(),
+	name: z.string(),
+	setupScript: z.string(),
+	repos: z.array(workspaceRepoSchema),
+	snapshot: workspaceSnapshotSchema.nullable()
+}).strict();
+const workspaceListSchema = z.object({
+	baselineSnapshot: baselineSnapshotSchema.nullable(),
+	workspaces: z.array(workspaceSchema)
+}).strict();
+const workspaceBodySchema = z.object({
+	name: z.string(),
+	setupScript: z.string().optional(),
+	repos: z.array(workspaceRepoInputSchema)
+}).strict();
+const workspaceParamsSchema = z.object({ id: z.string().uuid() }).strict();
+const deleteWorkspaceResponseSchema = z.object({ deleted: z.literal(true) }).strict();
+//#endregion
+//#region src/api/schema/stats.ts
+const statSchema = z.object({
+	count: z.number().int().nonnegative(),
+	date: z.string(),
+	metric: z.string().min(1),
+	name: z.string().min(1),
+	namespace: z.string().min(1)
+}).strict();
+const statsReportSchema = z.object({
+	generatedAt: z.string().datetime(),
+	stats: z.array(statSchema),
+	windowEnd: z.string(),
+	windowStart: z.string()
+}).strict();
+//#endregion
+export { sumUtcHoursIntoSixHours as $, actorProfileReportSchema as A, dailyConversationActivitySchema as B, createPersonalTokenBodySchema as C, personalTokenParamsSchema as D, personalTokenMetadataSchema as E, locationDirectoryReportSchema as F, codePersonReportSchema as G, codeChangeSummaryReportSchema as H, locationParamsSchema as I, HOUR_MS as J, codeRepositorySummarySchema as K, activityDays as L, personalSpendReportSchema as M, locationActivityDayReportSchema as N, revokePersonalTokenResponseSchema as O, locationDetailReportSchema as P, startOfUtcHour as Q, activityHours as R, taskSummarySchema as S, personalTokenListSchema as T, codeChangeSummarySchema as U, codeActivityDaySchema as V, codeOverviewReportSchema as W, fillUtcHours as X, fillUtcDays as Y, fillUtcSixHours as Z, taskListSchema as _, workspaceBodySchema as a, apiErrorSchema as at, taskRunSchema as b, workspaceRepoSchema as c, scheduledTaskSummarySchema as d, trailingUtcDayWindow as et, taskExecutionListSchema as f, taskListQuerySchema as g, taskExecutionStatusSchema as h, deleteWorkspaceResponseSchema as i, utcHourKey as it, personParamsSchema as j, actorDirectoryReportSchema as k, workspaceSchema as l, taskExecutionStatusDaySchema as m, statsReportSchema as n, trailingUtcSixHourWindow as nt, workspaceListSchema as o, taskExecutionSchema as p, DAY_MS as q, baselineSnapshotSchema as r, utcDayKey as rt, workspaceParamsSchema as s, statSchema as t, trailingUtcHourWindow as tt, eventTaskSummarySchema as u, taskParamsSchema as v, createdPersonalTokenSchema as w, taskRunWindowsSchema as x, taskRunListSchema as y, activitySixHours as z };

package/dist/{skills-CIcDQSgM.js → skills-BhM5qyCF.js}

@@ -1,7 +1,7 @@
 import { t as __exportAll } from "./rolldown-runtime-B4FMCO8f.js";
-import { f as logWarn } from "./logging-BzAk1S_s.js";
+import { f as logWarn } from "./logging-D37bayDc.js";
 import { s as skillRoots } from "./package-discovery-7a9YqLhE.js";
-import { n as pluginCatalogRuntime } from "./catalog-runtime-BReos-D4.js";
+import { n as pluginCatalogRuntime } from "./catalog-runtime-TBR8n4e1.js";
 import path from "node:path";
 import { z } from "zod";
 import fs from "node:fs/promises";

package/dist/{spawn-DdkUFRmq.js → spawn-Dk0PqdH6.js}

@@ -1,6 +1,6 @@
 import { t as __exportAll } from "./rolldown-runtime-B4FMCO8f.js";
-import { C as toolInvocationDestination, y as actorFromRun } from "./agent-runner-DNb1A49M.js";
-import { n as createAndEnqueueAgentInvocation } from "./work-fGofI7Op.js";
+import { C as toolInvocationDestination, y as actorFromRun } from "./agent-runner-E67lFrDG.js";
+import { n as createAndEnqueueAgentInvocation } from "./work-Di-ubSGg.js";
 //#region src/chat/agent-invocations/spawn.ts
 var spawn_exports = /* @__PURE__ */ __exportAll({ bindSpawnAgent: () => bindSpawnAgent });
 /** Bind a Run's Actor and credentials to new Agent invocations. */

package/dist/{stats-DTUbAb88.js → stats-DKRP4rsY.js}

@@ -1,11 +1,11 @@
-import { i as getChatConfig } from "./config-nGCW1OTG.js";
-import { F as isRecord$1, I as toOptionalNumber, L as toOptionalString } from "./logging-BzAk1S_s.js";
+import { F as isRecord$1, I as toOptionalNumber, L as toOptionalString } from "./logging-D37bayDc.js";
+import { a as getChatConfig } from "./config-CIE83sR2.js";
 import { _ as parseSlackMessageTs, d as parseStoredSlackActor, h as parseSlackTeamId, p as parseSlackChannelId } from "./context-B45_WqVX.js";
-import { B as getSlackClient, Bt as parseDestination, Et as getDb, G as withSlackRetries, Ht as sameDestination, Tt as getConversationStore, u as getPlugins, ut as JUNIOR_THREAD_STATE_TTL_MS } from "./agent-hooks-Bbcp9e33.js";
+import { Ft as getConversationStore, It as getDb, J as withSlackRetries, Qt as sameDestination, U as getSlackClient, Xt as parseDestination, pt as JUNIOR_THREAD_STATE_TTL_MS, u as getPlugins } from "./agent-hooks-DNjlz2A-.js";
 import { n as juniorDestinations } from "./destinations-BeBiJeEM.js";
-import { C as juniorConversations, a as juniorSchedulerRuns, c as juniorStats, l as juniorEventTasks, o as juniorSchedulerTasks, x as juniorAttachments } from "./executor-DcMSlI5c.js";
-import { o as ToolInputError } from "./usage-D3EbSO7w.js";
-import { C as getDefaultRedisStateAdapterFor, w as getStateAdapter } from "./profile-CrT5nXbw.js";
+import { S as juniorAttachments, a as juniorSchedulerRuns, c as juniorStats, l as juniorEventTasks, o as juniorSchedulerTasks, w as juniorConversations } from "./executor-BfbYPW63.js";
+import { o as ToolInputError } from "./usage-D4A48Bdl.js";
+import { C as getDefaultRedisStateAdapterFor, w as getStateAdapter } from "./profile-CSixooTi.js";
 import "./vercel-queue-DIkVcfK4.js";
 import { z } from "zod";
 import { createHash, randomUUID } from "node:crypto";
@@ -1830,7 +1830,7 @@ async function resolveTaskOutcomes(outcomes, currentDestination, creatorSlackUse
 			if (outcome.destination.channelId !== currentDestination.channelId) throw new Error("Messages can only be sent to the current Slack conversation or the task creator.");
 			resolved.push({
 				action: "send_message",
-				destination: outcome.destination
+				destination: currentDestination
 			});
 			continue;
 		}
@@ -1849,12 +1849,25 @@ async function resolveTaskOutcomes(outcomes, currentDestination, creatorSlackUse
 	}
 	return resolved;
 }
-/** Return stored outcomes, or preserve the legacy message Destination. */
+function outcomeTargetsDestination(outcome, destination) {
+	return outcome.destination.teamId === destination.teamId && outcome.destination.channelId === destination.channelId && (!outcome.destination.threadTs || outcome.destination.threadTs === destination.threadTs);
+}
+/** Return outcomes with legacy same-channel messages bound to the task Destination. */
 function effectiveTaskOutcomes(outcomes, destination) {
-	return outcomes ?? [{
+	return (outcomes ?? [{
 		action: "send_message",
 		destination
-	}];
+	}]).map((outcome) => destination.threadTs && outcomeTargetsDestination(outcome, destination) ? {
+		...outcome,
+		destination
+	} : outcome);
+}
+/** Move outcomes that target the task Destination and keep other outcomes unchanged. */
+function moveTaskOutcomes(outcomes, currentDestination, nextDestination) {
+	return effectiveTaskOutcomes(outcomes, currentDestination).map((outcome) => outcomeTargetsDestination(outcome, currentDestination) ? {
+		...outcome,
+		destination: nextDestination
+	} : outcome);
 }
 //#endregion
 //#region src/chat/event-tasks/tool-support.ts
@@ -1909,7 +1922,8 @@ function requireEventTaskSlackContext(context) {
 		destination: {
 			platform: "slack",
 			teamId: context.source.teamId,
-			channelId: context.source.channelId
+			channelId: context.source.channelId,
+			threadTs: context.source.threadTs ?? context.source.messageTs
 		},
 		source: context.source
 	};
@@ -2631,4 +2645,4 @@ async function readStats(start, end) {
 	return await getDb().select().from(juniorStats).where(and(gte(juniorStats.date, start), lte(juniorStats.date, end))).orderBy(asc(juniorStats.date), asc(juniorStats.namespace), asc(juniorStats.metric), asc(juniorStats.name));
 }
 //#endregion
-export { workspaceSnapshotWatch as $, eventTaskTriggerAvailable as A, releaseConversationWork as At, deleteEventTask as B, isInvalidConversationRecordError as Bt, SCHEDULED_TASK_SYSTEM_ACTOR as C, ensureConversationWake as Ct, eventTaskMatchesDestination as D, listActiveConversationIds as Dt, eventTaskListToolResultSchema as E, hasRunnableConversationWork as Et, effectiveTaskOutcomes as F, stopConversationWork as Ft, listEventTasksCreatedBy as G, buildDeterministicTurnId as Gt, findMatchingEventTasks as H, juniorToolOutputSchema as Ht, resolveTaskOutcomes as I, CONVERSATION_WORK_CHECK_IN_INTERVAL_MS as It, saveEventTask as J, listEventTasksForTeam as K, taskOutcomeInputSchema as L, CONVERSATION_WORK_STALE_ENQUEUE_MS as Lt, requireEventTaskSlackContext as M, requestAnotherSlice as Mt, requireSupportedEventTaskTrigger as N, requestConversationWork as Nt, eventTaskSuccess as O, recordAttemptFailure as Ot, writableEventTask as P, startConversationWork as Pt, workspaceSnapshotFinishedEvent as Q, collectEventTaskMatchKeys as R, hasRunnableConversationWork$1 as Rt, withScheduledTaskLock as S, drainConversationMailbox as St, compactEventTask as T, getConversationWorkState as Tt, getEventTask as U, makeStructuredToolOutput as Ut, eventTaskBelongsToUser as V, injectContinuationToolName as Vt, listDeletedEventTasksCreatedBy as W, buildDeterministicAssistantMessageId as Wt, WORKSPACE_SNAPSHOT_FAILED_EVENT as X, getResourceEventCatalog as Y, WORKSPACE_SNAPSHOT_READY_EVENT as Z, parseScheduledTaskRow as _, clearExpiredConversationLease as _t, requestAttachmentDeletion as a, registeredEventTypeSchema as at, saveScheduledTaskInLock as b, countPendingConversationMessages as bt, parseSlackThreadId as c, requireSupportedResourceEventMatch as ct, resolveSlackChannelIdFromThreadId as d, appendAndEnqueueExclusiveInboundMessage as dt, eventNamespaceSchema as et, createScheduledTask as f, appendAndEnqueueInboundMessage as ft, listScheduledTasksForTeam as g, clearConsumedConversationWake as gt, listScheduledTasks as h, checkInConversationWork as ht, readLiveAttachment as i, pluginSupportsEvent as it, registeredEventTaskTriggerSchema as j, removeActiveConversation as jt, eventTaskToolResultSchema as k, recordConversationRetry as kt, readSlackRawMessageContext as l, resourceEventGuidance as lt, listPublicScheduledTasksForTeams as m, cancelHumanFacingPendingMessages as mt, readStats as n, hasResourceEventCatalogEntries as nt, storeAttachment as o, registeredResourceEventMatchSchema as ot, isListedScheduledTask as p, beginConversationResume as pt, listPublicEventTasksForTeams as q, collectAttachmentGarbage as r, normalizeEventIdentifier as rt, storeAttachments as s, registeredResourceTypeSchema as st, incrementStat as t, hasPluginResourceEventCatalogEntries as tt, resolveSlackChannelIdFromMessage as u, ackMessages as ut, readScheduledTask as v, completeConversationStop as vt, scheduledRunSchema as w, getConversation as wt, scheduledRunId as x, deadLetterAttempt as xt, saveScheduledTask as y, completeConversationWork as yt, createEventTask as z, isFinalAttempt as zt };
+export { workspaceSnapshotFinishedEvent as $, eventTaskTriggerAvailable as A, recordConversationRetry as At, createEventTask as B, isFinalAttempt as Bt, SCHEDULED_TASK_SYSTEM_ACTOR as C, drainConversationMailbox as Ct, eventTaskMatchesDestination as D, hasRunnableConversationWork as Dt, eventTaskListToolResultSchema as E, getConversationWorkState as Et, effectiveTaskOutcomes as F, startConversationWork as Ft, listDeletedEventTasksCreatedBy as G, buildDeterministicAssistantMessageId as Gt, eventTaskBelongsToUser as H, injectContinuationToolName as Ht, moveTaskOutcomes as I, stopConversationWork as It, listPublicEventTasksForTeams as J, listEventTasksCreatedBy as K, buildDeterministicTurnId as Kt, resolveTaskOutcomes as L, CONVERSATION_WORK_CHECK_IN_INTERVAL_MS as Lt, requireEventTaskSlackContext as M, removeActiveConversation as Mt, requireSupportedEventTaskTrigger as N, requestAnotherSlice as Nt, eventTaskSuccess as O, listActiveConversationIds as Ot, writableEventTask as P, requestConversationWork as Pt, WORKSPACE_SNAPSHOT_READY_EVENT as Q, taskOutcomeInputSchema as R, CONVERSATION_WORK_STALE_ENQUEUE_MS as Rt, withScheduledTaskLock as S, deadLetterAttempt as St, compactEventTask as T, getConversation as Tt, findMatchingEventTasks as U, juniorToolOutputSchema as Ut, deleteEventTask as V, isInvalidConversationRecordError as Vt, getEventTask as W, makeStructuredToolOutput as Wt, getResourceEventCatalog as X, saveEventTask as Y, WORKSPACE_SNAPSHOT_FAILED_EVENT as Z, parseScheduledTaskRow as _, clearConsumedConversationWake as _t, requestAttachmentDeletion as a, pluginSupportsEvent as at, saveScheduledTaskInLock as b, completeConversationWork as bt, parseSlackThreadId as c, registeredResourceTypeSchema as ct, resolveSlackChannelIdFromThreadId as d, ackMessages as dt, workspaceSnapshotWatch as et, createScheduledTask as f, appendAndEnqueueExclusiveInboundMessage as ft, listScheduledTasksForTeam as g, checkInConversationWork as gt, listScheduledTasks as h, cancelHumanFacingPendingMessages as ht, readLiveAttachment as i, normalizeEventIdentifier as it, registeredEventTaskTriggerSchema as j, releaseConversationWork as jt, eventTaskToolResultSchema as k, recordAttemptFailure as kt, readSlackRawMessageContext as l, requireSupportedResourceEventMatch as lt, listPublicScheduledTasksForTeams as m, beginConversationResume as mt, readStats as n, hasPluginResourceEventCatalogEntries as nt, storeAttachment as o, registeredEventTypeSchema as ot, isListedScheduledTask as p, appendAndEnqueueInboundMessage as pt, listEventTasksForTeam as q, collectAttachmentGarbage as r, hasResourceEventCatalogEntries as rt, storeAttachments as s, registeredResourceEventMatchSchema as st, incrementStat as t, eventNamespaceSchema as tt, resolveSlackChannelIdFromMessage as u, resourceEventGuidance as ut, readScheduledTask as v, clearExpiredConversationLease as vt, scheduledRunSchema as w, ensureConversationWake as wt, scheduledRunId as x, countPendingConversationMessages as xt, saveScheduledTask as y, completeConversationStop as yt, collectEventTaskMatchKeys as z, hasRunnableConversationWork$1 as zt };

package/dist/{task-queue-CJIR4RF7.js → task-queue-CdpTvu4R.js}

@@ -1,6 +1,6 @@
-import { f as logWarn } from "./logging-BzAk1S_s.js";
+import { f as logWarn } from "./logging-D37bayDc.js";
 import { a as signQueueMessage, i as QUEUE_SIGNATURE_MAX_AGE_MS, o as verifyQueueMessage, s as createVercelQueueClient } from "./vercel-queue-DIkVcfK4.js";
-import { o as runWithTurnRequestDeadline } from "./job-queue-Drn_LXlM.js";
+import { o as runWithTurnRequestDeadline } from "./job-queue-CyTc24Es.js";
 import { z } from "zod";
 import { createHash } from "node:crypto";
 import { handleCallback, registerDevConsumer } from "@vercel/queue";
@@ -110,7 +110,7 @@ function pluginTaskCallback() {
 		maxDeliveries: PLUGIN_TASK_MAX_DELIVERIES,
 		onRejected: logPluginTaskQueueMessageRejected,
 		run: async (message) => {
-			const { processPluginTask } = await import("./task-runner-D-O3A-Cp.js").then((n) => n.r);
+			const { processPluginTask } = await import("./task-runner-alpjVSxQ.js").then((n) => n.r);
 			await processPluginTask(message);
 		},
 		topic: PLUGIN_TASK_QUEUE_TOPIC,