@sentry/junior 0.268.0 → 0.270.0

package/dist/{credentialed-lukuD-cc.js → credentialed-BeBaJMZ_.js}

@@ -1,26 +1,27 @@
 import { t as __exportAll } from "./rolldown-runtime-nwUcYXjP.js";
-import { C as toOptionalTrimmed, i as completeObject, o as embedTexts } from "./client-C1yDYjoS.js";
-import { i as getChatConfig, n as botConfig, o as getSlackBotToken, v as normalizeSlackEmojiName } from "./config-DrTeF80T.js";
-import { B as isRecord$2, E as withSpan, a as extractGenAiUsageSummary, b as setSpanAttributes, c as getLogContextAttributes, d as logAudit, h as logWarn, m as logInfo, p as logException, y as setSentryUser } from "./logging-DLSpkSSr.js";
+import { S as toOptionalTrimmed, i as completeObject, o as embedTexts, t as GEN_AI_PROVIDER_NAME } from "./client-B2MjENki.js";
+import { i as getChatConfig, n as botConfig, o as getSlackBotToken, v as normalizeSlackEmojiName } from "./config-Dm3pWRqY.js";
+import { B as isRecord$2, E as withSpan, a as extractGenAiUsageSummary, b as setSpanAttributes, c as getLogContextAttributes, d as logAudit, h as logWarn, m as logInfo, p as logException, y as setSentryUser } from "./logging-C6EdT6PP.js";
 import { a as getClient$1, n as captureMessage, r as continueTrace } from "./sentry-MDkYAVPV.js";
-import { t as canExposeConversationPayload } from "./conversation-privacy-CxlOCiUo.js";
-import { r as defaultModelId } from "./model-profile-Bg8EoCKD.js";
+import { t as canExposeConversationPayload } from "./conversation-privacy-C1pJ89rs.js";
+import { i as defaultModelId } from "./model-profile-B998sjVd.js";
 import { d as parseSlackChannelReferenceId, f as parseSlackTeamId, i as isActorUserId, m as parseSlackMessageTs, p as parseSlackUserId, s as parseActorUserId } from "./actor-CP9K2Idu.js";
-import { B as parseDestination, D as readUserTimezone, L as hasAgentTurnUsage, a as readIdentityById, d as getConversationEventStore, h as getSqlExecutor, i as readActorIdentity, k as saveUserTimezone, m as getDb, o as resolveViewerUser, y as createSqlStore } from "./viewer-CpXTGlep.js";
+import { C as getSqlExecutor, D as createSqlStore, L as readUserTimezone, S as getDb, X as parseDestination, g as createCache, i as readActorIdentity, l as resolveViewerUser, n as findUserByEmailFromSql, o as readIdentityById, p as parseAvatarUrl, q as hasAgentTurnUsage, s as readIdentityByIdFromSql, y as getConversationEventStore, z as saveUserTimezone } from "./viewer-BTgAfdUg.js";
 import { c as juniorIdentities, d as juniorDestinations, l as juniorUsers, s as juniorConversations } from "./agent-invocations-C1RNOCs8.js";
-import { C as juniorCodeRepositories, S as juniorCodeChanges, g as juniorConversationBriefs, i as juniorWorkspaces, m as juniorConversationParticipants, n as juniorSnapshots, r as juniorWorkspaceRepos, w as juniorAttachments, x as juniorConversationAnnotations, y as juniorConversationEvents } from "./executor-4vhvsMZJ.js";
-import { o as decodeStoredConversationEvent } from "./history-C84mlAwO.js";
-import { _ as CredentialUnavailableError, a as resolveAuthTokenPlaceholder, h as credentialSubjectSchema, m as credentialLogContext, o as resolvePluginCommandEnv, p as credentialContextSchema } from "./registry-BgecKva0.js";
-import { n as pluginCatalogRuntime } from "./catalog-runtime-BD9GSpc6.js";
-import { c as withLock, i as getStateAdapter, o as acquireActiveLock, r as getDefaultRedisStateAdapterFor } from "./adapter-04AcD2SO.js";
+import { C as juniorCodeRepositories, S as juniorCodeChanges, a as juniorReviewItemAssignees, c as juniorReviewItems, d as juniorAutomations, g as juniorConversationBriefs, i as juniorWorkspaces, m as juniorConversationParticipants, n as juniorSnapshots, o as juniorReviewItemConversations, r as juniorWorkspaceRepos, w as juniorAttachments, x as juniorConversationAnnotations, y as juniorConversationEvents } from "./executor-BB6eJkD4.js";
+import { l as decodeStoredConversationEvent } from "./media-U6Tuz6Mi.js";
+import { _ as CredentialUnavailableError, a as resolveAuthTokenPlaceholder, h as credentialSubjectSchema, m as credentialLogContext, o as resolvePluginCommandEnv, p as credentialContextSchema } from "./registry-CndmkP2P.js";
+import { n as pluginCatalogRuntime } from "./catalog-runtime-Bdym_wKy.js";
+import { r as acquireActiveLock } from "./locks-D-0h111u.js";
+import { n as getDefaultRedisStateAdapterFor, r as getStateAdapter } from "./adapter-BQNTKVTF.js";
 import { i as isValidTimeZone } from "./cadence-R7Em4RjE.js";
-import { C as conversationReportEventSchema, Q as parseBriefInput, W as readMessageAttachments, Z as conversationBriefSchema, w as conversationReportMessageEventSchema, z as readMessageCardRefs } from "./conversation-DSo310Ps.js";
-import { n as briefEntriesFromReportEvents, s as generateBrief, t as BRIEF_PROMPT } from "./prompt-BW9jFsqZ.js";
+import { C as conversationReportEventSchema, J as conversationBriefSchema, W as readMessageAttachments, Y as parseBriefInput, w as conversationReportMessageEventSchema, z as readMessageCardRefs } from "./conversation-AhOVzN_k.js";
+import { n as briefEntriesFromReportEvents, s as generateBrief, t as BRIEF_PROMPT } from "./prompt-BPSdXYXV.js";
 import path from "node:path";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { z } from "zod";
 import { createHash, createHmac, createPrivateKey, createPublicKey, generateKeyPairSync, randomBytes, randomUUID, sign, timingSafeEqual } from "node:crypto";
-import { and, arrayContains, asc, desc, eq, exists, getTableColumns, gte, inArray, isNotNull, isNull, lt, lte, max, ne, notExists, or, sql } from "drizzle-orm";
+import { and, arrayContains, asc, count, desc, eq, exists, getTableColumns, gte, ilike, inArray, isNotNull, isNull, lt, lte, max, ne, notExists, or, sql } from "drizzle-orm";
 import { EgressAuthRequired, EgressPolicyDenied, actorSchema, codeChangeInputSchema, conversationAnnotationInputSchema, conversationEventPresentationSchema, defineConversationEvent, eventDataSchema, eventInputSchema, eventMatchSchema, eventMatches, eventTypeSchema, missingToolAnnotationKeys, normalizeEventIdentifier, objectAnnotationSchema, objectIconPath, objectTypeSchema, pluginAuthorizationSchema, pluginCredentialHeaderTransformSchema, pluginCredentialResultSchema, pluginEventsSchema, pluginGrantSchema, pluginProviderAccountSchema, pluginStoredTokensSchema, promptContextSchema, promptMessageSchema, sourceSchema, stableEventMatchKey } from "@sentry/junior-plugin-api";
 import { alias, union } from "drizzle-orm/pg-core";
 import fs from "node:fs/promises";
@@ -166,39 +167,6 @@ function renderJuniorNativeConversationEvent(args) {
 	const presentation = definition.renderEvent(definition.parse(args.content));
 	return presentation === void 0 ? void 0 : conversationEventPresentationSchema.parse(presentation);
 }
-// src/chat/state/cache.ts
-const MAX_CACHE_KEY_LENGTH = 512;
-const LOAD_WAIT_MS = 1e4;
-/**
-* Create a cache in the state adapter under `junior:cache:{namespace}:`.
-* Entries are wrapped, so `null` and `false` values are cache hits.
-*/
-function createCache(state, namespace) {
-	return { async getOrLoad(key, load, options) {
-		if (!key.trim()) throw new Error("Cache key is required");
-		if (key.length > MAX_CACHE_KEY_LENGTH) throw new Error("Cache key exceeds the maximum length");
-		const cacheKey = `junior:cache:${namespace}:${key}`;
-		const cached = async () => options?.refresh ? void 0 : await state.get(cacheKey) ?? void 0;
-		await state.connect();
-		const hit = await cached();
-		if (hit) return hit.value;
-		const attempt = await withLock(state, `${cacheKey}:load`, async () => {
-			const loadedMeanwhile = await cached();
-			if (loadedMeanwhile) return loadedMeanwhile.value;
-			const entry = await load();
-			if (entry.ttlMs !== void 0) {
-				if (!(entry.ttlMs > 0)) throw new Error("Cache ttlMs must be positive");
-				await state.set(cacheKey, { value: entry.value }, entry.ttlMs);
-			}
-			return entry.value;
-		}, {
-			keepAlive: true,
-			waitMs: LOAD_WAIT_MS
-		});
-		if (attempt.acquired) return attempt.value;
-		return (await load()).value;
-	} };
-}
 // src/chat/plugins/cache.ts
 /** Create the cache scoped to one plugin. */
 function createPluginCache(plugin) {
@@ -214,6 +182,8 @@ const slackUserInfoSchema = z.object({
 		tz: z.string().nullish(),
 		profile: z.object({
 			email: z.string().nullish(),
+			image_512: z.string().nullish(),
+			is_custom_image: z.boolean().nullish(),
 			real_name: z.string().nullish()
 		}).optional()
 	})
@@ -258,10 +228,14 @@ async function lookupSlackUser(teamId, userId) {
 		const parsed = slackUserInfoSchema.safeParse(await response.json());
 		if (!parsed.success) return null;
 		const payload = parsed.data;
+		const userName = payload.user.name?.trim() || void 0;
+		const fullName = payload.user.profile?.real_name?.trim() || void 0;
+		const avatarUrl = payload.user.profile?.is_custom_image ? parseAvatarUrl(payload.user.profile.image_512, "slack") : void 0;
 		const result = {
-			userName: payload.user.name?.trim() || void 0,
-			fullName: payload.user.profile?.real_name?.trim() || void 0,
+			userName,
+			fullName,
 			email: payload.user.profile?.email?.trim() || void 0,
+			...avatarUrl ? { avatarUrl } : void 0,
 			timezone: payload.user.tz?.trim() || void 0
 		};
 		writeToCache(teamId, userId, result);
@@ -1784,17 +1758,22 @@ function createPluginModel(pluginName, options = {}, runtime = {}) {
 }
 /** Create the host-owned embedding capability exposed to prompt hooks. */
 function createPluginEmbedder(pluginName, runtime = {}) {
-	return { async embedTexts(input) {
-		return await embedTexts({
-			modelId: botConfig.embeddingModelId,
-			texts: input.texts,
-			signal: runtime.signal,
-			metadata: {
-				pluginName,
-				pluginModelRole: "embedding"
-			}
-		});
-	} };
+	return {
+		model: botConfig.embeddingModelId,
+		provider: GEN_AI_PROVIDER_NAME,
+		async embedTexts(input) {
+			return await embedTexts({
+				modelId: botConfig.embeddingModelId,
+				texts: input.texts,
+				...input.inputType !== void 0 ? { inputType: input.inputType } : void 0,
+				signal: runtime.signal,
+				metadata: {
+					pluginName,
+					pluginModelRole: "embedding"
+				}
+			});
+		}
+	};
 }
 // src/chat/plugins/state.ts
 const MAX_PLUGIN_STATE_KEY_LENGTH = 512;
@@ -3085,19 +3064,6 @@ function getSlackToolContext(context) {
 		threadTs: parseSlackMessageTs(location.threadTs)
 	};
 }
-/**
-* Return whether a person started this Turn with a Slack message.
-*
-* Only these Turns act with that person's Slack authority. Event, automation,
-* Agent invocation, and dashboard Turns in the same Conversation do not.
-*/
-function isSlackMessageTurn(context) {
-	return context.source.kind === "slack" && context.destination.platform === "slack" && context.actor?.platform === "slack" && context.actor.teamId === context.source.teamId;
-}
-/** Disable reason for tools that need a Slack message Turn. */
-function slackMessageTurnDisabledReason(context) {
-	return isSlackMessageTurn(context) ? void 0 : "It needs a Turn that a person started with a Slack message.";
-}
 // src/chat/slack/tool-support/channel-capabilities.ts
 /** Resolve channel capabilities from a Slack channel ID. */
 function resolveChannelCapabilities(channelId) {
@@ -5565,6 +5531,24 @@ async function deleteWorkspaceSnapshotBuilders$1(names) {
 	}
 	if (failures.length > 0) throw failures[0];
 }
+const DOCKER_SNAPSHOT_PACKAGES = /* @__PURE__ */ new Set([
+	"spal-release",
+	"ripgrep",
+	"gh",
+	"jq"
+]);
+/**
+* Keep only the small Docker base from the declared runtime dependencies.
+*
+* Postinstall commands are skipped, because they often download large tools.
+* A base package that no plugin declares is not installed.
+*/
+function selectSnapshotRuntime(runtime) {
+	return {
+		dependencies: runtime.dependencies.filter((dependency) => "package" in dependency && DOCKER_SNAPSHOT_PACKAGES.has(dependency.package)),
+		postinstall: []
+	};
+}
 /** Local Docker implementation of the sandbox provider contract. */
 const dockerSandboxProvider = {
 	errors: dockerSandboxErrors,
@@ -5572,7 +5556,8 @@ const dockerSandboxProvider = {
 	getSession,
 	createWorkspaceSnapshotBuilder: createWorkspaceSnapshotBuilder$1,
 	getWorkspaceSnapshotBuilder: getWorkspaceSnapshotBuilder$1,
-	deleteWorkspaceSnapshotBuilders: deleteWorkspaceSnapshotBuilders$1
+	deleteWorkspaceSnapshotBuilders: deleteWorkspaceSnapshotBuilders$1,
+	selectSnapshotRuntime
 };
 // src/chat/sandbox/vercel/credentials.ts
 /**
@@ -7092,9 +7077,12 @@ function workspaceRecipe(workspace) {
 }
 /** Build the complete profile that selects one reusable sandbox snapshot. */
 function create(runtime, workspace) {
-	const dependencies = mergeDependencies([...GLOBAL_RUNTIME_DEPENDENCIES, ...pluginCatalogRuntime.getRuntimeDependencies()]);
-	const pluginPostinstall = pluginCatalogRuntime.getRuntimePostinstall();
-	const postinstall = [...GLOBAL_RUNTIME_POSTINSTALL, ...pluginPostinstall];
+	const declared = {
+		dependencies: mergeDependencies([...GLOBAL_RUNTIME_DEPENDENCIES, ...pluginCatalogRuntime.getRuntimeDependencies()]),
+		postinstall: [...GLOBAL_RUNTIME_POSTINSTALL, ...pluginCatalogRuntime.getRuntimePostinstall()]
+	};
+	const { dependencies, postinstall } = getSandboxProvider().selectSnapshotRuntime?.(declared) ?? declared;
+	const pluginPostinstall = postinstall.filter((command) => !GLOBAL_RUNTIME_POSTINSTALL.includes(command));
 	if (dependencies.length === 0 && postinstall.length === 0 && !workspace) return null;
 	const rebuildEpoch = process.env.SANDBOX_SNAPSHOT_REBUILD_EPOCH?.trim() ?? "";
 	const floating = dependencies.some((dependency) => isFloating(dependency)) || pluginPostinstall.length > 0 || Boolean(workspace);
@@ -7552,6 +7540,488 @@ function createCodeChangePublisher(provider) {
 		}
 	};
 }
+// src/chat/review-items/assignees.ts
+/** Text that the agent writes to assign Everyone. */
+const EVERYONE_ASSIGNEE = "everyone";
+/**
+* Resolve one assignee: Everyone, an email, or a mention. A mention must be
+* in the tenant of the item.
+*/
+async function resolveAssignee(db, value, tenant, findMentionedUserId) {
+	const text = value.trim();
+	if (text.toLowerCase() === "everyone") return { everyone: true };
+	const mentionedUserId = await findMentionedUserId(text, tenant);
+	if (mentionedUserId) return { userId: mentionedUserId };
+	if (text.includes("@")) {
+		const user = await findUserByEmailFromSql(db, text);
+		if (!user) throw new ToolInputError(`No Junior user has the email ${text}.`);
+		return { userId: user.id };
+	}
+	throw new ToolInputError(`Unknown assignee ${JSON.stringify(text)}. Use ${EVERYONE_ASSIGNEE}, an email, or a mention such as <@U123>.`);
+}
+/** Resolve the assignees of a Review item. One is required. */
+async function resolveAssignees(db, values, tenant, findMentionedUserId) {
+	if (values.length === 0) throw new ToolInputError("A review item needs at least one assignee.");
+	const resolved = await Promise.all(values.map((value) => resolveAssignee(db, value, tenant, findMentionedUserId)));
+	return {
+		everyone: resolved.some((assignee) => "everyone" in assignee),
+		userIds: [...new Set(resolved.flatMap((assignee) => "userId" in assignee ? [assignee.userId] : []))]
+	};
+}
+/** Return which of the Users take part in one root Conversation. */
+async function conversationParticipantUserIds(db, rootConversationId, userIds) {
+	if (userIds.length === 0) return /* @__PURE__ */ new Set();
+	const rows = await db.select({ userId: juniorConversationParticipants.userId }).from(juniorConversationParticipants).where(and(eq(juniorConversationParticipants.rootConversationId, rootConversationId), inArray(juniorConversationParticipants.userId, [...userIds])));
+	return new Set(rows.map((row) => row.userId));
+}
+/** Return the User who created an Automation, if Junior knows them. */
+async function automationCreatorUserId(db, automationId) {
+	const [row] = await db.select({ userId: juniorIdentities.userId }).from(juniorAutomations).innerJoin(juniorIdentities, eq(juniorIdentities.id, juniorAutomations.creatorIdentityId)).where(eq(juniorAutomations.id, automationId)).limit(1);
+	return row?.userId ?? void 0;
+}
+// src/chat/review-items/access.ts
+/** Return whether two tenants are the same. Two missing tenants match. */
+function isSameTenant(a, b) {
+	return a?.provider === b?.provider && a?.providerTenantId === b?.providerTenantId;
+}
+/**
+* The reader for one person: items assigned to them, and public items in the
+* provider tenants of their identities.
+*/
+function reviewItemReaderForUser(user) {
+	return {
+		tenants: user.identities.flatMap((identity) => identity.providerTenantId ? [{
+			provider: identity.provider,
+			providerTenantId: identity.providerTenantId
+		}] : []),
+		userId: user.id
+	};
+}
+/** SQL: the Review item has this assigned User. */
+function reviewItemAssignedTo(userId) {
+	return sql`exists (select 1 from ${juniorReviewItemAssignees} where ${juniorReviewItemAssignees.itemId} = ${juniorReviewItems.id} and ${juniorReviewItemAssignees.userId} = ${userId})`;
+}
+/**
+* SQL: the Review item needs this User. Only an open `action` item that is
+* assigned to the User needs them. A notice, an item for Everyone, and an
+* item without assignees need no one. An assigned User can always see the
+* item, so this rule needs no visibility check. The nav count and the
+* "Waiting on you" marker use this rule.
+*/
+function reviewItemNeedsUser(userId) {
+	return and(eq(juniorReviewItems.status, "open"), eq(juniorReviewItems.kind, "action"), reviewItemAssignedTo(userId));
+}
+/** SQL: the Review item links this Conversation. */
+function reviewItemLinkedTo(conversationId) {
+	return sql`exists (select 1 from ${juniorReviewItemConversations} where ${juniorReviewItemConversations.itemId} = ${juniorReviewItems.id} and ${juniorReviewItemConversations.conversationId} = ${conversationId})`;
+}
+function publicIn(tenants) {
+	return tenants.map((tenant) => and(eq(juniorReviewItems.visibility, "public"), eq(juniorReviewItems.provider, tenant.provider), eq(juniorReviewItems.providerTenantId, tenant.providerTenantId)));
+}
+/**
+* SQL form of `canReadReviewItem`, for search. Keep the two the same; the
+* Review item access test checks that they agree.
+*/
+function reviewItemVisibleTo(reader) {
+	return or(sql`false`, ...publicIn(reader.tenants ?? []), ...reader.userId ? [reviewItemAssignedTo(reader.userId)] : [], ...reader.conversationId ? [reviewItemLinkedTo(reader.conversationId)] : [], ...reader.automationId ? [eq(juniorReviewItems.automationId, reader.automationId)] : []);
+}
+/** Return whether a reader can see one Review item. */
+function canReadReviewItem(item, reader) {
+	return item.visibility === "public" && item.tenant !== void 0 && (reader.tenants ?? []).some((tenant) => isSameTenant(tenant, item.tenant)) || reader.userId !== void 0 && item.assignees.some((assignee) => assignee.userId === reader.userId) || reader.conversationId !== void 0 && item.conversationIds.includes(reader.conversationId) || reader.automationId !== void 0 && item.automationId === reader.automationId;
+}
+/**
+* Read the scope of an agent. The agent reads as its Conversation and
+* Automation, not as its Actor: an assignment lets a person see the item on
+* the review desk, not let an agent read it into another Conversation.
+*/
+async function readReviewItemAgentScope(context) {
+	const user = (await context.resolveActorIdentity?.())?.user;
+	const automationId = context.source.kind === "scheduled_automation" || context.source.kind === "event_automation" ? context.source.automationId : void 0;
+	const current = (await readConversationAccessFromSql(getDb(), [context.conversationId], user)).get(context.conversationId);
+	const tenant = current?.tenant;
+	return {
+		inPrivateConversation: current?.visibility !== "public",
+		reader: {
+			conversationId: context.conversationId,
+			...automationId ? { automationId } : void 0,
+			...tenant ? { tenants: [tenant] } : void 0
+		},
+		...tenant ? { tenant } : void 0,
+		...user ? { user } : void 0
+	};
+}
+/**
+* Dedupe keys with this prefix belong to plugins. Only the plugin that added
+* the item, or a person, can change it. An agent cannot use the prefix.
+*/
+const PLUGIN_REVIEW_ITEM_KEY_PREFIX = "plugin:";
+/**
+* Whether an agent can change an item. Only an agent in the tenant of the
+* item can change it. A public item changes only from a public
+* Conversation, so private content never reaches its readers. A private
+* item changes only from the Conversation or Automation that added it. An
+* agent never changes an item that a plugin added.
+*/
+function canAgentChangeReviewItem(item, scope) {
+	if (item.dedupeKey.startsWith("plugin:")) return false;
+	if (!isSameTenant(item.tenant, scope.tenant)) return false;
+	if (item.visibility === "public") return !scope.inPrivateConversation;
+	return item.addedByConversationId === scope.reader.conversationId || scope.reader.automationId !== void 0 && item.automationId === scope.reader.automationId;
+}
+/**
+* Check the Conversations that an agent links. Every link must be in the
+* tenant of the item. `allowedIds` (the current Conversation and the links
+* that the item already has) always pass. A private item gets no other
+* links. A public item can get other links only to public Conversations.
+*/
+async function requireReviewItemLinks(args) {
+	const access = await readConversationAccessFromSql(getDb(), args.conversationIds, args.scope.user);
+	for (const conversationId of args.conversationIds) {
+		const conversation = access.get(conversationId);
+		if (!conversation || !isSameTenant(conversation.tenant, args.tenant)) throw new ToolInputError(`Conversation ${conversationId} is not found.`);
+		if (args.allowedIds.has(conversationId)) continue;
+		if (args.visibility === "private") throw new ToolInputError("A private item links only to the Conversation that added it.");
+		if (conversation.visibility !== "public") throw new ToolInputError(conversation.canViewPrivateContent ? `Conversation ${conversationId} is private. Only public Conversations can be linked.` : `Conversation ${conversationId} is not found.`);
+	}
+}
+/**
+* Check who an agent assigns a private item to. It cannot go to Everyone.
+* Each User must be the current Actor, a person in one of the given
+* Conversations (the current one and, for an existing item, the one that
+* added it), or the creator of the Automation that added the item. An
+* Automation run often has no Actor and no people yet, and its creator wrote
+* the work. A public item can go to anyone.
+*/
+async function requireReviewItemAssignees(args) {
+	if (args.visibility === "public") return;
+	if (args.assignees.everyone) throw new ToolInputError("A private item cannot be assigned to Everyone. Assign Users instead.");
+	const creatorId = args.automationId ? await automationCreatorUserId(getDb(), args.automationId) : void 0;
+	const others = args.assignees.userIds.filter((id) => id !== args.scope.user?.id && id !== creatorId);
+	const inConversation = /* @__PURE__ */ new Set();
+	for (const conversationId of new Set(args.conversationIds)) for (const id of await conversationParticipantUserIds(getDb(), conversationId, others)) inConversation.add(id);
+	if (others.some((id) => !inConversation.has(id))) throw new ToolInputError("A private item can be assigned only to people in its Conversation.");
+}
+/**
+* Return whether a User can act on an open Review item: an assigned User,
+* anyone for an item assigned to Everyone, and anyone for an item with no
+* assignees. The caller checks that the User can see the item.
+*/
+function canActOnReviewItem(item, userId) {
+	if (item.status !== "open") return false;
+	if (item.assignedToEveryone) return true;
+	if (item.assignees.length === 0) return true;
+	return item.assignees.some((assignee) => assignee.userId === userId);
+}
+/** Return whether a User is already the only assignee, so take does nothing. */
+function isOnlyAssignee(item, userId) {
+	return !item.assignedToEveryone && item.assignees.length === 1 && item.assignees[0]?.userId === userId;
+}
+// src/chat/review-items/store.ts
+/**
+* Close reason of an action item that a person answered with a reply in
+* its thread instead of on the card or the review desk.
+*/
+const REVIEW_ITEM_REPLIED_REASON = "Replied in thread";
+async function readUsers(db, userIds) {
+	if (userIds.length === 0) return /* @__PURE__ */ new Map();
+	const rows = await db.select({
+		displayName: juniorUsers.displayName,
+		email: juniorUsers.primaryEmail,
+		userId: juniorUsers.id
+	}).from(juniorUsers).where(inArray(juniorUsers.id, [...new Set(userIds)]));
+	return new Map(rows.map((row) => [row.userId, {
+		email: row.email,
+		userId: row.userId,
+		...row.displayName ? { displayName: row.displayName } : void 0
+	}]));
+}
+async function hydrate(db, rows) {
+	if (rows.length === 0) return [];
+	const ids = rows.map((row) => row.id);
+	const [assigneeRows, conversationRows] = await Promise.all([db.select().from(juniorReviewItemAssignees).where(inArray(juniorReviewItemAssignees.itemId, ids)), db.select().from(juniorReviewItemConversations).where(inArray(juniorReviewItemConversations.itemId, ids))]);
+	const users = await readUsers(db, [...assigneeRows.map((row) => row.userId), ...rows.flatMap((row) => row.closedByUserId ? [row.closedByUserId] : [])]);
+	return rows.map((row) => {
+		const closedBy = row.closedByUserId ? users.get(row.closedByUserId) : void 0;
+		return {
+			addedByConversationId: row.addedByConversationId,
+			assignedToEveryone: row.assignedToEveryone,
+			assignees: assigneeRows.filter((assignee) => assignee.itemId === row.id).flatMap((assignee) => users.get(assignee.userId) ?? []).sort((a, b) => a.email.localeCompare(b.email)),
+			body: row.body,
+			conversationIds: conversationRows.filter((link) => link.itemId === row.id).map((link) => link.conversationId).sort(),
+			createdAt: row.createdAt,
+			dedupeKey: row.dedupeKey,
+			id: row.id,
+			kind: row.kind,
+			status: row.status,
+			title: row.title,
+			updatedAt: row.updatedAt,
+			visibility: row.visibility,
+			...row.answer ? { answer: row.answer } : void 0,
+			...row.automationId ? { automationId: row.automationId } : void 0,
+			...row.closeReason ? { closeReason: row.closeReason } : void 0,
+			...row.closedAt ? { closedAt: row.closedAt } : void 0,
+			...closedBy ? { closedBy } : void 0,
+			...row.request ? { request: row.request } : void 0,
+			...row.provider && row.providerTenantId ? { tenant: {
+				provider: row.provider,
+				providerTenantId: row.providerTenantId
+			} } : void 0,
+			...row.subjectId ? { subject: {
+				id: row.subjectId,
+				...row.subjectTitle ? { title: row.subjectTitle } : void 0,
+				...row.subjectUrl ? { url: row.subjectUrl } : void 0
+			} } : void 0
+		};
+	});
+}
+function contentColumns(content) {
+	return {
+		assignedToEveryone: content.assignedToEveryone,
+		body: content.body,
+		kind: content.kind,
+		request: content.request ?? null,
+		subjectId: content.subject?.id ?? null,
+		subjectTitle: content.subject?.title ?? null,
+		subjectUrl: content.subject?.url ?? null,
+		title: content.title,
+		visibility: content.visibility
+	};
+}
+async function replaceLinks(db, itemId, content) {
+	await db.delete(juniorReviewItemAssignees).where(eq(juniorReviewItemAssignees.itemId, itemId));
+	await db.delete(juniorReviewItemConversations).where(eq(juniorReviewItemConversations.itemId, itemId));
+	const userIds = [...new Set(content.assigneeUserIds)];
+	if (userIds.length > 0) await db.insert(juniorReviewItemAssignees).values(userIds.map((userId) => ({
+		itemId,
+		userId
+	})));
+	const conversationIds = [...new Set(content.conversationIds)];
+	if (conversationIds.length > 0) await db.insert(juniorReviewItemConversations).values(conversationIds.map((conversationId) => ({
+		itemId,
+		conversationId
+	})));
+}
+/** Read one Review item by id. */
+async function getReviewItem(db, id) {
+	return (await hydrate(db, await db.select().from(juniorReviewItems).where(eq(juniorReviewItems.id, id))))[0];
+}
+/**
+* Read the action items that the agent added in one Conversation and that a
+* reply can answer: the open items, and the items that a reply closed.
+*/
+async function listReplyActionItems(db, conversationId) {
+	return await hydrate(db, await db.select().from(juniorReviewItems).where(and(eq(juniorReviewItems.addedByConversationId, conversationId), eq(juniorReviewItems.kind, "action"), or(eq(juniorReviewItems.status, "open"), eq(juniorReviewItems.closeReason, REVIEW_ITEM_REPLIED_REASON)))));
+}
+/**
+* Read the open Review item with one dedupe key in one provider tenant, if
+* there is one. Dedupe keys are unique only inside a tenant.
+*/
+async function getOpenReviewItemByDedupeKey(db, dedupeKey, tenant) {
+	return (await hydrate(db, await db.select().from(juniorReviewItems).where(and(eq(juniorReviewItems.dedupeKey, dedupeKey), eq(juniorReviewItems.status, "open"), tenant ? and(eq(juniorReviewItems.provider, tenant.provider), eq(juniorReviewItems.providerTenantId, tenant.providerTenantId)) : isNull(juniorReviewItems.provider)))))[0];
+}
+/**
+* Add one open Review item. Return undefined when another open item in the
+* same tenant already uses its dedupe key.
+*/
+async function insertReviewItem(db, input) {
+	const now = new Date(input.nowMs);
+	const id = await db.transaction(async (tx) => {
+		const inserted = await tx.insert(juniorReviewItems).values({
+			...contentColumns(input),
+			addedByConversationId: input.addedByConversationId,
+			automationId: input.automationId ?? null,
+			createdAt: now,
+			dedupeKey: input.dedupeKey,
+			id: randomUUID(),
+			provider: input.tenant?.provider ?? null,
+			providerTenantId: input.tenant?.providerTenantId ?? null,
+			status: "open",
+			updatedAt: now
+		}).onConflictDoNothing().returning({ id: juniorReviewItems.id });
+		if (!inserted[0]) return void 0;
+		await replaceLinks(tx, inserted[0].id, input);
+		return inserted[0].id;
+	});
+	if (!id) return void 0;
+	const item = await getReviewItem(db, id);
+	if (!item) throw new Error(`Review item ${id} is missing after insert`);
+	return item;
+}
+/** Replace the content of one open Review item. Return false when closed. */
+async function updateReviewItemContent(db, input) {
+	return await db.transaction(async (tx) => {
+		if (!(await tx.update(juniorReviewItems).set({
+			...contentColumns(input),
+			updatedAt: new Date(input.nowMs)
+		}).where(and(eq(juniorReviewItems.id, input.id), eq(juniorReviewItems.status, "open"))).returning({ id: juniorReviewItems.id }))[0]) return false;
+		await replaceLinks(tx, input.id, input);
+		return true;
+	});
+}
+/**
+* Close one open Review item. `closedByUserId` is the person who closed it,
+* and it is unset when an agent closes it. Return false when the item was
+* already closed, so only the first close wins.
+*/
+async function closeReviewItem(db, input) {
+	const now = new Date(input.nowMs);
+	return (await db.update(juniorReviewItems).set({
+		answer: input.answer ?? null,
+		closeReason: input.reason ?? null,
+		closedAt: now,
+		closedByUserId: input.closedByUserId ?? null,
+		status: input.status,
+		updatedAt: now
+	}).where(and(eq(juniorReviewItems.id, input.id), eq(juniorReviewItems.status, "open"))).returning({ id: juniorReviewItems.id })).length > 0;
+}
+/**
+* Dismiss the open Review items that an Automation or a set of
+* Conversations added, when no agent can act on them any more. No person
+* closes them. It sends no message and does not change the Slack cards. A
+* close by Conversations skips the items of an Automation, because a later
+* run of the Automation can still change them. An Automation delete closes
+* those.
+*/
+async function dismissOpenReviewItems(db, input) {
+	const now = new Date(input.nowMs);
+	await db.update(juniorReviewItems).set({
+		closeReason: input.reason,
+		closedAt: now,
+		status: "dismissed",
+		updatedAt: now
+	}).where(and(eq(juniorReviewItems.status, "open"), "automationId" in input ? eq(juniorReviewItems.automationId, input.automationId) : and(inArray(juniorReviewItems.addedByConversationId, [...input.addedByConversationIds]), isNull(juniorReviewItems.automationId))));
+}
+/**
+* Make one User the only assignee of an open Review item. Return false when
+* the item is closed.
+*/
+async function takeReviewItem(db, input) {
+	return await db.transaction(async (tx) => {
+		if (!(await tx.update(juniorReviewItems).set({
+			assignedToEveryone: false,
+			updatedAt: new Date(input.nowMs)
+		}).where(and(eq(juniorReviewItems.id, input.id), eq(juniorReviewItems.status, "open"))).returning({ id: juniorReviewItems.id }))[0]) return false;
+		await tx.delete(juniorReviewItemAssignees).where(eq(juniorReviewItemAssignees.itemId, input.id));
+		await tx.insert(juniorReviewItemAssignees).values({
+			itemId: input.id,
+			userId: input.userId
+		});
+		return true;
+	});
+}
+function searchConditions(reader, filters) {
+	const conditions = [reviewItemVisibleTo(reader), inArray(juniorReviewItems.status, [...filters.statuses])];
+	if (filters.after) conditions.push(or(lt(juniorReviewItems.updatedAt, filters.after.updatedAt), and(eq(juniorReviewItems.updatedAt, filters.after.updatedAt), lt(juniorReviewItems.id, filters.after.id))));
+	if (filters.subjectId) conditions.push(eq(juniorReviewItems.subjectId, filters.subjectId));
+	if (filters.automationId) conditions.push(eq(juniorReviewItems.automationId, filters.automationId));
+	if (filters.conversationId) conditions.push(reviewItemLinkedTo(filters.conversationId));
+	if (filters.assignee) conditions.push("everyone" in filters.assignee ? eq(juniorReviewItems.assignedToEveryone, true) : reviewItemAssignedTo(filters.assignee.userId));
+	if (filters.query) {
+		const pattern = `%${filters.query.replace(/[\\%_]/g, "\\$&")}%`;
+		conditions.push(or(ilike(juniorReviewItems.title, pattern), ilike(juniorReviewItems.body, pattern)));
+	}
+	return conditions;
+}
+/** Count the open Review items that need a User (`reviewItemNeedsUser`). */
+async function countReviewItemsNeedingUser(db, userId) {
+	return (await db.select({ count: count() }).from(juniorReviewItems).where(reviewItemNeedsUser(userId)))[0]?.count ?? 0;
+}
+/**
+* Find the Review items that a reader can see. Open items come first, so
+* the limit never drops an open item for a closed one. Then the newest
+* change comes first: `updated_at`, then `id`, both descending. `after`
+* pages through that order.
+*/
+async function searchReviewItems(db, reader, filters) {
+	return await hydrate(db, await db.select().from(juniorReviewItems).where(and(...searchConditions(reader, filters))).orderBy(desc(eq(juniorReviewItems.status, "open")), desc(juniorReviewItems.updatedAt), desc(juniorReviewItems.id)).limit(filters.limit));
+}
+/**
+* List the Conversations that wait on a User: each is linked to an open item
+* that needs the User (`reviewItemNeedsUser`).
+*/
+async function listWaitingConversationIds(db, userId) {
+	return (await db.selectDistinct({ conversationId: juniorReviewItemConversations.conversationId }).from(juniorReviewItemConversations).innerJoin(juniorReviewItems, eq(juniorReviewItems.id, juniorReviewItemConversations.itemId)).where(reviewItemNeedsUser(userId))).map((row) => row.conversationId).sort();
+}
+// src/chat/review-items/plugin.ts
+/**
+* Resolve the Users to assign. An Identity without a User has no one to
+* assign. A private item goes only to people in its Conversation, the same
+* rule that `requireReviewItemAssignees` applies to agents.
+*/
+async function assigneeUserIds(db, identityIds, conversationId, isPrivate) {
+	const userIds = [];
+	for (const identityId of new Set(identityIds)) {
+		const user = (await readIdentityByIdFromSql(db, identityId))?.user;
+		if (!user) continue;
+		if (isPrivate && !(await readConversationAccessFromSql(db, [conversationId], user)).get(conversationId)?.isParticipant) throw new Error("A private review item can be assigned only to people in its Conversation");
+		userIds.push(user.id);
+	}
+	return userIds;
+}
+/**
+* Connect a plugin to the review desk for one Conversation. Dedupe keys are
+* `plugin:<name>:<key>`, so a plugin changes only its own items, and agents
+* cannot change them. A change sends no message to the Conversation. It
+* only shows the new state through `show`. An item is private when the
+* Conversation is not public.
+*/
+function createPluginReviewItems(args) {
+	const { conversationId, show } = args;
+	const scopedKey = (dedupeKey) => `${PLUGIN_REVIEW_ITEM_KEY_PREFIX}${args.plugin}:${dedupeKey}`;
+	const readAccess = async (db) => {
+		const access = (await readConversationAccessFromSql(db, [conversationId])).get(conversationId);
+		if (!access) throw new Error(`Conversation ${conversationId} is not found`);
+		return access;
+	};
+	return {
+		async upsert(notice) {
+			const db = getDb();
+			const access = await readAccess(db);
+			const existing = await getOpenReviewItemByDedupeKey(db, scopedKey(notice.dedupeKey), access.tenant);
+			const isPrivate = access.visibility !== "public" || existing?.visibility === "private";
+			if (existing && isPrivate && existing.addedByConversationId !== conversationId) throw new Error("A private review item links only to the Conversation that added it");
+			const content = {
+				assignedToEveryone: false,
+				assigneeUserIds: await assigneeUserIds(db, notice.assigneeIdentityIds, conversationId, isPrivate),
+				body: notice.body,
+				conversationIds: [.../* @__PURE__ */ new Set([conversationId, ...existing?.conversationIds ?? []])],
+				kind: "notice",
+				title: notice.title,
+				visibility: isPrivate ? "private" : "public",
+				...notice.subject ? { subject: notice.subject } : void 0
+			};
+			if (existing) {
+				await updateReviewItemContent(db, {
+					...content,
+					id: existing.id,
+					nowMs: Date.now()
+				});
+				await show(existing.id);
+				return;
+			}
+			const item = await insertReviewItem(db, {
+				...content,
+				addedByConversationId: conversationId,
+				dedupeKey: scopedKey(notice.dedupeKey),
+				nowMs: Date.now(),
+				...access.tenant ? { tenant: access.tenant } : void 0
+			});
+			if (item) await show(item.id);
+		},
+		async close(input) {
+			const db = getDb();
+			const access = await readAccess(db);
+			const item = await getOpenReviewItemByDedupeKey(db, scopedKey(input.dedupeKey), access.tenant);
+			if (!item) return;
+			if (await closeReviewItem(db, {
+				id: item.id,
+				nowMs: Date.now(),
+				reason: input.reason,
+				status: input.status
+			})) await show(item.id);
+		}
+	};
+}
 // src/chat/briefs/registration.ts
 var registration_exports = /* @__PURE__ */ __exportAll({
 	coreTaskRegistrations: () => coreTaskRegistrations,
@@ -7712,6 +8182,13 @@ function pluginMcpContext(plugin, context) {
 		}
 	};
 }
+/** Time one plugin hook call so slow plugins show up in turn traces. */
+async function withPluginHookSpan(pluginName, hookName, callback) {
+	return await withSpan(`plugin.hook ${hookName}`, "plugin.hook", {}, callback, {
+		"app.plugin.name": pluginName,
+		"app.plugin.hook": hookName
+	});
+}
 function safeErrorMessage(error) {
 	return error instanceof Error ? error.message : String(error);
 }
@@ -7859,7 +8336,7 @@ async function getPluginUserPromptContributions(args) {
 		const hook = plugin.hooks?.userPrompt;
 		if (!hook) continue;
 		try {
-			const rawResult = await hook({ ...invocationPluginContext(plugin, args.context, args.turnId) });
+			const rawResult = await withPluginHookSpan(pluginName, "userPrompt", async () => await hook({ ...invocationPluginContext(plugin, args.context, args.turnId) }));
 			if (rawResult === void 0) continue;
 			if (!Array.isArray(rawResult)) {
 				logInvalidPromptContributions({
@@ -8096,6 +8573,11 @@ function getPluginRoutes(options) {
 				plugin: pluginName
 			}) },
 			codeChanges: createCodeChangePublisher(pluginName),
+			reviewItems: { forConversation: (conversationId) => createPluginReviewItems({
+				conversationId,
+				plugin: pluginName,
+				show: options.showReviewItem ?? (async () => {})
+			}) },
 			users: { readIdentity: readIdentityById },
 			events: {
 				async hasMatch(event) {
@@ -8502,11 +8984,11 @@ function createPluginHookRunner(input = {}) {
 				const hook = plugin.hooks?.sandboxPrepare;
 				if (!hook) continue;
 				logInfo("agent.plugin.sandbox_preparation.started", { "app.plugin.name": pluginName });
-				await hook({
+				await withPluginHookSpan(pluginName, "sandboxPrepare", async () => await hook({
 					...basePluginContext$1(plugin),
 					actor: input.actor,
 					sandbox: sandboxCapability
-				});
+				}));
 			}
 		},
 		async beforeToolExecute(tool) {
@@ -8519,7 +9001,7 @@ function createPluginHookRunner(input = {}) {
 				if (!hook) continue;
 				let replacement;
 				let blocked;
-				await hook({
+				await withPluginHookSpan(pluginName, "beforeToolExecute", async () => await hook({
 					...basePluginContext$1(plugin),
 					actor: input.actor,
 					actors,
@@ -8548,7 +9030,7 @@ function createPluginHookRunner(input = {}) {
 							replacement = input;
 						}
 					}
-				});
+				}));
 				if (blocked) throw blocked;
 				if (replacement !== void 0) {
 					if (!isRecord(replacement)) throw new Error(`Plugin "${pluginName}" replaced tool input with a non-object value`);
@@ -9483,4 +9965,4 @@ async function executeCredentialedEgressRequest(input) {
 		});
 	}
 }
-export { openSlackModal as $, recordSlackAttachment as $n, verifyTimerWatchCredentialSubject as $t, setWorkspaceSnapshotBuild as A, sandboxSkillDir as An, getSlackToolContext as At, parseOAuthStatePayload as B, conversationArchivedForUser as Bn, createTimerWatch as Bt, listWorkspaces as C, runNonInteractiveCommand as Cn, resolveSandboxCommandEnvironment as Ct, invalidateReadySnapshot as D, SANDBOX_REPOS_ROOT as Dn, tryWorkspaceRepoCheckoutPath as Dt, WorkspaceValidationError as E, SANDBOX_JUNIOR_ROOT as En, SANDBOX_RUNTIME as Et, getSandboxProvider as F, createPluginModel as Fn, RESOURCE_WATCH_TOOL_SOURCE as Ft, normalizeSlackReplyMarkdown as G, viewerConversationMembership as Gn, listWatches as Gt, startOAuthFlow as H, conversationIsMemberRoot as Hn, deliverWatch as Ht, isVercelSandboxEgressRequest as I, createPluginLogger as In, STOP_WATCHING_TOOL_NAME as It, truncateStatusText as J, readConversationEventPage as Jn, bindScheduledAutomationCredentialSubject as Jt, normalizeSlackStatusText as K, createPluginConversationEvents as Kn, takeDueTimerWatches as Kt, proxyVercelSandboxEgressRequest as L, readConversationAccessFromSql as Ln, cancelSubscriptions as Lt, hash as M, sandboxSkillPathResolution as Mn, slackMessageTurnDisabledReason as Mt, isStale as N, createPluginState as Nn, RESOURCE_SUBSCRIPTION_DEFAULT_TTL_MS as Nt, loadSnapshotsForProfile as O, SANDBOX_SKILLS_ROOT as On, workspaceRepoCheckoutPath as Ot, ensureDockerDaemon as P, createPluginEmbedder as Pn, RESOURCE_SUBSCRIPTION_MAX_TTL_MS as Pt, openSlackDirectMessage as Q, readAttachmentVisionSummary as Qn, verifySlackDirectCredentialSubject as Qt, deliverOAuthAuthorization as R, conversationArchiveTimes as Rn, cancelWatch as Rt, getWorkspaceByName as S, buildNonInteractiveShellScript as Sn, buildSandboxEgressNetworkPolicy as St, updateWorkspace as T, SANDBOX_DATA_ROOT as Tn, normalizeSandboxEgressTracePropagationDomains as Tt, escapeSlackMrkdwnText as U, conversationNotArchivedForEmail as Un, findMatchingWatches as Ut, resolveBaseUrl as V, conversationHasParticipantUser as Vn, createWatch as Vt, formatSlackLink as W, conversationNotArchivedForUser as Wn, getWatch as Wt, deleteSlackMessage as X, getSlackFileId as Xn, verifyEventAutomationCredentialSubject as Xt, addReactionToMessage as Y, buildSentryConversationUrl as Yn, bindSlackDirectCredentialSubject as Yt, getSlackMessagePermalink as Z, matchSlackAttachments as Zn, verifyScheduledAutomationCredentialSubject as Zt, registration_exports as _, getDashboardTaskLink as _n, consumeSandboxEgressPermissionDeniedSignal as _t, agent_hooks_exports as a, isConversationScopedChannel as an, defaultTimezone as ar, slackEntitySchema as at, deleteWorkspace as b, PluginToolDeniedError as bn, parseSandboxEgressAuthRequiredSignal as bt, getPluginRoutes as c, runWithSlackInstallationToken as cn, createPluginCache as cr, isAlreadyExistsError as ct, getPluginTools as d, getWorkspaceTeamId as dn, agentsInstructionsUpdatedEvent as dr, WorkspaceSnapshotNotReadyError as dt, SlackActionError as en, resolveRootVisibility as er, postSlackEphemeralMessage as et, getPluginUserPromptContributions as f, runWithWorkspaceTeamId as fn, authenticationLinkedEvent as fr, getWorkspaceSnapshotNotReadyError as ft, coreTaskRegistrations as g, getDashboardReviewItemLink as gn, consumeSandboxEgressAuthRequiredSignal as gt, validatePlugins as h, getDashboardObjectIconLink as hn, clearSandboxEgressSignals as ht, resolvePluginOAuthAccount as i, getSlackClient as in, listConversationAnnotationsById as ir, uploadFilesToConversation as it, create as j, sandboxSkillFile as jn, isSlackMessageTurn as jt, setWorkspaceSnapshot as k, SANDBOX_WORKSPACE_ROOT as kn, resolveChannelCapabilities as kt, getPluginSlackConversationLink as l, withSlackRetries as ln, createCache as lr, throwSandboxOperationError as lt, setPlugins as m, getDashboardConversationLink as mn, conversationNoteEvent as mr, workspaceSnapshotNotReadyUserMessage as mt, createUserTokenStore as n, getFilePermalink as nn, createPluginAnnotations as nr, removeReactionFromMessage as nt, createPluginHookRunner as o, isDmChannel as on, resolveUserTimezone as or, slackExternalRefIdSchema as ot, getPlugins as p, JUNIOR_THREAD_STATE_TTL_MS as pn, authenticationUnlinkedEvent as pr, isWorkspaceSnapshotNotReadyError as pt, slackMention as q, readLatestConversationBrief as qn, bindEventAutomationCredentialSubject as qt, getOAuthAccountProviders as r, getHeaderString as rn, listConversationAnnotations as rr, updateSlackMessage as rt, getPluginApiRoutes as s, normalizeSlackConversationId as sn, lookupSlackUser as sr, isAbortError as st, executeCredentialedEgressRequest as t, downloadPrivateSlackFile as tn, saveObjectAnnotations as tr, postSlackMessage as tt, getPluginSystemPromptContributions as u, sleep$1 as un, JUNIOR_NATIVE_EVENT_NAMESPACE as ur, wrapSandboxSetupError as ut, setBriefsConfig as v, setDashboardConversationLinkOptions as vn, createSandboxEgressCredentialToken as vt, listWorkspacesByRepository as w, SANDBOX_COMMAND_PATH as wn, resolveSandboxEgressProviderForHost as wt, getWorkspace as x, buildCommandScript as xn, sandboxEgressSignalsResponseSchema as xt, createWorkspace as y, ToolInputError as yn, parseSandboxEgressCredentialToken as yt, formatProviderLabel as z, conversationArchivedForEmail as zn, collectEventMatchKeys as zt };
+export { loadSnapshotsForProfile as $, sandboxSkillDir as $n, workspaceRepoCheckoutPath as $t, updateReviewItemContent as A, normalizeSlackConversationId as An, lookupSlackUser as Ar, slackEntitySchema as At, EVERYONE_ASSIGNEE as B, getDashboardTaskLink as Bn, clearSandboxEgressSignals as Bt, getOpenReviewItemByDedupeKey as C, SlackActionError as Cn, resolveRootVisibility as Cr, openSlackDirectMessage as Ct, listWaitingConversationIds as D, getSlackClient as Dn, listConversationAnnotationsById as Dr, removeReactionFromMessage as Dt, listReplyActionItems as E, getHeaderString as En, listConversationAnnotations as Er, postSlackMessage as Et, isOnlyAssignee as F, runWithWorkspaceTeamId as Fn, authenticationUnlinkedEvent as Fr, wrapSandboxSetupError as Ft, deleteWorkspace as G, buildNonInteractiveShellScript as Gn, parseSandboxEgressAuthRequiredSignal as Gt, resolveAssignee as H, ToolInputError as Hn, consumeSandboxEgressPermissionDeniedSignal as Ht, readReviewItemAgentScope as I, JUNIOR_THREAD_STATE_TTL_MS as In, conversationNoteEvent as Ir, WorkspaceSnapshotNotReadyError as It, listWorkspaces as J, SANDBOX_DATA_ROOT as Jn, resolveSandboxCommandEnvironment as Jt, getWorkspace as K, runNonInteractiveCommand as Kn, sandboxEgressSignalsResponseSchema as Kt, requireReviewItemAssignees as L, getDashboardConversationLink as Ln, getWorkspaceSnapshotNotReadyError as Lt, canActOnReviewItem as M, withSlackRetries as Mn, JUNIOR_NATIVE_EVENT_NAMESPACE as Mr, isAbortError as Mt, canAgentChangeReviewItem as N, sleep$1 as Nn, agentsInstructionsUpdatedEvent as Nr, isAlreadyExistsError as Nt, searchReviewItems as O, isConversationScopedChannel as On, defaultTimezone as Or, updateSlackMessage as Ot, canReadReviewItem as P, getWorkspaceTeamId as Pn, authenticationLinkedEvent as Pr, throwSandboxOperationError as Pt, invalidateReadySnapshot as Q, SANDBOX_WORKSPACE_ROOT as Qn, tryWorkspaceRepoCheckoutPath as Qt, requireReviewItemLinks as R, getDashboardObjectIconLink as Rn, isWorkspaceSnapshotNotReadyError as Rt, dismissOpenReviewItems as S, verifyTimerWatchCredentialSubject as Sn, recordSlackAttachment as Sr, getSlackMessagePermalink as St, insertReviewItem as T, getFilePermalink as Tn, createPluginAnnotations as Tr, postSlackEphemeralMessage as Tt, resolveAssignees as U, PluginToolDeniedError as Un, createSandboxEgressCredentialToken as Ut, automationCreatorUserId as V, setDashboardConversationLinkOptions as Vn, consumeSandboxEgressAuthRequiredSignal as Vt, createWorkspace as W, buildCommandScript as Wn, parseSandboxEgressCredentialToken as Wt, updateWorkspace as X, SANDBOX_REPOS_ROOT as Xn, normalizeSandboxEgressTracePropagationDomains as Xt, listWorkspacesByRepository as Y, SANDBOX_JUNIOR_ROOT as Yn, resolveSandboxEgressProviderForHost as Yt, WorkspaceValidationError as Z, SANDBOX_SKILLS_ROOT as Zn, SANDBOX_RUNTIME as Zt, registration_exports as _, bindScheduledAutomationCredentialSubject as _n, readConversationEventPage as _r, normalizeSlackStatusText as _t, agent_hooks_exports as a, STOP_WATCHING_TOOL_NAME as an, createPluginLogger as ar, ensureDockerDaemon as at, closeReviewItem as b, verifyScheduledAutomationCredentialSubject as bn, matchSlackAttachments as br, addReactionToMessage as bt, getPluginRoutes as c, collectEventMatchKeys as cn, conversationArchivedForEmail as cr, proxyVercelSandboxEgressRequest as ct, getPluginTools as d, deliverWatch as dn, conversationIsMemberRoot as dr, parseOAuthStatePayload as dt, resolveChannelCapabilities as en, sandboxSkillFile as er, setWorkspaceSnapshot as et, getPluginUserPromptContributions as f, findMatchingWatches as fn, conversationNotArchivedForEmail as fr, resolveBaseUrl as ft, coreTaskRegistrations as g, bindEventAutomationCredentialSubject as gn, readLatestConversationBrief as gr, normalizeSlackReplyMarkdown as gt, validatePlugins as h, takeDueTimerWatches as hn, createPluginConversationEvents as hr, formatSlackLink as ht, resolvePluginOAuthAccount as i, RESOURCE_WATCH_TOOL_SOURCE as in, createPluginModel as ir, isStale as it, PLUGIN_REVIEW_ITEM_KEY_PREFIX as j, runWithSlackInstallationToken as jn, createPluginCache as jr, slackExternalRefIdSchema as jt, takeReviewItem as k, isDmChannel as kn, resolveUserTimezone as kr, uploadFilesToConversation as kt, getPluginSlackConversationLink as l, createTimerWatch as ln, conversationArchivedForUser as lr, deliverOAuthAuthorization as lt, setPlugins as m, listWatches as mn, viewerConversationMembership as mr, escapeSlackMrkdwnText as mt, createUserTokenStore as n, RESOURCE_SUBSCRIPTION_DEFAULT_TTL_MS as nn, createPluginState as nr, create as nt, createPluginHookRunner as o, cancelSubscriptions as on, readConversationAccessFromSql as or, getSandboxProvider as ot, getPlugins as p, getWatch as pn, conversationNotArchivedForUser as pr, startOAuthFlow as pt, getWorkspaceByName as q, SANDBOX_COMMAND_PATH as qn, buildSandboxEgressNetworkPolicy as qt, getOAuthAccountProviders as r, RESOURCE_SUBSCRIPTION_MAX_TTL_MS as rn, createPluginEmbedder as rr, hash as rt, getPluginApiRoutes as s, cancelWatch as sn, conversationArchiveTimes as sr, isVercelSandboxEgressRequest as st, executeCredentialedEgressRequest as t, getSlackToolContext as tn, sandboxSkillPathResolution as tr, setWorkspaceSnapshotBuild as tt, getPluginSystemPromptContributions as u, createWatch as un, conversationHasParticipantUser as ur, formatProviderLabel as ut, setBriefsConfig as v, bindSlackDirectCredentialSubject as vn, buildSentryConversationUrl as vr, slackMention as vt, getReviewItem as w, downloadPrivateSlackFile as wn, saveObjectAnnotations as wr, openSlackModal as wt, countReviewItemsNeedingUser as x, verifySlackDirectCredentialSubject as xn, readAttachmentVisionSummary as xr, deleteSlackMessage as xt, REVIEW_ITEM_REPLIED_REASON as y, verifyEventAutomationCredentialSubject as yn, getSlackFileId as yr, truncateStatusText as yt, reviewItemReaderForUser as z, getDashboardReviewItemLink as zn, workspaceSnapshotNotReadyUserMessage as zt };