@sentry/junior 0.202.0 → 0.204.0

package/dist/chunk-U2GPUYAL.js

@@ -1,3656 +0,0 @@
-import {
-  JUNIOR_THREAD_STATE_TTL_MS
-} from "./chunk-3Y47VMHV.js";
-import {
-  getConversationEventStore,
-  getDb,
-  getSqlExecutor
-} from "./chunk-M76HMB7M.js";
-import {
-  juniorCodeChanges,
-  juniorCodeRepositories,
-  juniorConversationAnnotations,
-  juniorConversationEvents,
-  juniorIdentities,
-  juniorSnapshots,
-  juniorUsers,
-  juniorWorkspaceRepos,
-  juniorWorkspaces
-} from "./chunk-PW4P4JYF.js";
-import {
-  SANDBOX_WORKSPACE_ROOT,
-  getVercelSandboxCredentials,
-  hash,
-  isSandboxMissingError,
-  runNonInteractiveCommand,
-  sleep
-} from "./chunk-NSXKRGRT.js";
-import {
-  getStateAdapter
-} from "./chunk-2MK3QBGA.js";
-import {
-  botConfig,
-  completeObject,
-  embedTexts,
-  getSlackBotToken
-} from "./chunk-63NKKFJL.js";
-import {
-  defaultModelId
-} from "./chunk-NHJU2ZAL.js";
-import {
-  isActorUserId,
-  parseActorUserId,
-  parseSlackChannelReferenceId,
-  parseSlackMessageTs,
-  parseSlackTeamId
-} from "./chunk-N7TMSOZH.js";
-import {
-  logException,
-  logInfo,
-  logWarn,
-  normalizeIdentityEmail,
-  setSpanAttributes,
-  setSpanStatus,
-  withSpan
-} from "./chunk-MAGNK5J4.js";
-
-// src/chat/plugins/agent-hooks.ts
-import {
-  missingToolAnnotationKeys,
-  normalizeResourceEventIdentifier,
-  pluginResourceEventsSchema,
-  promptContextSchema,
-  promptMessageSchema,
-  resourceEventInputSchema
-} from "@sentry/junior-plugin-api";
-
-// src/chat/plugins/annotations.ts
-import { and, desc, eq, inArray } from "drizzle-orm";
-import {
-  conversationAnnotationInputSchema
-} from "@sentry/junior-plugin-api";
-function annotationFromRow(row) {
-  const parsed = conversationAnnotationInputSchema.safeParse(row.annotation);
-  if (!parsed.success) return void 0;
-  return {
-    ...parsed.data,
-    plugin: row.plugin,
-    createdAt: row.createdAt.toISOString(),
-    updatedAt: row.updatedAt.toISOString()
-  };
-}
-function createPluginAnnotations(args) {
-  return {
-    async upsert(input) {
-      const annotation = conversationAnnotationInputSchema.parse(input);
-      const now = /* @__PURE__ */ new Date();
-      await args.db.insert(juniorConversationAnnotations).values({
-        annotation,
-        conversationId: args.conversationId,
-        createdAt: now,
-        key: annotation.key,
-        kind: annotation.kind,
-        plugin: args.plugin,
-        updatedAt: now
-      }).onConflictDoUpdate({
-        target: [
-          juniorConversationAnnotations.conversationId,
-          juniorConversationAnnotations.plugin,
-          juniorConversationAnnotations.kind,
-          juniorConversationAnnotations.key
-        ],
-        set: { annotation, updatedAt: now }
-      });
-    },
-    async remove(kind, key) {
-      await args.db.delete(juniorConversationAnnotations).where(
-        and(
-          eq(
-            juniorConversationAnnotations.conversationId,
-            args.conversationId
-          ),
-          eq(juniorConversationAnnotations.plugin, args.plugin),
-          eq(juniorConversationAnnotations.kind, kind),
-          eq(juniorConversationAnnotations.key, key)
-        )
-      );
-    },
-    async list() {
-      return (await listConversationAnnotations(args.db, args.conversationId)).filter((a) => a.plugin === args.plugin);
-    }
-  };
-}
-async function listConversationAnnotations(db, conversationId) {
-  const byConversation = await listConversationAnnotationsById(db, [
-    conversationId
-  ]);
-  return byConversation.get(conversationId) ?? [];
-}
-async function listConversationAnnotationsById(db, conversationIds) {
-  const byConversation = /* @__PURE__ */ new Map();
-  if (conversationIds.length === 0) return byConversation;
-  const rows = await db.select().from(juniorConversationAnnotations).where(
-    inArray(juniorConversationAnnotations.conversationId, [
-      ...conversationIds
-    ])
-  ).orderBy(desc(juniorConversationAnnotations.updatedAt));
-  for (const row of rows) {
-    const annotation = annotationFromRow(row);
-    if (!annotation) continue;
-    const current = byConversation.get(row.conversationId);
-    if (current) {
-      current.push(annotation);
-    } else {
-      byConversation.set(row.conversationId, [annotation]);
-    }
-  }
-  return byConversation;
-}
-
-// src/chat/plugins/conversation-events.ts
-function registeredDefinition(plugin, value) {
-  return plugin.conversationEvents?.find(
-    (definition) => definition === value.definition
-  );
-}
-function eventIdentityVersion(plugin, definition) {
-  let version = definition.version;
-  for (const candidate of plugin.conversationEvents ?? []) {
-    if (candidate.eventName === definition.eventName) {
-      version = Math.min(version, candidate.version);
-    }
-  }
-  return version;
-}
-function createPluginConversationEvents(args) {
-  return {
-    async emit(value) {
-      const definition = registeredDefinition(args.plugin, value);
-      if (!definition) {
-        throw new Error(
-          `Plugin "${args.plugin.manifest.name}" cannot emit an unregistered conversation event.`
-        );
-      }
-      const content = definition.parse(value.data);
-      const identityVersion = eventIdentityVersion(args.plugin, definition);
-      await getConversationEventStore().append(
-        args.conversationId,
-        [
-          {
-            createdAtMs: Date.now(),
-            idempotencyKey: `plugin:${args.plugin.manifest.name}:operation:${args.operationId}:event:${definition.eventName}@${identityVersion}`,
-            data: {
-              type: "structured_event",
-              namespace: args.plugin.manifest.name,
-              name: definition.eventName,
-              version: definition.version,
-              turnId: args.turnId,
-              content
-            }
-          }
-        ],
-        { activity: "preserve" }
-      );
-    }
-  };
-}
-function renderPluginConversationEvent(args) {
-  const plugin = getPlugins().find(
-    (candidate) => candidate.manifest.name === args.namespace
-  );
-  const definition = plugin?.conversationEvents?.find(
-    (candidate) => candidate.eventName === args.name && candidate.version === args.version
-  );
-  if (!definition) return void 0;
-  return definition.renderEvent(definition.parse(args.content));
-}
-
-// src/chat/plugins/conversation-event-stats.ts
-import { and as and2, eq as eq2, gte, lt, sql } from "drizzle-orm";
-import { z } from "zod";
-var DAY_MS = 24 * 60 * 60 * 1e3;
-var costRowSchema = z.object({
-  costUsd: z.number().finite().nonnegative(),
-  date: z.string().regex(/^\d{4}-\d{2}-\d{2}(T\d{2})?$/),
-  events: z.number().int().nonnegative()
-}).strict();
-function startOfUtcDay(value) {
-  const date = new Date(value);
-  date.setUTCHours(0, 0, 0, 0);
-  return date;
-}
-function registeredEventName(plugin, eventName) {
-  if (!plugin.conversationEvents?.some(
-    (definition) => definition.eventName === eventName
-  )) {
-    throw new TypeError(
-      `Plugin "${plugin.manifest.name}" did not register event "${eventName}"`
-    );
-  }
-  return eventName;
-}
-function createPluginConversationEventStats(plugin, now = Date.now) {
-  return {
-    async costsByHour(input) {
-      const eventName = registeredEventName(plugin, input.eventName);
-      const hourCount = input.hours ?? 24;
-      const end = new Date(now());
-      end.setUTCMinutes(0, 0, 0);
-      const start = new Date(end.getTime() - (hourCount - 1) * 60 * 60 * 1e3);
-      const endExclusive = new Date(end.getTime() + 60 * 60 * 1e3);
-      const date = sql`TO_CHAR(
-        ${juniorConversationEvents.createdAt} AT TIME ZONE 'UTC',
-        'YYYY-MM-DD"T"HH24'
-      )`;
-      const cost = sql`CASE
-        WHEN jsonb_typeof(${juniorConversationEvents.payload}->'content'->'costUsd') = 'number'
-          THEN (${juniorConversationEvents.payload}->'content'->>'costUsd')::double precision
-        ELSE 0
-      END`;
-      const rows = await getDb().select({
-        costUsd: sql`SUM(${cost})::double precision`.mapWith(Number),
-        date,
-        events: sql`COUNT(*)::integer`.mapWith(Number)
-      }).from(juniorConversationEvents).where(
-        and2(
-          eq2(juniorConversationEvents.type, "structured_event"),
-          sql`${juniorConversationEvents.payload}->>'namespace' = ${plugin.manifest.name}`,
-          sql`${juniorConversationEvents.payload}->>'name' = ${eventName}`,
-          gte(juniorConversationEvents.createdAt, start),
-          lt(juniorConversationEvents.createdAt, endExclusive)
-        )
-      ).groupBy(date);
-      const byHour = new Map(
-        z.array(costRowSchema).parse(rows).map((row) => [row.date, row])
-      );
-      return Array.from({ length: hourCount }, (_, index) => {
-        const hour = new Date(start.getTime() + index * 60 * 60 * 1e3);
-        const key = hour.toISOString().slice(0, 13);
-        return byHour.get(key) ?? {
-          costUsd: 0,
-          date: key,
-          events: 0
-        };
-      });
-    },
-    async costsByDay(input) {
-      const eventName = registeredEventName(plugin, input.eventName);
-      const end = startOfUtcDay(now());
-      const start = new Date(end.getTime() - (input.days - 1) * DAY_MS);
-      const endExclusive = new Date(end.getTime() + DAY_MS);
-      const date = sql`TO_CHAR(
-        ${juniorConversationEvents.createdAt} AT TIME ZONE 'UTC',
-        'YYYY-MM-DD'
-      )`;
-      const cost = sql`CASE
-        WHEN jsonb_typeof(${juniorConversationEvents.payload}->'content'->'costUsd') = 'number'
-          THEN (${juniorConversationEvents.payload}->'content'->>'costUsd')::double precision
-        ELSE 0
-      END`;
-      const rows = await getDb().select({
-        costUsd: sql`SUM(${cost})::double precision`.mapWith(Number),
-        date,
-        events: sql`COUNT(*)::integer`.mapWith(Number)
-      }).from(juniorConversationEvents).where(
-        and2(
-          eq2(juniorConversationEvents.type, "structured_event"),
-          sql`${juniorConversationEvents.payload}->>'namespace' = ${plugin.manifest.name}`,
-          sql`${juniorConversationEvents.payload}->>'name' = ${eventName}`,
-          gte(juniorConversationEvents.createdAt, start),
-          lt(juniorConversationEvents.createdAt, endExclusive)
-        )
-      ).groupBy(date);
-      const byDate = new Map(
-        z.array(costRowSchema).parse(rows).map((row) => [row.date, row])
-      );
-      return Array.from({ length: input.days }, (_, index) => {
-        const day = new Date(start.getTime() + index * DAY_MS);
-        const date2 = day.toISOString().slice(0, 10);
-        return byDate.get(date2) ?? {
-          costUsd: 0,
-          date: date2,
-          events: 0
-        };
-      });
-    }
-  };
-}
-
-// src/chat/plugins/logging.ts
-function createPluginLogger(plugin) {
-  return {
-    info(message, metadata) {
-      logInfo("plugin.log.info", {
-        "app.log.message": message,
-        "app.plugin.name": plugin,
-        ...metadata
-      });
-    },
-    warn(message, metadata) {
-      logWarn("plugin.log.warn", {
-        "app.log.message": message,
-        "app.plugin.name": plugin,
-        ...metadata
-      });
-    },
-    error(message, metadata) {
-      logException(new Error(message), "plugin.log.error", {
-        "app.plugin.name": plugin,
-        ...metadata
-      });
-    }
-  };
-}
-
-// src/chat/plugins/model.ts
-function createPluginModel(pluginName, options = {}, runtime = {}) {
-  return {
-    async completeObject(input) {
-      const modelId = options.structuredModelId ?? (options.structuredModel === "default" ? defaultModelId(botConfig) : botConfig.fastModelId);
-      const result = await completeObject({
-        modelId,
-        schema: input.schema,
-        prompt: input.prompt,
-        ...input.system !== void 0 ? { system: input.system } : void 0,
-        ...input.maxTokens !== void 0 ? { maxTokens: input.maxTokens } : void 0,
-        signal: runtime.signal,
-        promptName: `${pluginName}.structured_completion`,
-        metadata: {
-          pluginName,
-          pluginModelRole: "structured"
-        }
-      });
-      return {
-        object: result.object,
-        ...result.costUsd !== void 0 ? { costUsd: result.costUsd } : void 0
-      };
-    }
-  };
-}
-function createPluginEmbedder(pluginName, runtime = {}) {
-  return {
-    async embedTexts(input) {
-      return await embedTexts({
-        modelId: botConfig.embeddingModelId,
-        texts: input.texts,
-        signal: runtime.signal,
-        metadata: {
-          pluginName,
-          pluginModelRole: "embedding"
-        }
-      });
-    }
-  };
-}
-
-// src/chat/plugins/state.ts
-import { createHash } from "crypto";
-var MAX_PLUGIN_STATE_KEY_LENGTH = 512;
-function hashKeyPart(value) {
-  return createHash("sha256").update(value).digest("hex").slice(0, 32);
-}
-function pluginStateKey(plugin, key) {
-  const pluginPrefix = `junior:${plugin}`;
-  if (key === pluginPrefix || key.startsWith(`${pluginPrefix}:`)) {
-    return key;
-  }
-  return `junior:plugin_state:${hashKeyPart(plugin)}:${hashKeyPart(key)}`;
-}
-function validatePluginStateKey(key) {
-  if (!key.trim()) {
-    throw new Error("Plugin state key is required");
-  }
-  if (key.length > MAX_PLUGIN_STATE_KEY_LENGTH) {
-    throw new Error("Plugin state key exceeds the maximum length");
-  }
-}
-function createPluginState(plugin, adapter) {
-  const getAdapter = () => adapter ?? getStateAdapter();
-  return {
-    async delete(key) {
-      validatePluginStateKey(key);
-      const state = getAdapter();
-      await state.connect();
-      await state.delete(pluginStateKey(plugin, key));
-    },
-    async get(key) {
-      validatePluginStateKey(key);
-      const state = getAdapter();
-      await state.connect();
-      const value = await state.get(pluginStateKey(plugin, key));
-      return value ?? void 0;
-    },
-    async set(key, value, ttlMs) {
-      validatePluginStateKey(key);
-      const state = getAdapter();
-      await state.connect();
-      await state.set(pluginStateKey(plugin, key), value, ttlMs);
-    },
-    async setIfNotExists(key, value, ttlMs) {
-      validatePluginStateKey(key);
-      const state = getAdapter();
-      await state.connect();
-      return await state.setIfNotExists(
-        pluginStateKey(plugin, key),
-        value,
-        ttlMs
-      );
-    },
-    async withLock(key, ttlMs, callback) {
-      validatePluginStateKey(key);
-      const state = getAdapter();
-      await state.connect();
-      const lockKey = pluginStateKey(plugin, key);
-      const lock = await state.acquireLock(lockKey, ttlMs);
-      if (!lock) {
-        throw new Error(`Could not acquire plugin state lock for ${key}`);
-      }
-      try {
-        return await callback();
-      } finally {
-        await state.releaseLock(lock);
-      }
-    }
-  };
-}
-
-// src/chat/slack/dashboard-link.ts
-var dashboardConversationLinkOptions;
-function withHttps(host) {
-  return /^https?:\/\//.test(host) ? host : `https://${host}`;
-}
-function stripTrailingSlashes(value) {
-  let end = value.length;
-  while (end > 1 && value.charCodeAt(end - 1) === 47) {
-    end -= 1;
-  }
-  return end === value.length ? value : value.slice(0, end);
-}
-function normalizeDashboardPath(path, fallback) {
-  const value = path?.trim() || fallback;
-  const withSlash = value.startsWith("/") ? value : `/${value}`;
-  return stripTrailingSlashes(withSlash);
-}
-function resolveDashboardBaseURL(config) {
-  const explicit = config.baseURL ?? process.env.JUNIOR_BASE_URL;
-  if (explicit?.trim()) {
-    return stripTrailingSlashes(withHttps(explicit.trim()));
-  }
-  const vercelProd = process.env.VERCEL_PROJECT_PRODUCTION_URL?.trim();
-  if (vercelProd) {
-    return stripTrailingSlashes(withHttps(vercelProd));
-  }
-  const vercelUrl = process.env.VERCEL_URL?.trim();
-  if (vercelUrl) {
-    return stripTrailingSlashes(withHttps(vercelUrl));
-  }
-  return "http://localhost:3000";
-}
-function setDashboardConversationLinkOptions(options) {
-  const previous = dashboardConversationLinkOptions;
-  dashboardConversationLinkOptions = options?.disabled ? void 0 : options;
-  return previous;
-}
-function resolveDashboardPath(segmentPath) {
-  if (!dashboardConversationLinkOptions) {
-    return void 0;
-  }
-  const baseURL = resolveDashboardBaseURL(dashboardConversationLinkOptions);
-  const basePath = normalizeDashboardPath(
-    dashboardConversationLinkOptions.basePath,
-    "/"
-  );
-  const path = basePath === "/" ? segmentPath : `${basePath}${segmentPath}`;
-  return `${baseURL}${path}`;
-}
-function getDashboardConversationLink(conversationId) {
-  return resolveDashboardPath(
-    `/conversations/${encodeURIComponent(conversationId)}`
-  );
-}
-function getDashboardTaskLink(taskId) {
-  return resolveDashboardPath(`/tasks/${encodeURIComponent(taskId)}`);
-}
-
-// src/chat/resource-events/store.ts
-import { createHash as createHash2 } from "crypto";
-import {
-  resourceEventMatchSchema,
-  resourceEventMatches,
-  resourceEventTypeSchema,
-  stableResourceEventMatchKey
-} from "@sentry/junior-plugin-api";
-import { z as z2 } from "zod";
-var RESOURCE_EVENT_PREFIX = "junior:resource_event_subscription:v5";
-var INDEX_LOCK_TTL_MS = 1e4;
-var SUBSCRIPTION_LOCK_TTL_MS = 1e4;
-var SUBSCRIPTION_LOCK_WAIT_MS = 1e4;
-var SUBSCRIPTION_LOCK_RETRY_MS = 25;
-var SUBSCRIPTION_LOCK_HEARTBEAT_MS = 3e3;
-var subscriptionStatusSchema = z2.enum(["active", "cancelled", "completed"]);
-var subscriptionIdIndexSchema = z2.array(z2.string().min(1));
-var subscriptionSchema = z2.object({
-  conversationId: z2.string().min(1),
-  createdAtMs: z2.number().finite(),
-  events: z2.array(resourceEventTypeSchema).min(1),
-  expiresAtMs: z2.number().finite(),
-  id: z2.string().min(1),
-  intent: z2.string().min(1),
-  label: z2.string().min(1),
-  match: resourceEventMatchSchema.optional(),
-  namespace: z2.string().min(1),
-  identifier: z2.string().min(1),
-  resourceType: z2.string().min(1),
-  status: subscriptionStatusSchema,
-  updatedAtMs: z2.number().finite()
-}).strict();
-function digest(value) {
-  return createHash2("sha256").update(value).digest("hex").slice(0, 32);
-}
-function subscriptionKey(id) {
-  return `${RESOURCE_EVENT_PREFIX}:record:${id}`;
-}
-function subscriptionLockKey(id) {
-  return `${RESOURCE_EVENT_PREFIX}:lock:${id}`;
-}
-function resourceIndexKey(namespace, identifier) {
-  return `${RESOURCE_EVENT_PREFIX}:resource:${digest(`${namespace}\0${identifier}`)}`;
-}
-function conversationIndexKey(conversationId) {
-  return `${RESOURCE_EVENT_PREFIX}:conversation:${digest(conversationId)}`;
-}
-function indexLockKey(key) {
-  return `${key}:lock`;
-}
-async function sleep2(ms) {
-  await new Promise((resolve) => {
-    const timer = setTimeout(resolve, ms);
-    timer.unref?.();
-  });
-}
-async function acquireSubscriptionLock(state, subscriptionId, waitDeadlineMs = Date.now() + SUBSCRIPTION_LOCK_WAIT_MS) {
-  while (true) {
-    const lock = await state.acquireLock(
-      subscriptionLockKey(subscriptionId),
-      SUBSCRIPTION_LOCK_TTL_MS
-    );
-    if (lock) {
-      return lock;
-    }
-    if (Date.now() >= waitDeadlineMs) {
-      throw new Error(
-        `Could not acquire resource event subscription lock for ${subscriptionId}`
-      );
-    }
-    await sleep2(SUBSCRIPTION_LOCK_RETRY_MS);
-  }
-}
-async function withSubscriptionLock(state, subscriptionId, callback, waitDeadlineMs) {
-  const lock = await acquireSubscriptionLock(
-    state,
-    subscriptionId,
-    waitDeadlineMs
-  );
-  let lockLostError;
-  let heartbeatError;
-  let heartbeat;
-  const timer = setInterval(() => {
-    if (heartbeat) {
-      return;
-    }
-    heartbeat = state.extendLock(lock, SUBSCRIPTION_LOCK_TTL_MS).then((extended) => {
-      if (extended) {
-        heartbeatError = void 0;
-      } else {
-        lockLostError = new Error(
-          `Resource event subscription lock was lost for ${subscriptionId}`
-        );
-      }
-    }).catch((error) => {
-      heartbeatError = error instanceof Error ? error : new Error(`Failed to extend subscription lock: ${String(error)}`);
-    }).finally(() => {
-      heartbeat = void 0;
-    });
-  }, SUBSCRIPTION_LOCK_HEARTBEAT_MS);
-  timer.unref?.();
-  let result;
-  try {
-    result = await callback();
-  } finally {
-    clearInterval(timer);
-    await heartbeat;
-    await state.releaseLock(lock);
-  }
-  const lockError = lockLostError ?? heartbeatError;
-  if (lockError) {
-    throw lockError;
-  }
-  return result;
-}
-function ttlUntil(expiresAtMs, nowMs) {
-  return Math.max(1, expiresAtMs - nowMs);
-}
-async function readSubscriptionIdIndex(state, key) {
-  const value = await state.get(key);
-  if (value === void 0 || value === null) {
-    return [];
-  }
-  return subscriptionIdIndexSchema.parse(value);
-}
-function buildSubscriptionId(input) {
-  const eventKey = [...new Set(input.events)].sort().join("\0");
-  const matchKey = stableResourceEventMatchKey(input.match);
-  const material = matchKey ? `${input.namespace}\0${input.identifier}\0${input.conversationId}\0${eventKey}\0${matchKey}` : `${input.namespace}\0${input.identifier}\0${input.conversationId}\0${eventKey}`;
-  return `resub_${digest(material)}`;
-}
-async function withIndexLock(state, key, callback) {
-  const lock = await state.acquireLock(indexLockKey(key), INDEX_LOCK_TTL_MS);
-  if (!lock) {
-    throw new Error(`Could not acquire resource event index lock for ${key}`);
-  }
-  try {
-    return await callback();
-  } finally {
-    await state.releaseLock(lock);
-  }
-}
-async function addToIndex(state, key, subscriptionId, nowMs) {
-  await withIndexLock(state, key, async () => {
-    const ids = [...new Set(await readSubscriptionIdIndex(state, key))];
-    const next = ids.includes(subscriptionId) ? ids : [...ids, subscriptionId];
-    await state.set(key, next, await indexTtlMs(state, next, nowMs));
-  });
-}
-async function removeFromIndex(state, key, subscriptionId, nowMs) {
-  await withIndexLock(state, key, async () => {
-    const existing = await readSubscriptionIdIndex(state, key);
-    const next = existing.filter((id) => id !== subscriptionId);
-    await state.set(key, next, await indexTtlMs(state, next, nowMs));
-  });
-}
-async function indexTtlMs(state, subscriptionIds, nowMs) {
-  const records = await Promise.all(
-    subscriptionIds.map(
-      async (id) => parseSubscription(await state.get(subscriptionKey(id)))
-    )
-  );
-  const latestExpiresAtMs = Math.max(
-    nowMs,
-    ...records.filter(
-      (record) => record !== void 0 && activeAt(record, nowMs)
-    ).map((record) => record.expiresAtMs)
-  );
-  return ttlUntil(latestExpiresAtMs, nowMs);
-}
-function parseSubscription(value) {
-  if (value === void 0 || value === null) {
-    return void 0;
-  }
-  return subscriptionSchema.parse(value);
-}
-function activeAt(subscription, nowMs) {
-  return subscription.status === "active" && subscription.expiresAtMs > nowMs;
-}
-function matchesEvent(subscription, input) {
-  return subscription.namespace === input.namespace && subscription.identifier === input.identifier && subscription.events.includes(input.eventType) && activeAt(subscription, input.nowMs) && resourceEventMatches(subscription.match, input.data);
-}
-async function createResourceEventSubscription(input, options = {}) {
-  const state = options.state ?? getStateAdapter();
-  await state.connect();
-  const nowMs = options.nowMs ?? Date.now();
-  const events = [...new Set(input.events.map((event) => event.trim()))].filter(
-    Boolean
-  );
-  if (events.length === 0) {
-    throw new Error("Resource event subscription requires at least one event");
-  }
-  if (input.expiresAtMs <= nowMs) {
-    throw new Error("Resource event subscription expiry must be in the future");
-  }
-  const match = input.match && Object.keys(input.match).length > 0 ? input.match : void 0;
-  const id = buildSubscriptionId({
-    conversationId: input.conversationId,
-    events,
-    match,
-    namespace: input.namespace,
-    identifier: input.identifier
-  });
-  const record = {
-    conversationId: input.conversationId,
-    createdAtMs: nowMs,
-    events,
-    expiresAtMs: input.expiresAtMs,
-    id,
-    intent: input.intent,
-    label: input.label,
-    ...match ? { match } : void 0,
-    namespace: input.namespace,
-    identifier: input.identifier,
-    resourceType: input.resourceType,
-    status: "active",
-    updatedAtMs: nowMs
-  };
-  const parsed = subscriptionSchema.parse(record);
-  await state.set(
-    subscriptionKey(id),
-    parsed,
-    ttlUntil(parsed.expiresAtMs, nowMs)
-  );
-  await addToIndex(
-    state,
-    resourceIndexKey(input.namespace, input.identifier),
-    id,
-    nowMs
-  );
-  await addToIndex(
-    state,
-    conversationIndexKey(input.conversationId),
-    id,
-    nowMs
-  );
-  return parsed;
-}
-async function listResourceEventSubscriptions(input) {
-  const state = input.state ?? getStateAdapter();
-  await state.connect();
-  const nowMs = input.nowMs ?? Date.now();
-  const ids = await readSubscriptionIdIndex(
-    state,
-    conversationIndexKey(input.conversationId)
-  );
-  const records = await Promise.all(
-    ids.map(
-      async (id) => parseSubscription(await state.get(subscriptionKey(id)))
-    )
-  );
-  return records.filter(
-    (record) => record !== void 0 && record.conversationId === input.conversationId && activeAt(record, nowMs)
-  ).sort((left, right) => left.createdAtMs - right.createdAtMs);
-}
-async function cancelResourceEventSubscription(input) {
-  const state = input.state ?? getStateAdapter();
-  await state.connect();
-  return await withSubscriptionLock(state, input.id, async () => {
-    const current = parseSubscription(
-      await state.get(subscriptionKey(input.id))
-    );
-    if (!current || current.conversationId !== input.conversationId) {
-      return void 0;
-    }
-    const nowMs = input.nowMs ?? Date.now();
-    const next = {
-      ...current,
-      status: "cancelled",
-      updatedAtMs: nowMs
-    };
-    await state.set(
-      subscriptionKey(input.id),
-      next,
-      JUNIOR_THREAD_STATE_TTL_MS
-    );
-    await removeFromIndex(
-      state,
-      resourceIndexKey(current.namespace, current.identifier),
-      input.id,
-      nowMs
-    );
-    await removeFromIndex(
-      state,
-      conversationIndexKey(current.conversationId),
-      input.id,
-      nowMs
-    );
-    return next;
-  });
-}
-async function cancelSubscriptions(input) {
-  const subscriptions = await listResourceEventSubscriptions(input);
-  for (const subscription of subscriptions) {
-    await cancelResourceEventSubscription({
-      conversationId: input.conversationId,
-      id: subscription.id,
-      nowMs: input.nowMs,
-      state: input.state
-    });
-  }
-}
-async function collectResourceEventMatchKeys(input) {
-  const state = input.state ?? getStateAdapter();
-  await state.connect();
-  const nowMs = input.nowMs ?? Date.now();
-  const eventTypes = new Set(
-    input.eventTypes.map((eventType) => eventType.trim()).filter(Boolean)
-  );
-  if (eventTypes.size === 0) return [];
-  const keys = /* @__PURE__ */ new Set();
-  const identifiers = new Set(
-    input.identifiers.map((value) => value.trim()).filter(Boolean)
-  );
-  for (const identifier of identifiers) {
-    const ids = await readSubscriptionIdIndex(
-      state,
-      resourceIndexKey(input.namespace, identifier)
-    );
-    const records = await Promise.all(
-      ids.map(
-        async (id) => parseSubscription(await state.get(subscriptionKey(id)))
-      )
-    );
-    for (const record of records) {
-      if (!record) continue;
-      if (record.namespace !== input.namespace) continue;
-      if (record.identifier !== identifier) continue;
-      if (!activeAt(record, nowMs)) continue;
-      if (!record.events.some((eventType) => eventTypes.has(eventType))) continue;
-      for (const key of Object.keys(record.match ?? {})) {
-        keys.add(key);
-      }
-    }
-  }
-  return [...keys].sort();
-}
-async function findMatchingResourceEventSubscriptions(input) {
-  const state = input.state ?? getStateAdapter();
-  await state.connect();
-  const nowMs = input.nowMs ?? Date.now();
-  const ids = await readSubscriptionIdIndex(
-    state,
-    resourceIndexKey(input.namespace, input.identifier)
-  );
-  const records = await Promise.all(
-    ids.map(
-      async (id) => parseSubscription(await state.get(subscriptionKey(id)))
-    )
-  );
-  return records.filter(
-    (record) => record !== void 0 && matchesEvent(record, {
-      data: input.data,
-      eventType: input.eventType,
-      nowMs,
-      namespace: input.namespace,
-      identifier: input.identifier
-    })
-  );
-}
-async function deliverResourceEventSubscription(input) {
-  const state = input.state ?? getStateAdapter();
-  await state.connect();
-  return await withSubscriptionLock(
-    state,
-    input.subscription.id,
-    async () => {
-      const nowMs = input.nowMs ?? Date.now();
-      const current = parseSubscription(
-        await state.get(subscriptionKey(input.subscription.id))
-      );
-      if (!current || !matchesEvent(current, {
-        data: input.data,
-        eventType: input.eventType,
-        nowMs,
-        namespace: input.namespace,
-        identifier: input.identifier
-      })) {
-        return false;
-      }
-      const delivered = await input.deliver(current);
-      if (input.terminal) {
-        const latest = parseSubscription(
-          await state.get(subscriptionKey(current.id))
-        );
-        if (!latest || latest.status !== current.status || latest.updatedAtMs !== current.updatedAtMs) {
-          return delivered;
-        }
-        const next = {
-          ...current,
-          status: "completed",
-          updatedAtMs: nowMs
-        };
-        await state.set(
-          subscriptionKey(current.id),
-          next,
-          JUNIOR_THREAD_STATE_TTL_MS
-        );
-        await removeFromIndex(
-          state,
-          resourceIndexKey(current.namespace, current.identifier),
-          current.id,
-          nowMs
-        );
-        await removeFromIndex(
-          state,
-          conversationIndexKey(current.conversationId),
-          current.id,
-          nowMs
-        );
-      }
-      return delivered;
-    },
-    input.waitDeadlineMs
-  );
-}
-
-// src/chat/resource-events/tool-support.ts
-var RESOURCE_SUBSCRIPTION_DEFAULT_TTL_MS = 14 * 24 * 60 * 60 * 1e3;
-var RESOURCE_SUBSCRIPTION_MAX_TTL_MS = 30 * 24 * 60 * 60 * 1e3;
-var STOP_WATCHING_TOOL_NAME = "stopWatchingResources";
-var RESOURCE_WATCH_TOOL_SOURCE = {
-  id: "resource-watches",
-  description: "Inspect or stop resource watches for the current conversation."
-};
-
-// src/chat/slack/tool-support/context.ts
-function getSlackToolContext(context) {
-  const source = context.source.kind === "slack" ? context.source : void 0;
-  const location = context.location?.provider === "slack" ? context.location : source ? {
-    provider: "slack",
-    teamId: source.teamId,
-    channelId: source.channelId,
-    threadTs: source.threadTs
-  } : void 0;
-  if (!location) return void 0;
-  const destinationChannelId = parseSlackChannelReferenceId(
-    context.destination.platform === "slack" ? context.destination.channelId : location.channelId
-  );
-  const locationChannelId = parseSlackChannelReferenceId(location.channelId);
-  const teamId = parseSlackTeamId(location.teamId);
-  if (!destinationChannelId || !locationChannelId || !teamId) {
-    return void 0;
-  }
-  return {
-    actor: context.actor?.platform === "slack" ? context.actor : void 0,
-    destinationChannelId,
-    locationChannelId,
-    messageChannelId: source ? parseSlackChannelReferenceId(source.channelId) : void 0,
-    messageTs: parseSlackMessageTs(source?.messageTs),
-    teamId,
-    threadTs: parseSlackMessageTs(location.threadTs)
-  };
-}
-
-// src/chat/plugins/viewer.ts
-import { randomUUID } from "crypto";
-import { and as and3, asc, eq as eq3 } from "drizzle-orm";
-import {
-  identitySchema,
-  userSchema
-} from "@sentry/junior-plugin-api";
-function identityFromRow(row) {
-  return identitySchema.parse({
-    id: row.id,
-    provider: row.provider,
-    providerSubjectId: row.providerSubjectId,
-    ...row.providerTenantId ? { providerTenantId: row.providerTenantId } : void 0,
-    ...row.displayName ? { displayName: row.displayName } : void 0,
-    ...row.handle ? { handle: row.handle } : void 0
-  });
-}
-async function readUserById(db, userRow) {
-  const identityRows = await db.select().from(juniorIdentities).where(
-    and3(
-      eq3(juniorIdentities.userId, userRow.id),
-      eq3(juniorIdentities.kind, "user")
-    )
-  ).orderBy(
-    asc(juniorIdentities.provider),
-    asc(juniorIdentities.providerTenantId),
-    asc(juniorIdentities.providerSubjectId)
-  );
-  return userSchema.parse({
-    email: userRow.primaryEmail,
-    id: userRow.id,
-    identities: identityRows.map(identityFromRow),
-    ...userRow.displayName ? { displayName: userRow.displayName } : void 0
-  });
-}
-async function resolveViewerUserFromSql(db, email) {
-  const normalizedEmail = normalizeIdentityEmail(email);
-  if (!normalizedEmail) return void 0;
-  const now = /* @__PURE__ */ new Date();
-  const rows = await db.insert(juniorUsers).values({
-    id: randomUUID(),
-    primaryEmail: email.trim(),
-    primaryEmailNormalized: normalizedEmail,
-    displayName: null,
-    createdAt: now,
-    updatedAt: now
-  }).onConflictDoNothing({ target: juniorUsers.primaryEmailNormalized }).returning();
-  const userRow = rows[0] ?? (await db.select().from(juniorUsers).where(eq3(juniorUsers.primaryEmailNormalized, normalizedEmail)).limit(1))[0];
-  return userRow ? await readUserById(db, userRow) : void 0;
-}
-async function resolveViewerUser(email) {
-  return await resolveViewerUserFromSql(getDb(), email);
-}
-async function findUserByEmailFromSql(db, email) {
-  const normalizedEmail = normalizeIdentityEmail(email);
-  if (!normalizedEmail) return void 0;
-  const userRow = (await db.select().from(juniorUsers).where(eq3(juniorUsers.primaryEmailNormalized, normalizedEmail)).limit(1))[0];
-  return userRow ? await readUserById(db, userRow) : void 0;
-}
-async function findUserByEmail(email) {
-  return await findUserByEmailFromSql(getDb(), email);
-}
-async function updateViewerDisplayNameFromSql(db, userId, displayName) {
-  const rows = await db.update(juniorUsers).set({ displayName, updatedAt: /* @__PURE__ */ new Date() }).where(eq3(juniorUsers.id, userId)).returning();
-  const userRow = rows[0];
-  return userRow ? await readUserById(db, userRow) : void 0;
-}
-async function updateViewerDisplayName(userId, displayName) {
-  return await updateViewerDisplayNameFromSql(getDb(), userId, displayName);
-}
-async function readActorIdentityFromSql(db, actor) {
-  if (actor.platform === "system") return void 0;
-  const providerTenantId = actor.platform === "slack" ? actor.teamId : "";
-  const rows = await db.select({
-    identity: juniorIdentities,
-    user: juniorUsers
-  }).from(juniorIdentities).leftJoin(juniorUsers, eq3(juniorUsers.id, juniorIdentities.userId)).where(
-    and3(
-      eq3(juniorIdentities.kind, "user"),
-      eq3(juniorIdentities.provider, actor.platform),
-      eq3(juniorIdentities.providerTenantId, providerTenantId),
-      eq3(juniorIdentities.providerSubjectId, actor.userId)
-    )
-  ).limit(1);
-  const row = rows[0];
-  if (!row) return void 0;
-  return {
-    identity: identityFromRow(row.identity),
-    ...row.user ? { user: await readUserById(db, row.user) } : void 0
-  };
-}
-async function readActorIdentity(actor) {
-  return await readActorIdentityFromSql(getDb(), actor);
-}
-
-// src/chat/credentials/subject.ts
-import { createHmac, timingSafeEqual } from "crypto";
-
-// src/chat/slack/client.ts
-import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
-import { WebClient } from "@slack/web-api";
-
-// src/chat/slack/workspace-context.ts
-import { AsyncLocalStorage } from "async_hooks";
-var workspaceTeamIdStorage = new AsyncLocalStorage();
-function runWithWorkspaceTeamId(teamId, fn) {
-  if (!teamId) return fn();
-  return workspaceTeamIdStorage.run(teamId, fn);
-}
-function getWorkspaceTeamId() {
-  return workspaceTeamIdStorage.getStore();
-}
-
-// src/chat/slack/client.ts
-var SlackActionError = class extends Error {
-  code;
-  apiError;
-  needed;
-  provided;
-  statusCode;
-  requestId;
-  errorData;
-  retryAfterSeconds;
-  detail;
-  detailLine;
-  detailRule;
-  constructor(message, code, options = {}) {
-    super(message);
-    this.name = "SlackActionError";
-    this.code = code;
-    this.apiError = options.apiError;
-    this.needed = options.needed;
-    this.provided = options.provided;
-    this.statusCode = options.statusCode;
-    this.requestId = options.requestId;
-    this.errorData = options.errorData;
-    this.retryAfterSeconds = options.retryAfterSeconds;
-    this.detail = options.detail;
-    this.detailLine = options.detailLine;
-    this.detailRule = options.detailRule;
-  }
-};
-function serializeSlackErrorData(data) {
-  if (!data || typeof data !== "object") {
-    return void 0;
-  }
-  const filtered = Object.fromEntries(
-    Object.entries(data).filter(
-      ([key]) => key !== "error"
-    )
-  );
-  if (Object.keys(filtered).length === 0) {
-    return void 0;
-  }
-  try {
-    const serialized = JSON.stringify(filtered);
-    return serialized.length <= 600 ? serialized : `${serialized.slice(0, 597)}...`;
-  } catch {
-    return void 0;
-  }
-}
-function getHeaderString(headers, name) {
-  if (!headers || typeof headers !== "object") {
-    return void 0;
-  }
-  const key = name.toLowerCase();
-  const entries = headers;
-  for (const [entryKey, value] of Object.entries(entries)) {
-    if (entryKey.toLowerCase() !== key) continue;
-    if (typeof value === "string") return value;
-    if (Array.isArray(value)) {
-      const first = value.find((entry) => typeof entry === "string");
-      return typeof first === "string" ? first : void 0;
-    }
-  }
-  return void 0;
-}
-function parseSlackCanvasDetail(detail) {
-  if (typeof detail !== "string") {
-    return {};
-  }
-  const trimmed = detail.trim();
-  if (!trimmed) {
-    return {};
-  }
-  const parsed = {
-    detail: trimmed
-  };
-  const lineMatch = trimmed.match(/line\s+(\d+):/i);
-  if (lineMatch) {
-    const line = Number.parseInt(lineMatch[1] ?? "", 10);
-    if (Number.isFinite(line)) {
-      parsed.detailLine = line;
-    }
-  }
-  if (/unsupported heading depth/i.test(trimmed)) {
-    parsed.detailRule = "unsupported_heading_depth";
-  }
-  return parsed;
-}
-var installationTokenStorage = new AsyncLocalStorage2();
-var clientsByToken = /* @__PURE__ */ new Map();
-function runWithSlackInstallationToken(token, fn) {
-  const trimmed = token.trim();
-  if (!trimmed) {
-    throw new SlackActionError(
-      "Slack installation token binding requires a non-empty token",
-      "missing_token"
-    );
-  }
-  return installationTokenStorage.run({ token: trimmed }, fn);
-}
-function resolveSlackToken() {
-  const ambientToken = installationTokenStorage.getStore()?.token;
-  if (ambientToken) {
-    return ambientToken;
-  }
-  const envToken = getSlackBotToken();
-  if (envToken) {
-    return envToken;
-  }
-  const teamId = getWorkspaceTeamId();
-  if (teamId) {
-    throw new SlackActionError(
-      `Slack call is scoped to workspace ${teamId} but no installation token is bound and no default bot token is configured`,
-      "missing_token"
-    );
-  }
-  throw new SlackActionError(
-    "SLACK_BOT_TOKEN (or SLACK_BOT_USER_TOKEN) is required for Slack Web API actions in this service",
-    "missing_token"
-  );
-}
-function normalizeSlackConversationId(channelId) {
-  return parseSlackChannelReferenceId(channelId);
-}
-function getClient() {
-  const token = resolveSlackToken();
-  let cached = clientsByToken.get(token);
-  if (!cached) {
-    cached = new WebClient(token, {
-      retryConfig: { retries: 0 },
-      rejectRateLimitedCalls: true
-    });
-    clientsByToken.set(token, cached);
-  }
-  return cached;
-}
-function mapSlackError(error) {
-  if (error instanceof SlackActionError) {
-    return error;
-  }
-  const candidate = error;
-  const apiError = candidate.data?.error;
-  const message = candidate.message ?? "Slack action failed";
-  const baseOptions = {
-    apiError,
-    statusCode: candidate.statusCode,
-    requestId: getHeaderString(candidate.headers, "x-slack-req-id"),
-    errorData: serializeSlackErrorData(candidate.data),
-    ...parseSlackCanvasDetail(candidate.data?.detail)
-  };
-  if (apiError === "missing_scope") {
-    return new SlackActionError(message, "missing_scope", {
-      ...baseOptions,
-      needed: candidate.data?.needed,
-      provided: candidate.data?.provided
-    });
-  }
-  if (apiError === "not_in_channel") {
-    return new SlackActionError(message, "not_in_channel", baseOptions);
-  }
-  if (apiError === "restricted_action_read_only_channel") {
-    return new SlackActionError(message, "read_only_channel", baseOptions);
-  }
-  if (apiError === "already_reacted") {
-    return new SlackActionError(message, "already_reacted", baseOptions);
-  }
-  if (apiError === "no_reaction") {
-    return new SlackActionError(message, "no_reaction", baseOptions);
-  }
-  if (apiError === "invalid_arguments") {
-    return new SlackActionError(message, "invalid_arguments", baseOptions);
-  }
-  if (apiError === "invalid_cursor") {
-    return new SlackActionError(message, "invalid_arguments", baseOptions);
-  }
-  if (apiError === "invalid_name") {
-    return new SlackActionError(message, "invalid_arguments", baseOptions);
-  }
-  if (apiError === "not_found" || apiError === "channel_not_found" || apiError === "message_not_found") {
-    return new SlackActionError(message, "not_found", baseOptions);
-  }
-  if (apiError === "feature_not_enabled" || apiError === "not_allowed_token_type") {
-    return new SlackActionError(message, "feature_unavailable", baseOptions);
-  }
-  if (apiError === "canvas_creation_failed") {
-    return new SlackActionError(message, "canvas_creation_failed", baseOptions);
-  }
-  if (apiError === "canvas_editing_failed") {
-    return new SlackActionError(message, "canvas_editing_failed", baseOptions);
-  }
-  if (candidate.code === "slack_webapi_rate_limited_error" || candidate.statusCode === 429) {
-    return new SlackActionError(message, "rate_limited", {
-      ...baseOptions,
-      retryAfterSeconds: candidate.retryAfter
-    });
-  }
-  return new SlackActionError(message, "internal_error", baseOptions);
-}
-var MAX_RETRY_DELAY_MS = 1e4;
-var MAX_TOTAL_RETRY_DELAY_MS = 2e4;
-var CONNECTION_ERROR_CODES = /* @__PURE__ */ new Set([
-  "ECONNREFUSED",
-  "ECONNRESET",
-  "ENOTFOUND",
-  "EAI_AGAIN"
-]);
-var TIMEOUT_ERROR_CODES = /* @__PURE__ */ new Set([
-  "ETIMEDOUT",
-  "ECONNABORTED",
-  "ESOCKETTIMEDOUT"
-]);
-function findNetworkErrorCode(error, depth = 0) {
-  if (!error || typeof error !== "object" || depth > 4) {
-    return void 0;
-  }
-  const candidate = error;
-  if (typeof candidate.code === "string" && (CONNECTION_ERROR_CODES.has(candidate.code) || TIMEOUT_ERROR_CODES.has(candidate.code))) {
-    return candidate.code;
-  }
-  return findNetworkErrorCode(candidate.original, depth + 1) ?? findNetworkErrorCode(candidate.cause, depth + 1);
-}
-function hasSocketHangUpMessage(error) {
-  return error instanceof Error && error.message.toLowerCase().includes("socket hang up");
-}
-function classifySlackRetry(raw, mapped) {
-  if (mapped.code === "rate_limited") {
-    return "rate_limited";
-  }
-  if (mapped.statusCode !== void 0 && mapped.statusCode >= 500) {
-    return "server_error";
-  }
-  const networkCode = findNetworkErrorCode(raw);
-  if (networkCode && CONNECTION_ERROR_CODES.has(networkCode)) {
-    return "connection";
-  }
-  if (networkCode && TIMEOUT_ERROR_CODES.has(networkCode)) {
-    return "timeout";
-  }
-  if (hasSocketHangUpMessage(raw)) {
-    return "connection";
-  }
-  return "none";
-}
-async function withSlackRetries(task, maxAttempts = 3, context = {}) {
-  let attempt = 0;
-  let totalDelayMs = 0;
-  const action = context.action ?? "unknown";
-  while (attempt < maxAttempts) {
-    attempt += 1;
-    const attemptNumber = attempt;
-    try {
-      return await withSpan(
-        `POST slack.com/api/${action}`,
-        "http.client",
-        {},
-        async () => {
-          try {
-            return await task();
-          } catch (error) {
-            const mapped = mapSlackError(error);
-            const errorAttrs = {
-              "error.type": mapped.code
-            };
-            if (mapped.apiError) {
-              errorAttrs["app.slack.api_error_code"] = mapped.apiError;
-            }
-            if (mapped.code === "rate_limited") {
-              errorAttrs["http.response.status_code"] = 429;
-              if (mapped.retryAfterSeconds) {
-                errorAttrs["app.slack.retry_after_ms"] = mapped.retryAfterSeconds * 1e3;
-              }
-            } else if (mapped.statusCode != null) {
-              errorAttrs["http.response.status_code"] = mapped.statusCode;
-            }
-            setSpanAttributes(errorAttrs);
-            setSpanStatus("error");
-            throw error;
-          }
-        },
-        {
-          "http.request.method": "POST",
-          "server.address": "slack.com",
-          "url.scheme": "https",
-          "url.path": `/api/${action}`,
-          "app.slack.method": action,
-          "app.retry.max_attempts": maxAttempts,
-          ...attemptNumber > 1 ? { "http.request.resend_count": attemptNumber - 1 } : void 0,
-          ...context.attributes ?? {},
-          ...context.spanAttributes ?? {}
-        }
-      );
-    } catch (error) {
-      const mapped = mapSlackError(error);
-      const retryClass = classifySlackRetry(error, mapped);
-      const isRetryable = retryClass === "rate_limited" || retryClass === "connection" || retryClass === "server_error" || retryClass === "timeout" && context.idempotent === true;
-      const remainingDelayBudgetMs = MAX_TOTAL_RETRY_DELAY_MS - totalDelayMs;
-      const baseLogAttributes = {
-        "app.slack.action": action,
-        "app.slack.error_code": mapped.code,
-        ...mapped.apiError ? { "app.slack.api_error": mapped.apiError } : void 0,
-        ...mapped.detail ? { "app.slack.detail": mapped.detail } : void 0,
-        ...mapped.detailLine !== void 0 ? { "app.slack.detail_line": mapped.detailLine } : void 0,
-        ...mapped.detailRule ? { "app.slack.detail_rule": mapped.detailRule } : void 0,
-        ...mapped.requestId ? { "app.slack.request_id": mapped.requestId } : void 0,
-        ...mapped.statusCode !== void 0 ? { "http.response.status_code": mapped.statusCode } : void 0,
-        ...context.attributes ?? {}
-      };
-      if (!isRetryable || attempt >= maxAttempts || remainingDelayBudgetMs <= 0) {
-        logWarn("slack.action.failed", {
-          ...baseLogAttributes,
-          ...mapped.errorData ? { "app.slack.error_data": mapped.errorData } : void 0
-        });
-        throw mapped;
-      }
-      logWarn("slack.action.retrying", {
-        ...baseLogAttributes,
-        "app.slack.retry_attempt": attempt,
-        "app.slack.retry_class": retryClass
-      });
-      const retryAfterMs = retryClass === "rate_limited" && mapped.retryAfterSeconds && mapped.retryAfterSeconds > 0 ? mapped.retryAfterSeconds * 1e3 : void 0;
-      const backoffMs = Math.min(2e3, 250 * 2 ** (attempt - 1));
-      const delayMs = Math.min(
-        retryAfterMs ?? backoffMs,
-        MAX_RETRY_DELAY_MS,
-        remainingDelayBudgetMs
-      );
-      totalDelayMs += delayMs;
-      await sleep(delayMs);
-    }
-  }
-  throw new SlackActionError(
-    "Slack action exhausted retries",
-    "internal_error"
-  );
-}
-function getSlackClient() {
-  return getClient();
-}
-function isDmChannel(channelId) {
-  const normalized = normalizeSlackConversationId(channelId);
-  return Boolean(normalized && normalized.startsWith("D"));
-}
-function isConversationScopedChannel(channelId) {
-  const normalized = normalizeSlackConversationId(channelId);
-  if (!normalized) return false;
-  return normalized.startsWith("C") || normalized.startsWith("G") || normalized.startsWith("D");
-}
-function isConversationChannel(channelId) {
-  const normalized = normalizeSlackConversationId(channelId);
-  if (!normalized) return false;
-  return normalized.startsWith("C") || normalized.startsWith("G");
-}
-async function getFilePermalink(fileId) {
-  const client = getClient();
-  const response = await withSlackRetries(
-    () => client.files.info({
-      file: fileId
-    }),
-    3,
-    {
-      action: "files.info",
-      idempotent: true,
-      spanAttributes: { "app.slack.file_id": fileId }
-    }
-  );
-  return response.file?.permalink;
-}
-async function downloadPrivateSlackFile(url) {
-  const token = resolveSlackToken();
-  return withSpan(
-    "GET files.slack.com",
-    "http.client",
-    {},
-    async () => {
-      const response = await fetch(url, {
-        headers: {
-          Authorization: `Bearer ${token}`
-        }
-      });
-      setSpanAttributes({ "http.response.status_code": response.status });
-      if (!response.ok) {
-        setSpanAttributes({ "error.type": String(response.status) });
-        setSpanStatus("error");
-        throw new Error(`Slack file download failed: ${response.status}`);
-      }
-      return Buffer.from(await response.arrayBuffer());
-    },
-    {
-      "http.request.method": "GET",
-      "server.address": "files.slack.com",
-      "url.scheme": "https",
-      "app.slack.method": "files.download"
-    }
-  );
-}
-
-// src/chat/credentials/subject.ts
-var CREDENTIAL_SUBJECT_HMAC_CONTEXT = "junior.credential_subject.v1";
-var CREDENTIAL_SUBJECT_SIGNATURE_VERSION = "v1";
-function getCredentialSubjectSecret() {
-  return process.env.JUNIOR_SECRET?.trim() || void 0;
-}
-function buildPayload(parts) {
-  return [CREDENTIAL_SUBJECT_HMAC_CONTEXT, ...parts].join("\0");
-}
-function signPayload(secret, payload) {
-  const digest2 = createHmac("sha256", secret).update(payload).digest("hex");
-  return `${CREDENTIAL_SUBJECT_SIGNATURE_VERSION}=${digest2}`;
-}
-function timingSafeMatch(expected, actual) {
-  const expectedBuffer = Buffer.from(expected);
-  const actualBuffer = Buffer.from(actual);
-  if (expectedBuffer.length !== actualBuffer.length) {
-    return false;
-  }
-  return timingSafeEqual(expectedBuffer, actualBuffer);
-}
-function createSlackDirectCredentialSubject(input) {
-  const channelId = normalizeSlackConversationId(input.channelId);
-  const teamId = input.teamId?.trim();
-  const userId = parseActorUserId(input.userId);
-  if (!channelId || !teamId || !userId || !isDmChannel(channelId)) {
-    return void 0;
-  }
-  return {
-    type: "user",
-    userId,
-    allowedWhen: "private-direct-conversation"
-  };
-}
-function bindSlackDirectCredentialSubject(input) {
-  const channelId = normalizeSlackConversationId(input.channelId);
-  const teamId = input.teamId.trim();
-  const secret = getCredentialSubjectSecret();
-  const { subject } = input;
-  const userId = parseActorUserId(subject.userId);
-  if (!channelId || !teamId || !secret || !isDmChannel(channelId) || subject.type !== "user" || !userId || subject.allowedWhen !== "private-direct-conversation") {
-    return void 0;
-  }
-  return {
-    type: "user",
-    userId,
-    allowedWhen: subject.allowedWhen,
-    binding: {
-      type: "slack-direct-conversation",
-      teamId,
-      channelId,
-      signature: signPayload(
-        secret,
-        buildPayload([subject.allowedWhen, teamId, channelId, userId])
-      )
-    }
-  };
-}
-function verifySlackDirectCredentialSubject(input) {
-  const channelId = normalizeSlackConversationId(input.channelId);
-  const secret = getCredentialSubjectSecret();
-  if (!channelId || !secret) {
-    return false;
-  }
-  const { subject } = input;
-  const binding = subject.binding;
-  if (subject.type !== "user" || !isActorUserId(subject.userId) || subject.allowedWhen !== "private-direct-conversation" || !binding || binding.type !== "slack-direct-conversation" || typeof binding.signature !== "string" || !binding.signature || binding.teamId !== input.teamId || binding.channelId !== channelId) {
-    return false;
-  }
-  const expected = signPayload(
-    secret,
-    buildPayload([
-      subject.allowedWhen,
-      binding.teamId,
-      binding.channelId,
-      subject.userId
-    ])
-  );
-  return timingSafeMatch(expected, binding.signature);
-}
-function bindScheduledTaskCredentialSubject(input) {
-  const secret = getCredentialSubjectSecret();
-  const plugin = input.plugin.trim();
-  const userId = parseActorUserId(input.subject.userId);
-  if (!secret || plugin !== "scheduler" || !userId || input.subject.allowedWhen !== "scheduled-task") {
-    return void 0;
-  }
-  const taskId = input.subject.taskId;
-  if (!taskId || taskId !== taskId.trim()) {
-    return void 0;
-  }
-  return {
-    type: "user",
-    userId,
-    allowedWhen: "scheduled-task",
-    taskId,
-    binding: {
-      type: "scheduled-task",
-      plugin,
-      taskId,
-      signature: signPayload(
-        secret,
-        buildPayload(["scheduled-task", plugin, taskId, userId])
-      )
-    }
-  };
-}
-function verifyScheduledTaskCredentialSubject(input) {
-  const secret = getCredentialSubjectSecret();
-  const { subject } = input;
-  const binding = subject.binding;
-  if (!secret || input.plugin !== "scheduler" || subject.type !== "user" || !isActorUserId(subject.userId) || subject.allowedWhen !== "scheduled-task" || !subject.taskId || binding.type !== "scheduled-task" || binding.plugin !== input.plugin || binding.taskId !== subject.taskId) {
-    return false;
-  }
-  const expected = signPayload(
-    secret,
-    buildPayload([
-      "scheduled-task",
-      binding.plugin,
-      binding.taskId,
-      subject.userId
-    ])
-  );
-  return timingSafeMatch(expected, binding.signature);
-}
-function bindEventTaskCredentialSubject(input) {
-  const secret = getCredentialSubjectSecret();
-  const plugin = input.plugin.trim();
-  const userId = parseActorUserId(input.subject.userId);
-  if (!secret || plugin !== "junior" || !userId || input.subject.allowedWhen !== "event-task") {
-    return void 0;
-  }
-  const taskId = input.subject.taskId;
-  if (!taskId || taskId !== taskId.trim()) {
-    return void 0;
-  }
-  return {
-    type: "user",
-    userId,
-    allowedWhen: "event-task",
-    taskId,
-    binding: {
-      type: "event-task",
-      plugin,
-      taskId,
-      signature: signPayload(
-        secret,
-        buildPayload(["event-task", plugin, taskId, userId])
-      )
-    }
-  };
-}
-function verifyEventTaskCredentialSubject(input) {
-  const secret = getCredentialSubjectSecret();
-  const { subject } = input;
-  const binding = subject.binding;
-  if (!secret || input.plugin !== "junior" || subject.type !== "user" || !isActorUserId(subject.userId) || subject.allowedWhen !== "event-task" || !subject.taskId || binding.type !== "event-task" || binding.plugin !== input.plugin || binding.taskId !== subject.taskId) {
-    return false;
-  }
-  const expected = signPayload(
-    secret,
-    buildPayload([
-      "event-task",
-      binding.plugin,
-      binding.taskId,
-      subject.userId
-    ])
-  );
-  return timingSafeMatch(expected, binding.signature);
-}
-
-// src/chat/slack/tool-support/channel-capabilities.ts
-function resolveChannelCapabilities(channelId) {
-  return {
-    canCreateCanvas: isConversationScopedChannel(channelId),
-    canSendFiles: isConversationScopedChannel(channelId),
-    canPostToChannel: isConversationChannel(channelId),
-    canAddReactions: isConversationScopedChannel(channelId)
-  };
-}
-
-// src/chat/plugins/agent-hooks.ts
-import { z as z3 } from "zod";
-
-// src/chat/workspaces/checkout-path.ts
-function tryWorkspaceRepoCheckoutPath(repo) {
-  const name = repo.split("/").filter(Boolean).at(-1);
-  if (!name || name === "." || name === ".." || !/^[A-Za-z0-9._-]+$/.test(name)) {
-    return void 0;
-  }
-  return `repos/${name}`;
-}
-function workspaceRepoCheckoutPath(repo) {
-  const path = tryWorkspaceRepoCheckoutPath(repo);
-  if (!path) {
-    throw new Error(`Invalid repository name for checkout path: ${repo}`);
-  }
-  return path;
-}
-
-// src/chat/workspaces/store.ts
-import { randomUUID as randomUUID2 } from "crypto";
-import { and as and5, asc as asc3, eq as eq5, sql as sql2 } from "drizzle-orm";
-
-// src/chat/sandbox/snapshot/builder-sandbox.ts
-import { Sandbox } from "@vercel/sandbox";
-async function getWorkspaceSnapshotBuilder(name, signal) {
-  const credentials = getVercelSandboxCredentials();
-  return await Sandbox.get({
-    name,
-    resume: true,
-    signal,
-    ...credentials ?? {}
-  });
-}
-async function deleteWorkspaceSnapshotBuilders(names) {
-  const credentials = getVercelSandboxCredentials();
-  let hasError = false;
-  let firstError;
-  for (const name of new Set(names)) {
-    try {
-      const sandbox = await Sandbox.get({
-        name,
-        resume: false,
-        ...credentials ?? {}
-      });
-      await sandbox.delete();
-    } catch (error) {
-      if (!isSandboxMissingError(error)) {
-        if (!hasError) firstError = error;
-        hasError = true;
-      }
-    }
-  }
-  if (hasError) throw firstError;
-}
-
-// src/chat/sandbox/snapshot/runtime.ts
-var SANDBOX_RUNTIME = "node22";
-
-// src/chat/sandbox/snapshot/store.ts
-import { and as and4, asc as asc2, desc as desc2, eq as eq4, ne, or } from "drizzle-orm";
-function builderNames(rows) {
-  return [
-    ...new Set(
-      rows.map((row) => row.sandboxName).filter((name) => Boolean(name))
-    )
-  ];
-}
-function sameWorkspaceRecipe(stored, expected) {
-  if (stored.setupScript !== expected.setupScript || stored.repos.length !== expected.repos.length) {
-    return false;
-  }
-  const expectedRepos = new Set(
-    expected.repos.map((repo) => JSON.stringify([repo.provider, repo.repo]))
-  );
-  return stored.repos.every(
-    (repo) => expectedRepos.has(JSON.stringify([repo.provider, repo.repo]))
-  );
-}
-function snapshotFromRow(row) {
-  if (row.status !== "ready" || !row.snapshotId || !row.generatedAt || row.buildDurationMs == null) {
-    throw new Error(`Invalid ready Workspace snapshot row: ${row.id}`);
-  }
-  return {
-    id: row.snapshotId,
-    generatedAt: row.generatedAt,
-    buildDurationMs: row.buildDurationMs,
-    sizeBytes: row.sizeBytes,
-    profileHash: row.profileHash
-  };
-}
-function snapshotBuildFromRow(row) {
-  if (row.status === "ready" || !row.buildStartedAt || !row.buildPhase) {
-    throw new Error(`Invalid Workspace snapshot build row: ${row.id}`);
-  }
-  return {
-    id: row.id,
-    status: row.status,
-    phase: row.buildPhase,
-    profileHash: row.profileHash,
-    startedAt: row.buildStartedAt,
-    sandboxName: row.buildSandboxName,
-    commandId: row.buildCommandId,
-    error: row.buildError
-  };
-}
-async function loadSnapshotsForProfile(db, workspaceId, profileHash) {
-  const profile = and4(
-    eq4(juniorSnapshots.workspaceId, workspaceId),
-    eq4(juniorSnapshots.profileHash, profileHash)
-  );
-  const order = [
-    desc2(juniorSnapshots.updatedAt),
-    desc2(juniorSnapshots.createdAt),
-    desc2(juniorSnapshots.id)
-  ];
-  const [readyRows, buildRows] = await Promise.all([
-    db.select().from(juniorSnapshots).where(and4(profile, eq4(juniorSnapshots.status, "ready"))).orderBy(...order).limit(1),
-    db.select().from(juniorSnapshots).where(and4(profile, ne(juniorSnapshots.status, "ready"))).orderBy(asc2(juniorSnapshots.status), ...order).limit(1)
-  ]);
-  return {
-    ready: readyRows[0] ? snapshotFromRow(readyRows[0]) : null,
-    build: buildRows[0] ? snapshotBuildFromRow(buildRows[0]) : null
-  };
-}
-async function clearWorkspaceSnapshots(db, workspaceId) {
-  await db.select({ id: juniorWorkspaces.id }).from(juniorWorkspaces).where(eq4(juniorWorkspaces.id, workspaceId)).for("update");
-  const deleted = await db.delete(juniorSnapshots).where(eq4(juniorSnapshots.workspaceId, workspaceId)).returning({ sandboxName: juniorSnapshots.buildSandboxName });
-  return builderNames(deleted);
-}
-async function invalidateReadySnapshot(params) {
-  const executor = getSqlExecutor();
-  return await executor.transaction(async () => {
-    const db = executor.db();
-    const deleted = await db.delete(juniorSnapshots).where(
-      and4(
-        eq4(juniorSnapshots.workspaceId, params.workspaceId),
-        eq4(juniorSnapshots.profileHash, params.profileHash),
-        eq4(juniorSnapshots.status, "ready"),
-        eq4(juniorSnapshots.snapshotId, params.snapshotId)
-      )
-    ).returning({ sandboxName: juniorSnapshots.buildSandboxName });
-    return deleted[0]?.sandboxName ?? null;
-  });
-}
-async function setWorkspaceSnapshot(workspaceId, snapshot, options) {
-  const executor = getSqlExecutor();
-  return await executor.transaction(async () => {
-    const db = executor.db();
-    const now = /* @__PURE__ */ new Date();
-    const updated = await db.update(juniorSnapshots).set({
-      status: "ready",
-      snapshotId: snapshot.id,
-      buildDurationMs: snapshot.buildDurationMs,
-      sizeBytes: snapshot.sizeBytes,
-      generatedAt: snapshot.generatedAt,
-      buildStartedAt: null,
-      buildPhase: null,
-      buildCommandId: null,
-      buildError: null,
-      updatedAt: now
-    }).where(
-      and4(
-        eq4(juniorSnapshots.id, options.buildId),
-        eq4(juniorSnapshots.workspaceId, workspaceId),
-        eq4(juniorSnapshots.profileHash, snapshot.profileHash),
-        eq4(juniorSnapshots.status, "building")
-      )
-    ).returning({ id: juniorSnapshots.id });
-    if (updated.length === 0) {
-      return { written: false, replacedBuilderNames: [] };
-    }
-    const replaced = await db.delete(juniorSnapshots).where(
-      and4(
-        eq4(juniorSnapshots.workspaceId, workspaceId),
-        eq4(juniorSnapshots.profileHash, snapshot.profileHash),
-        ne(juniorSnapshots.id, options.buildId),
-        or(
-          eq4(juniorSnapshots.status, "failed"),
-          eq4(juniorSnapshots.status, "ready")
-        )
-      )
-    ).returning({ sandboxName: juniorSnapshots.buildSandboxName });
-    return {
-      written: true,
-      replacedBuilderNames: builderNames(replaced)
-    };
-  });
-}
-async function setWorkspaceSnapshotBuild(workspaceId, build, options = {}) {
-  const executor = getSqlExecutor();
-  return await executor.transaction(async () => {
-    const db = executor.db();
-    const now = /* @__PURE__ */ new Date();
-    const updated = await db.update(juniorSnapshots).set({
-      status: build.status,
-      buildStartedAt: build.startedAt,
-      buildPhase: build.phase,
-      buildSandboxName: build.sandboxName,
-      buildCommandId: build.commandId,
-      buildError: build.error,
-      updatedAt: now
-    }).where(
-      and4(
-        eq4(juniorSnapshots.id, build.id),
-        eq4(juniorSnapshots.workspaceId, workspaceId),
-        eq4(juniorSnapshots.profileHash, build.profileHash),
-        eq4(juniorSnapshots.status, "building")
-      )
-    ).returning({ id: juniorSnapshots.id });
-    if (updated.length > 0) {
-      return true;
-    }
-    if (!options.insertIfMissing) return false;
-    const workspaceRows = await db.select({ setupScript: juniorWorkspaces.setupScript }).from(juniorWorkspaces).where(eq4(juniorWorkspaces.id, workspaceId)).for("update");
-    const workspace = workspaceRows[0];
-    if (!workspace) return false;
-    if (options.expectedRecipe) {
-      const repos = await db.select({
-        provider: juniorWorkspaceRepos.provider,
-        repo: juniorWorkspaceRepos.repo
-      }).from(juniorWorkspaceRepos).where(eq4(juniorWorkspaceRepos.workspaceId, workspaceId));
-      if (!sameWorkspaceRecipe({ ...workspace, repos }, options.expectedRecipe)) {
-        return false;
-      }
-    }
-    const inserted = await db.insert(juniorSnapshots).values({
-      id: build.id,
-      workspaceId,
-      profileHash: build.profileHash,
-      status: build.status,
-      snapshotId: null,
-      buildDurationMs: null,
-      sizeBytes: null,
-      generatedAt: null,
-      buildStartedAt: build.startedAt,
-      buildPhase: build.phase,
-      buildSandboxName: build.sandboxName,
-      buildCommandId: build.commandId,
-      buildError: build.error,
-      createdAt: now,
-      updatedAt: now
-    }).onConflictDoNothing().returning({ id: juniorSnapshots.id });
-    return inserted.length > 0;
-  });
-}
-
-// src/chat/workspaces/validation.ts
-var WORKSPACE_NAME_PATTERN = /^[a-z][a-z0-9_-]{0,63}$/;
-var PROVIDER_PATTERN = /^[a-z][a-z0-9_-]{0,63}$/;
-var REPO_PATTERN = /^[A-Za-z0-9._-]+\/[A-Za-z0-9._-]+$/;
-var MAX_SETUP_SCRIPT_BYTES = 64 * 1024;
-var MAX_REPOS = 32;
-var WorkspaceValidationError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "WorkspaceValidationError";
-  }
-};
-function normalizeWorkspaceRecipe(input) {
-  const name = input.name.trim().toLowerCase();
-  if (!WORKSPACE_NAME_PATTERN.test(name)) {
-    throw new WorkspaceValidationError(
-      "Workspace name must start with a letter and use only lowercase letters, digits, underscores, or hyphens."
-    );
-  }
-  const setupScript = input.setupScript ?? "";
-  if (typeof setupScript !== "string") {
-    throw new WorkspaceValidationError("Setup script must be a string.");
-  }
-  if (Buffer.byteLength(setupScript, "utf8") > MAX_SETUP_SCRIPT_BYTES) {
-    throw new WorkspaceValidationError(
-      `Setup script must be at most ${MAX_SETUP_SCRIPT_BYTES} bytes.`
-    );
-  }
-  if (!Array.isArray(input.repos)) {
-    throw new WorkspaceValidationError("Repositories must be an array.");
-  }
-  if (input.repos.length > MAX_REPOS) {
-    throw new WorkspaceValidationError(
-      `A Workspace can include at most ${MAX_REPOS} repositories.`
-    );
-  }
-  const repos = input.repos.map((entry, index) => {
-    const provider = entry.provider.trim().toLowerCase();
-    if (!PROVIDER_PATTERN.test(provider)) {
-      throw new WorkspaceValidationError(
-        `Repository ${index + 1} provider is invalid.`
-      );
-    }
-    const repo = entry.repo.trim();
-    if (!REPO_PATTERN.test(repo)) {
-      throw new WorkspaceValidationError(
-        `Repository ${index + 1} must use owner/name format.`
-      );
-    }
-    if (!tryWorkspaceRepoCheckoutPath(repo)) {
-      throw new WorkspaceValidationError(
-        `Repository ${index + 1} name cannot be used as a checkout path.`
-      );
-    }
-    return {
-      provider,
-      repo
-    };
-  });
-  const identities = /* @__PURE__ */ new Set();
-  for (const repo of repos) {
-    const identity = `${repo.provider}:${repo.repo.toLowerCase()}`;
-    if (identities.has(identity)) {
-      throw new WorkspaceValidationError(
-        `Duplicate repository in Workspace: ${repo.provider}:${repo.repo}`
-      );
-    }
-    identities.add(identity);
-  }
-  const checkoutPaths = /* @__PURE__ */ new Set();
-  for (const repo of repos) {
-    const path = tryWorkspaceRepoCheckoutPath(repo.repo);
-    const key = path.toLowerCase();
-    if (checkoutPaths.has(key)) {
-      throw new WorkspaceValidationError(
-        `Workspace checkout path collision: ${path}`
-      );
-    }
-    checkoutPaths.add(key);
-  }
-  return { name, setupScript, repos };
-}
-
-// src/chat/workspaces/store.ts
-function workspaceFromRows(row, repos, snapshot) {
-  return {
-    id: row.id,
-    name: row.name,
-    setupScript: row.setupScript,
-    repos: repos.map((repo) => ({
-      provider: repo.provider,
-      repo: repo.repo
-    })),
-    snapshot
-  };
-}
-async function workspaceWithSnapshot(db, row, repos) {
-  const workspace = workspaceFromRows(row, repos, null);
-  const profileHash = hash(SANDBOX_RUNTIME, workspace);
-  if (!profileHash) return workspace;
-  const snapshots = await loadSnapshotsForProfile(
-    db,
-    workspace.id,
-    profileHash
-  );
-  return { ...workspace, snapshot: snapshots.ready };
-}
-async function loadWorkspaceRepos(db, workspaceId) {
-  return await db.select().from(juniorWorkspaceRepos).where(eq5(juniorWorkspaceRepos.workspaceId, workspaceId)).orderBy(
-    asc3(juniorWorkspaceRepos.provider),
-    asc3(juniorWorkspaceRepos.repo)
-  );
-}
-async function replaceWorkspaceRepos(db, workspaceId, repos) {
-  await db.delete(juniorWorkspaceRepos).where(eq5(juniorWorkspaceRepos.workspaceId, workspaceId));
-  if (repos.length === 0) return;
-  await db.insert(juniorWorkspaceRepos).values(
-    repos.map((repo) => ({
-      workspaceId,
-      provider: repo.provider,
-      repo: repo.repo
-    }))
-  );
-}
-function sameWorkspaceRepos(current, next) {
-  if (current.length !== next.length) return false;
-  const identity = (repo) => `${repo.provider}:${repo.repo.toLowerCase()}`;
-  const currentIds = current.map(identity).sort();
-  const nextIds = next.map(identity).sort();
-  return currentIds.every((value, index) => value === nextIds[index]);
-}
-function isUniqueViolation(error) {
-  let current = error;
-  for (let depth = 0; current && depth < 6; depth += 1) {
-    if (typeof current === "object" && current !== null && "code" in current && current.code === "23505") {
-      return true;
-    }
-    current = typeof current === "object" && current !== null && "cause" in current ? current.cause : void 0;
-  }
-  return false;
-}
-async function cleanupSnapshotBuilders(workspaceId, names) {
-  if (names.length === 0) return;
-  try {
-    await deleteWorkspaceSnapshotBuilders(names);
-  } catch (error) {
-    logException(error, "sandbox.workspace_snapshot.builder.delete_failed", {
-      "app.workspace.id": workspaceId,
-      "app.sandbox.snapshot.builder_count": names.length
-    });
-  }
-}
-async function listWorkspaces(db) {
-  const [workspaces, repos] = await Promise.all([
-    db.select().from(juniorWorkspaces).orderBy(asc3(juniorWorkspaces.name)),
-    db.select().from(juniorWorkspaceRepos).orderBy(
-      asc3(juniorWorkspaceRepos.workspaceId),
-      asc3(juniorWorkspaceRepos.provider),
-      asc3(juniorWorkspaceRepos.repo)
-    )
-  ]);
-  return workspaces.map(
-    (workspace) => workspaceFromRows(
-      workspace,
-      repos.filter((repo) => repo.workspaceId === workspace.id),
-      null
-    )
-  );
-}
-async function listWorkspaceNamesByRepository(db, input) {
-  const provider = input.provider.trim().toLowerCase();
-  const repo = input.repo.trim();
-  const rows = await db.select({ name: juniorWorkspaces.name }).from(juniorWorkspaceRepos).innerJoin(
-    juniorWorkspaces,
-    eq5(juniorWorkspaces.id, juniorWorkspaceRepos.workspaceId)
-  ).where(
-    and5(
-      eq5(juniorWorkspaceRepos.provider, provider),
-      // Recipes store the provided repo casing; identity is case-insensitive.
-      sql2`lower(${juniorWorkspaceRepos.repo}) = lower(${repo})`
-    )
-  ).orderBy(asc3(juniorWorkspaces.name));
-  return rows.map((row) => row.name);
-}
-async function getWorkspaceByName(db, name) {
-  const rows = await db.select().from(juniorWorkspaces).where(eq5(juniorWorkspaces.name, name)).limit(1);
-  const workspace = rows[0];
-  if (!workspace) return void 0;
-  return await workspaceWithSnapshot(
-    db,
-    workspace,
-    await loadWorkspaceRepos(db, workspace.id)
-  );
-}
-async function getWorkspace(db, id) {
-  const rows = await db.select().from(juniorWorkspaces).where(eq5(juniorWorkspaces.id, id)).limit(1);
-  const workspace = rows[0];
-  if (!workspace) return void 0;
-  return await workspaceWithSnapshot(
-    db,
-    workspace,
-    await loadWorkspaceRepos(db, workspace.id)
-  );
-}
-async function createWorkspace(input) {
-  const recipe = normalizeWorkspaceRecipe(input);
-  const executor = getSqlExecutor();
-  const now = /* @__PURE__ */ new Date();
-  const id = randomUUID2();
-  try {
-    await executor.transaction(async () => {
-      const db = executor.db();
-      await db.insert(juniorWorkspaces).values({
-        id,
-        name: recipe.name,
-        setupScript: recipe.setupScript,
-        createdAt: now,
-        updatedAt: now
-      });
-      await replaceWorkspaceRepos(db, id, recipe.repos);
-    });
-  } catch (error) {
-    if (isUniqueViolation(error)) {
-      throw new WorkspaceValidationError(
-        `Workspace name already exists: ${recipe.name}`
-      );
-    }
-    throw error;
-  }
-  return await getWorkspace(executor.db(), id);
-}
-async function updateWorkspace(id, input) {
-  const recipe = normalizeWorkspaceRecipe(input);
-  const executor = getSqlExecutor();
-  const now = /* @__PURE__ */ new Date();
-  try {
-    const result = await executor.transaction(async () => {
-      const db = executor.db();
-      const existingRows = await db.select().from(juniorWorkspaces).where(eq5(juniorWorkspaces.id, id)).limit(1);
-      const existing = existingRows[0];
-      if (!existing) return void 0;
-      const existingRepos = await loadWorkspaceRepos(db, id);
-      const snapshotChanged = existing.setupScript !== recipe.setupScript || !sameWorkspaceRepos(existingRepos, recipe.repos);
-      const rows = await db.update(juniorWorkspaces).set({
-        name: recipe.name,
-        setupScript: recipe.setupScript,
-        updatedAt: now
-      }).where(eq5(juniorWorkspaces.id, id)).returning();
-      await replaceWorkspaceRepos(db, id, recipe.repos);
-      const builderNames2 = snapshotChanged ? await clearWorkspaceSnapshots(db, id) : [];
-      return { builderNames: builderNames2, workspace: rows[0] };
-    });
-    if (!result) return void 0;
-    await cleanupSnapshotBuilders(id, result.builderNames);
-  } catch (error) {
-    if (isUniqueViolation(error)) {
-      throw new WorkspaceValidationError(
-        `Workspace name already exists: ${recipe.name}`
-      );
-    }
-    throw error;
-  }
-  return await getWorkspace(executor.db(), id);
-}
-async function deleteWorkspace(id) {
-  const executor = getSqlExecutor();
-  const result = await executor.transaction(async () => {
-    const db = executor.db();
-    const builderNames2 = await clearWorkspaceSnapshots(db, id);
-    const rows = await db.delete(juniorWorkspaces).where(eq5(juniorWorkspaces.id, id)).returning({ id: juniorWorkspaces.id });
-    return { builderNames: builderNames2, deleted: rows.length > 0 };
-  });
-  await cleanupSnapshotBuilders(id, result.builderNames);
-  return result.deleted;
-}
-
-// src/chat/code/store.ts
-import { randomUUID as randomUUID3 } from "crypto";
-import { and as and6, eq as eq6, lte, sql as sql3 } from "drizzle-orm";
-import {
-  codeChangeInputSchema
-} from "@sentry/junior-plugin-api";
-async function recordCodeChange(db, provider, input) {
-  const change = codeChangeInputSchema.parse(input);
-  const repositories = await db.insert(juniorCodeRepositories).values({
-    id: randomUUID3(),
-    name: change.repository.name,
-    provider,
-    providerId: change.repository.providerId,
-    url: change.repository.url,
-    updatedAt: change.updatedAt
-  }).onConflictDoUpdate({
-    target: [
-      juniorCodeRepositories.provider,
-      juniorCodeRepositories.providerId
-    ],
-    set: {
-      name: change.repository.name,
-      ...change.repository.url ? { url: change.repository.url } : void 0,
-      updatedAt: change.updatedAt
-    },
-    where: lte(juniorCodeRepositories.updatedAt, change.updatedAt)
-  }).returning({ id: juniorCodeRepositories.id });
-  const existingRepositories = repositories[0] ? [] : await db.select({ id: juniorCodeRepositories.id }).from(juniorCodeRepositories).where(
-    and6(
-      eq6(juniorCodeRepositories.provider, provider),
-      eq6(juniorCodeRepositories.providerId, change.repository.providerId)
-    )
-  ).limit(1);
-  const repositoryId = repositories[0]?.id ?? existingRepositories[0]?.id;
-  if (!repositoryId) {
-    throw new Error("Code repository upsert returned no row");
-  }
-  const conversationIds = sql3.join(
-    change.conversationIds.map((conversationId) => sql3`${conversationId}`),
-    sql3`, `
-  );
-  const values = {
-    closedAt: change.closedAt ?? null,
-    conversationIds: change.conversationIds.length > 0 ? sql3`ARRAY(
-            SELECT DISTINCT value
-            FROM unnest(
-              ${juniorCodeChanges.conversationIds}
-              || ARRAY[${conversationIds}]::text[]
-            ) AS value
-            ORDER BY value
-          )` : juniorCodeChanges.conversationIds,
-    mergedAt: change.mergedAt ?? null,
-    number: change.number,
-    openedAt: change.openedAt,
-    repositoryId,
-    state: change.state,
-    ...change.title ? { title: change.title } : void 0,
-    updatedAt: change.updatedAt,
-    url: change.url ?? null
-  };
-  await db.insert(juniorCodeChanges).values({
-    ...values,
-    conversationIds: change.conversationIds,
-    id: randomUUID3(),
-    provider,
-    providerId: change.providerId
-  }).onConflictDoUpdate({
-    target: [juniorCodeChanges.provider, juniorCodeChanges.providerId],
-    set: values,
-    where: lte(juniorCodeChanges.updatedAt, change.updatedAt)
-  });
-}
-async function associateCodeChangeConversations(db, provider, input) {
-  if (input.conversationIds.length === 0) return;
-  const conversationIds = sql3.join(
-    input.conversationIds.map((conversationId) => sql3`${conversationId}`),
-    sql3`, `
-  );
-  await db.update(juniorCodeChanges).set({
-    conversationIds: sql3`ARRAY(
-        SELECT DISTINCT value
-        FROM unnest(
-          ${juniorCodeChanges.conversationIds}
-          || ARRAY[${conversationIds}]::text[]
-        ) AS value
-        ORDER BY value
-      )`
-  }).where(
-    and6(
-      eq6(juniorCodeChanges.provider, provider),
-      eq6(juniorCodeChanges.providerId, input.providerId)
-    )
-  );
-}
-
-// src/chat/code/publisher.ts
-function createCodeChangePublisher(provider) {
-  return {
-    async associateConversations(input) {
-      await associateCodeChangeConversations(getDb(), provider, input);
-    },
-    async record(input) {
-      await recordCodeChange(getDb(), provider, input);
-    }
-  };
-}
-
-// src/chat/plugins/agent-hooks.ts
-var PluginHookDeniedError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "PluginHookDeniedError";
-  }
-};
-var registeredPlugins = [];
-var PLUGIN_NAME_RE = /^[a-z][a-z0-9-]*$/;
-var PLUGIN_TOOL_NAME_RE = /^[a-z][A-Za-z0-9]*$/;
-var OPERATIONAL_REPORT_MAX_METRICS = 8;
-var OPERATIONAL_REPORT_MAX_WIDGETS = 12;
-var OPERATIONAL_REPORT_MAX_CHART_SERIES = 8;
-var OPERATIONAL_REPORT_MAX_CHART_CATEGORIES = 100;
-var OPERATIONAL_REPORT_MAX_RECORD_SETS = 8;
-var OPERATIONAL_REPORT_MAX_FIELDS = 8;
-var OPERATIONAL_REPORT_MAX_RECORDS = 25;
-var OPERATIONAL_REPORT_MAX_LABEL_LENGTH = 80;
-var OPERATIONAL_REPORT_MAX_VALUE_LENGTH = 160;
-var PLUGIN_ROUTE_METHODS = /* @__PURE__ */ new Set([
-  "GET",
-  "POST",
-  "PUT",
-  "PATCH",
-  "DELETE",
-  "HEAD",
-  "OPTIONS",
-  "ALL"
-]);
-var PLUGIN_PROMPT_CONTRIBUTION_TOTAL_MAX_CHARS = 16e3;
-var PLUGIN_PROMPT_CONTEXT_MAX_BYTES = 8e3;
-var PLUGIN_PROMPT_CONTEXT_TOTAL_MAX_BYTES = 16e3;
-var systemPromptMessageArraySchema = z3.array(promptMessageSchema);
-function isRecord(value) {
-  return Boolean(value && typeof value === "object" && !Array.isArray(value));
-}
-function basePluginContext(plugin) {
-  const name = plugin.manifest.name;
-  return {
-    plugin: { name },
-    log: createPluginLogger(name),
-    db: getDb()
-  };
-}
-function pluginToolNamespace(pluginName) {
-  const parts = pluginName.split("-").filter(Boolean);
-  const [first = "plugin", ...rest] = parts;
-  return `${first}${rest.map((part) => `${part[0]?.toUpperCase() ?? ""}${part.slice(1)}`).join("")}`;
-}
-function systemPromptPluginContext(plugin) {
-  return {
-    ...basePluginContext(plugin)
-  };
-}
-function pluginInvocationContext(context) {
-  const common = {
-    conversationId: context.conversationId,
-    locationId: context.locationId
-  };
-  switch (context.source.kind) {
-    case "slack": {
-      if (context.destination.platform !== "slack") {
-        throw new TypeError("Slack plugin context requires Slack destination");
-      }
-      return {
-        ...common,
-        actor: context.actor?.platform === "slack" ? context.actor : void 0,
-        destination: context.destination,
-        source: context.source
-      };
-    }
-    case "local": {
-      if (context.destination.platform !== "local") {
-        throw new TypeError("Local plugin context requires local destination");
-      }
-      return {
-        ...common,
-        actor: context.actor?.platform === "local" ? context.actor : void 0,
-        destination: context.destination,
-        source: context.source
-      };
-    }
-    case "web":
-      return {
-        ...common,
-        actor: context.actor?.platform === "web" ? context.actor : void 0,
-        destination: context.destination,
-        source: context.source
-      };
-    case "resource_event":
-    case "scheduled_task":
-    case "event_task":
-    case "plugin_dispatch":
-    case "agent_invocation":
-      return {
-        ...common,
-        actor: context.actor,
-        destination: context.destination,
-        source: context.source
-      };
-  }
-}
-function invocationPluginContext(plugin, context, turnId) {
-  const base = basePluginContext(plugin);
-  const common = {
-    ...base,
-    conversationId: context.conversationId,
-    locationId: context.locationId,
-    embedder: createPluginEmbedder(plugin.manifest.name),
-    ...context.conversationId && turnId ? {
-      events: createPluginConversationEvents({
-        conversationId: context.conversationId,
-        operationId: `user-prompt:${turnId}`,
-        plugin,
-        turnId
-      })
-    } : void 0,
-    model: createPluginModel(plugin.manifest.name, plugin.model),
-    source: context.source,
-    text: context.userText ?? "",
-    state: createPluginState(plugin.manifest.name),
-    users: {
-      resolveActor: context.resolveActorIdentity ?? (async () => void 0)
-    }
-  };
-  return {
-    ...common,
-    ...pluginInvocationContext(context)
-  };
-}
-function pluginMcpContext(plugin, context) {
-  const manager = context.mcpToolManager;
-  const wrappedTools = new Set(plugin.manifest.mcp?.wrappedTools ?? []);
-  if (!manager || wrappedTools.size === 0) {
-    return void 0;
-  }
-  const provider = plugin.manifest.name;
-  const prepare = async () => {
-    await manager.activateProvider(provider);
-    return manager.getActiveProviders().includes(provider) ? "ready" : "authorization_pending";
-  };
-  return {
-    prepare,
-    async callTool(input) {
-      if (await prepare() === "authorization_pending") {
-        return { status: "authorization_pending" };
-      }
-      return await manager.callWrappedTool(
-        provider,
-        input.name,
-        input.arguments ?? {},
-        input.toolCallId ? { toolCallId: input.toolCallId } : void 0
-      );
-    }
-  };
-}
-function safeErrorMessage(error) {
-  return error instanceof Error ? error.message : String(error);
-}
-function toPromptContributionContext(args) {
-  return {
-    id: `${args.hookName}:${args.index}`,
-    pluginName: args.pluginName,
-    text: args.message.text
-  };
-}
-function normalizePromptContext(value) {
-  const serialized = JSON.stringify(value);
-  if (serialized === void 0 || Buffer.byteLength(serialized, "utf8") > PLUGIN_PROMPT_CONTEXT_MAX_BYTES) {
-    throw new TypeError("Plugin prompt context exceeded its serialized budget");
-  }
-  const parsed = JSON.parse(serialized);
-  if (!isRecord(parsed)) {
-    throw new TypeError("Plugin prompt context must be a JSON object");
-  }
-  return parsed;
-}
-function toUserPromptContributionContext(args) {
-  const message = promptMessageSchema.safeParse(args.value);
-  if (message.success) {
-    return toPromptContributionContext({
-      hookName: "userPrompt",
-      index: args.index,
-      message: message.data,
-      pluginName: args.pluginName
-    });
-  }
-  if (!isRecord(args.value) || typeof args.value.renderPrompt !== "function") {
-    return void 0;
-  }
-  const context = promptContextSchema.safeParse(args.value.context);
-  if (!context.success) {
-    return void 0;
-  }
-  const text = promptMessageSchema.safeParse({
-    text: args.value.renderPrompt()
-  });
-  if (!text.success) {
-    return void 0;
-  }
-  return {
-    id: `userPrompt:${args.index}`,
-    pluginName: args.pluginName,
-    text: text.data.text,
-    context: {
-      content: normalizePromptContext(context.data.content),
-      kind: context.data.kind,
-      loadedAtMs: Date.now(),
-      pluginName: args.pluginName,
-      version: context.data.version
-    }
-  };
-}
-function logInvalidPromptContributions(args) {
-  logWarn("plugin.prompt.contribution_result.invalid", {
-    "app.plugin.hook": args.hookName,
-    "app.plugin.name": args.pluginName,
-    "app.plugin.validation_reason": "invalid_shape"
-  });
-}
-function validatePlugins(plugins) {
-  const seen = /* @__PURE__ */ new Set();
-  for (const plugin of plugins) {
-    const name = plugin.manifest.name;
-    if (!PLUGIN_NAME_RE.test(name)) {
-      throw new Error(
-        `Plugin name "${name}" must be a lowercase plugin identifier`
-      );
-    }
-    if (seen.has(name)) {
-      throw new Error(`Duplicate plugin name "${name}"`);
-    }
-    if (plugin.resourceEvents !== void 0 && !pluginResourceEventsSchema.safeParse(plugin.resourceEvents).success) {
-      throw new Error(`Plugin "${name}" resourceEvents is invalid`);
-    }
-    for (const [taskName, task] of Object.entries(plugin.tasks ?? {})) {
-      if (!PLUGIN_TOOL_NAME_RE.test(taskName)) {
-        throw new Error(
-          `Plugin task "${taskName}" from plugin "${name}" must be a camelCase identifier`
-        );
-      }
-      if (typeof task.run !== "function") {
-        throw new Error(
-          `Plugin task "${taskName}" from plugin "${name}" must define a run function`
-        );
-      }
-    }
-    seen.add(name);
-  }
-}
-function setPlugins(nextPlugins) {
-  validatePlugins(nextPlugins);
-  const previous = registeredPlugins;
-  registeredPlugins = [...nextPlugins].sort(
-    (left, right) => left.manifest.name.localeCompare(right.manifest.name)
-  );
-  return previous;
-}
-function getPlugins() {
-  return [...registeredPlugins];
-}
-function applyPluginFormatMarkdown(text) {
-  let transformed = text;
-  for (const plugin of getPlugins()) {
-    const hook = plugin.hooks?.formatMarkdown;
-    if (!hook) {
-      continue;
-    }
-    try {
-      const next = hook({ text: transformed });
-      if (typeof next === "string") {
-        transformed = next;
-      }
-    } catch (error) {
-      logWarn("plugin.format_markdown.hook.failed", {
-        "app.plugin.name": plugin.manifest.name,
-        "exception.message": safeErrorMessage(error)
-      });
-    }
-  }
-  return transformed;
-}
-async function getPluginSystemPromptContributions(platform) {
-  const contributions = [];
-  let totalChars = 0;
-  for (const plugin of getPlugins()) {
-    const pluginName = plugin.manifest.name;
-    const hook = plugin.hooks?.systemPrompt;
-    if (!hook) {
-      continue;
-    }
-    try {
-      const pluginContributions = await hook({
-        ...systemPromptPluginContext(plugin),
-        platform
-      });
-      const result = systemPromptMessageArraySchema.safeParse(pluginContributions);
-      if (!result.success) {
-        logInvalidPromptContributions({
-          hookName: "systemPrompt",
-          pluginName
-        });
-        continue;
-      }
-      const acceptedContributions = result.data.map(
-        (message, index) => toPromptContributionContext({
-          hookName: "systemPrompt",
-          index,
-          message,
-          pluginName
-        })
-      );
-      const pluginContributionChars = acceptedContributions.reduce(
-        (sum, contribution) => sum + contribution.text.length,
-        0
-      );
-      if (totalChars + pluginContributionChars > PLUGIN_PROMPT_CONTRIBUTION_TOTAL_MAX_CHARS) {
-        logWarn("plugin.system_prompt.contribution_budget_exceeded", {
-          "app.plugin.name": pluginName
-        });
-        continue;
-      }
-      totalChars += pluginContributionChars;
-      contributions.push(...acceptedContributions);
-    } catch (error) {
-      logWarn("plugin.system_prompt.hook.failed", {
-        "app.plugin.name": pluginName,
-        "exception.message": safeErrorMessage(error)
-      });
-    }
-  }
-  return contributions;
-}
-async function getPluginUserPromptContributions(args) {
-  const contributions = [];
-  let totalChars = 0;
-  let totalContextBytes = 0;
-  for (const plugin of getPlugins()) {
-    const pluginName = plugin.manifest.name;
-    const hook = plugin.hooks?.userPrompt;
-    if (!hook) {
-      continue;
-    }
-    try {
-      const rawResult = await hook({
-        ...invocationPluginContext(plugin, args.context, args.turnId)
-      });
-      if (rawResult === void 0) {
-        continue;
-      }
-      if (!Array.isArray(rawResult)) {
-        logInvalidPromptContributions({
-          hookName: "userPrompt",
-          pluginName
-        });
-        continue;
-      }
-      const acceptedContributions = rawResult.map(
-        (value, index) => toUserPromptContributionContext({ index, pluginName, value })
-      );
-      if (acceptedContributions.some((contribution) => !contribution)) {
-        logInvalidPromptContributions({
-          hookName: "userPrompt",
-          pluginName
-        });
-        continue;
-      }
-      const validContributions = acceptedContributions.filter(
-        (contribution) => contribution !== void 0
-      );
-      const pluginContributionChars = validContributions.reduce(
-        (sum, contribution) => sum + contribution.text.length,
-        0
-      );
-      const pluginContextBytes = validContributions.reduce(
-        (sum, contribution) => sum + (contribution.context ? Buffer.byteLength(
-          JSON.stringify(contribution.context.content),
-          "utf8"
-        ) : 0),
-        0
-      );
-      if (totalChars + pluginContributionChars > PLUGIN_PROMPT_CONTRIBUTION_TOTAL_MAX_CHARS || totalContextBytes + pluginContextBytes > PLUGIN_PROMPT_CONTEXT_TOTAL_MAX_BYTES) {
-        logWarn("plugin.user_prompt.contribution_budget_exceeded", {
-          "app.plugin.name": pluginName
-        });
-        continue;
-      }
-      totalChars += pluginContributionChars;
-      totalContextBytes += pluginContextBytes;
-      contributions.push(...validContributions);
-    } catch (error) {
-      logWarn("plugin.user_prompt.hook.failed", {
-        "app.plugin.name": pluginName,
-        "exception.message": safeErrorMessage(error)
-      });
-    }
-  }
-  return contributions;
-}
-function getPluginTools(context, sandbox = createSandboxCapability(context.workspace)) {
-  const tools = {};
-  for (const plugin of getPlugins()) {
-    const pluginName = plugin.manifest.name;
-    const hook = plugin.hooks?.tools;
-    if (!hook) {
-      continue;
-    }
-    const slackToolContext = getSlackToolContext(context);
-    const credentialSubject = slackToolContext ? createSlackDirectCredentialSubject({
-      channelId: slackToolContext.locationChannelId,
-      teamId: slackToolContext.teamId,
-      userId: slackToolContext.actor?.userId
-    }) : void 0;
-    const dashboardConversationUrl = getDashboardConversationLink(
-      context.conversationId
-    );
-    const slackContext = slackToolContext ? {
-      channelCapabilities: resolveChannelCapabilities(
-        slackToolContext.locationChannelId
-      ),
-      ...dashboardConversationUrl ? { conversationLink: { url: dashboardConversationUrl } } : void 0,
-      ...credentialSubject ? { credentialSubject } : void 0
-    } : void 0;
-    const annotations = createPluginAnnotations({
-      conversationId: context.conversationId,
-      db: getDb(),
-      plugin: pluginName
-    });
-    const mcp = pluginMcpContext(plugin, context);
-    const canSubscribe = Boolean(plugin.resourceEvents) && plugin.resourceEvents?.isEnabled?.() !== false;
-    const resourceEvents = {
-      canSubscribe,
-      async subscribe(input) {
-        if (!canSubscribe) {
-          throw new Error(
-            "Resource subscriptions are not available in this conversation."
-          );
-        }
-        const registration = plugin.resourceEvents;
-        const resourceType = registration?.resourceTypes.find(
-          (candidate) => candidate.type === input.resource.type
-        );
-        if (input.resource.namespace !== pluginName || !resourceType || input.events.length === 0 || input.events.some(
-          (eventType) => !resourceType.supportedEvents.includes(eventType)
-        )) {
-          throw new Error(
-            "Resource subscription contains an event or resource that the plugin does not support."
-          );
-        }
-        const subscription = await createResourceEventSubscription({
-          conversationId: context.conversationId,
-          events: input.events,
-          expiresAtMs: Date.now() + RESOURCE_SUBSCRIPTION_DEFAULT_TTL_MS,
-          intent: input.intent,
-          label: input.resource.label,
-          namespace: pluginName,
-          identifier: normalizeResourceEventIdentifier(
-            registration,
-            input.resource.identifier
-          ),
-          resourceType: input.resource.type
-        });
-        return {
-          events: subscription.events,
-          id: subscription.id
-        };
-      }
-    };
-    const resolveActor = context.resolveActorIdentity ?? (async () => void 0);
-    const common = {
-      ...basePluginContext(plugin),
-      annotations,
-      conversationId: context.conversationId,
-      locationId: context.locationId,
-      ...slackContext ? { slack: slackContext } : void 0,
-      userText: context.userText,
-      embedder: createPluginEmbedder(pluginName),
-      egress: context.egress,
-      ...mcp ? { mcp } : void 0,
-      model: createPluginModel(pluginName, plugin.model),
-      resourceEvents,
-      sandbox,
-      state: createPluginState(pluginName),
-      users: { resolveActor },
-      workspaces: {
-        async findByRepository(input) {
-          return await listWorkspaceNamesByRepository(getDb(), input);
-        }
-      }
-    };
-    let pluginContext;
-    switch (context.source.kind) {
-      case "slack":
-        if (context.destination.platform !== "slack") {
-          throw new TypeError(
-            "Slack plugin context requires Slack destination"
-          );
-        }
-        pluginContext = {
-          ...common,
-          actor: context.actor?.platform === "slack" ? context.actor : void 0,
-          destination: context.destination,
-          source: context.source
-        };
-        break;
-      case "local":
-        if (context.destination.platform !== "local") {
-          throw new TypeError(
-            "Local plugin context requires local destination"
-          );
-        }
-        pluginContext = {
-          ...common,
-          actor: context.actor?.platform === "local" ? context.actor : void 0,
-          destination: context.destination,
-          source: context.source
-        };
-        break;
-      case "web":
-        pluginContext = {
-          ...common,
-          actor: context.actor?.platform === "web" ? context.actor : void 0,
-          destination: context.destination,
-          source: context.source
-        };
-        break;
-      case "resource_event":
-      case "scheduled_task":
-      case "event_task":
-      case "plugin_dispatch":
-      case "agent_invocation":
-        pluginContext = {
-          ...common,
-          actor: context.actor,
-          destination: context.destination,
-          source: context.source
-        };
-        break;
-    }
-    const pluginTools = hook(pluginContext);
-    const namespace = pluginToolNamespace(pluginName);
-    for (const [localName, tool] of Object.entries(pluginTools)) {
-      if (!PLUGIN_TOOL_NAME_RE.test(localName)) {
-        throw new Error(
-          `Plugin tool "${localName}" from plugin "${pluginName}" must be a camelCase identifier`
-        );
-      }
-      const name = `${namespace}_${localName}`;
-      if (tools[name]) {
-        throw new Error(
-          `Duplicate plugin tool "${name}" from plugin "${pluginName}"`
-        );
-      }
-      const definition = tool;
-      const missingAnnotationKeys = missingToolAnnotationKeys(
-        definition.annotations
-      );
-      if (missingAnnotationKeys.length > 0) {
-        logWarn("plugin.tool_annotations.missing", {
-          "app.plugin.name": pluginName,
-          "gen_ai.tool.name": localName,
-          "app.tool.missing_annotations": missingAnnotationKeys.join(",")
-        });
-      }
-      definition.approvalMode ??= "auto";
-      definition.identity = {
-        id: `${pluginName}.${localName}`,
-        name: localName,
-        plugin: pluginName
-      };
-      definition.source = {
-        id: pluginName,
-        description: plugin.manifest.description
-      };
-      definition.exposure ??= "deferred";
-      tools[name] = definition;
-    }
-  }
-  return tools;
-}
-function routeMethods(route, pluginName) {
-  const methods = Array.isArray(route.method) ? route.method : [route.method ?? "ALL"];
-  if (methods.length === 0) {
-    throw new Error(
-      `Plugin route "${route.path}" from plugin "${pluginName}" must declare at least one method`
-    );
-  }
-  for (const method of methods) {
-    if (!PLUGIN_ROUTE_METHODS.has(method)) {
-      throw new Error(
-        `Plugin route "${route.path}" from plugin "${pluginName}" has invalid method "${String(method)}"`
-      );
-    }
-  }
-  if (methods.includes("ALL") && methods.length > 1) {
-    throw new Error(
-      `Plugin route "${route.path}" from plugin "${pluginName}" must not combine ALL with explicit methods`
-    );
-  }
-  return methods;
-}
-function requirePublishedResourceEvent(plugin, eventType) {
-  const registration = plugin.resourceEvents;
-  if (!registration || registration.isEnabled?.() === false) {
-    throw new Error(
-      `Plugin "${plugin.manifest.name}" cannot publish resource events without an active registration`
-    );
-  }
-  if (!registration.resourceTypes.some(
-    (resourceType) => resourceType.supportedEvents.includes(eventType)
-  )) {
-    throw new Error(
-      `Plugin "${plugin.manifest.name}" did not register resource event "${eventType}"`
-    );
-  }
-}
-function getPluginRoutes(options) {
-  const routes = [];
-  const seen = /* @__PURE__ */ new Set();
-  const methodsByPath = /* @__PURE__ */ new Map();
-  for (const plugin of getPlugins()) {
-    const pluginName = plugin.manifest.name;
-    const hook = plugin.hooks?.routes;
-    if (!hook) {
-      continue;
-    }
-    const pluginRoutes = hook({
-      ...basePluginContext(plugin),
-      annotations: {
-        forConversation: (conversationId) => createPluginAnnotations({
-          conversationId,
-          db: getDb(),
-          plugin: pluginName
-        })
-      },
-      codeChanges: createCodeChangePublisher(pluginName),
-      resourceEvents: {
-        async hasMatch(event) {
-          if (!options.resourceEvents.hasMatch) return false;
-          const parsed = resourceEventInputSchema.parse(event);
-          requirePublishedResourceEvent(plugin, parsed.eventType);
-          return await options.resourceEvents.hasMatch({
-            ...parsed,
-            identifier: normalizeResourceEventIdentifier(
-              plugin.resourceEvents,
-              parsed.identifier
-            ),
-            namespace: pluginName
-          });
-        },
-        async neededMatchKeys(input) {
-          if (!options.resourceEvents.neededMatchKeys) return [];
-          const identifiers = [
-            ...new Set(
-              input.identifiers.map(
-                (identifier) => normalizeResourceEventIdentifier(
-                  plugin.resourceEvents,
-                  identifier
-                )
-              ).filter(Boolean)
-            )
-          ];
-          if (identifiers.length === 0 || input.eventTypes.length === 0) {
-            return [];
-          }
-          return await options.resourceEvents.neededMatchKeys({
-            eventTypes: input.eventTypes,
-            identifiers,
-            namespace: pluginName
-          });
-        },
-        async publish(event) {
-          const parsed = resourceEventInputSchema.parse(event);
-          requirePublishedResourceEvent(plugin, parsed.eventType);
-          await options.resourceEvents.publish({
-            ...parsed,
-            identifier: normalizeResourceEventIdentifier(
-              plugin.resourceEvents,
-              parsed.identifier
-            ),
-            namespace: pluginName
-          });
-        }
-      }
-    });
-    if (!Array.isArray(pluginRoutes)) {
-      throw new Error(
-        `Plugin routes hook from plugin "${pluginName}" must return an array`
-      );
-    }
-    for (const route of pluginRoutes) {
-      if (!isRecord(route)) {
-        throw new Error(
-          `Plugin route from plugin "${pluginName}" must be an object`
-        );
-      }
-      if (typeof route.path !== "string" || !route.path.startsWith("/")) {
-        throw new Error(
-          `Plugin route "${route.path}" from plugin "${pluginName}" must start with /`
-        );
-      }
-      if (typeof route.handler !== "function") {
-        throw new Error(
-          `Plugin route "${route.path}" from plugin "${pluginName}" must provide a handler`
-        );
-      }
-      const methods = routeMethods(route, pluginName);
-      const pathMethods = methodsByPath.get(route.path) ?? /* @__PURE__ */ new Set();
-      if (pathMethods.has("ALL") || methods.includes("ALL") && pathMethods.size > 0) {
-        throw new Error(
-          `Plugin route "${route.path}" conflicts with an ALL route for the same path`
-        );
-      }
-      for (const method of methods) {
-        const key = `${method}:${route.path}`;
-        if (seen.has(key)) {
-          throw new Error(`Duplicate plugin route "${method} ${route.path}"`);
-        }
-        seen.add(key);
-        pathMethods.add(method);
-      }
-      methodsByPath.set(route.path, pathMethods);
-      routes.push({
-        ...route,
-        pluginName
-      });
-    }
-  }
-  return routes;
-}
-function getPluginApiRoutes() {
-  const routes = [];
-  for (const plugin of getPlugins()) {
-    const pluginName = plugin.manifest.name;
-    const hook = plugin.hooks?.apiRoutes;
-    if (!hook) {
-      continue;
-    }
-    const app = hook({
-      ...basePluginContext(plugin),
-      eventStats: createPluginConversationEventStats(plugin),
-      users: { resolve: resolveViewerUser }
-    });
-    if (app === void 0) {
-      continue;
-    }
-    if (!isRecord(app) || typeof app.fetch !== "function") {
-      throw new Error(
-        `Plugin apiRoutes hook from plugin "${pluginName}" must return a fetch-compatible app`
-      );
-    }
-    routes.push({ app, pluginName });
-  }
-  return routes;
-}
-function trustedSlackConversationUrl(pluginName, link) {
-  const url = typeof link?.url === "string" ? link.url.trim() : "";
-  if (!url) {
-    return void 0;
-  }
-  let parsed;
-  try {
-    parsed = new URL(url);
-  } catch (error) {
-    throw new Error(
-      `Plugin "${pluginName}" slackConversationLink must return an absolute http(s) URL`,
-      { cause: error }
-    );
-  }
-  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
-    throw new Error(
-      `Plugin "${pluginName}" slackConversationLink must return an absolute http(s) URL`
-    );
-  }
-  return parsed.toString();
-}
-function getPluginSlackConversationLink(conversationId) {
-  for (const plugin of getPlugins()) {
-    const pluginName = plugin.manifest.name;
-    const hook = plugin.hooks?.slackConversationLink;
-    if (!hook) {
-      continue;
-    }
-    const link = hook({
-      ...basePluginContext(plugin),
-      conversationId
-    });
-    const url = trustedSlackConversationUrl(pluginName, link);
-    if (url) {
-      return { url };
-    }
-  }
-  return void 0;
-}
-function pluginReadState(state) {
-  return {
-    get: state.get
-  };
-}
-function operationalReportText(value, maxLength) {
-  if (typeof value !== "string") {
-    return void 0;
-  }
-  const trimmed = value.trim();
-  if (!trimmed) {
-    return void 0;
-  }
-  return trimmed.length <= maxLength ? trimmed : `${trimmed.slice(0, Math.max(0, maxLength - 3))}...`;
-}
-function operationalReportTone(tone) {
-  return tone === "danger" || tone === "good" || tone === "neutral" || tone === "warning" ? tone : void 0;
-}
-function sanitizeOperationalReport(args) {
-  const metrics = args.report.metrics?.slice(0, OPERATIONAL_REPORT_MAX_METRICS).map((metric) => {
-    const label = operationalReportText(
-      metric.label,
-      OPERATIONAL_REPORT_MAX_LABEL_LENGTH
-    );
-    const value = operationalReportText(
-      metric.value,
-      OPERATIONAL_REPORT_MAX_VALUE_LENGTH
-    );
-    if (!label || !value) {
-      return void 0;
-    }
-    const sanitizedMetric = { label, value };
-    const tone = operationalReportTone(metric.tone);
-    if (tone) {
-      sanitizedMetric.tone = tone;
-    }
-    return sanitizedMetric;
-  }).filter((metric) => Boolean(metric));
-  const recordSets = args.report.recordSets?.slice(0, OPERATIONAL_REPORT_MAX_RECORD_SETS).map((recordSet, recordSetIndex) => {
-    const title2 = operationalReportText(
-      recordSet.title,
-      OPERATIONAL_REPORT_MAX_LABEL_LENGTH
-    );
-    if (!title2) {
-      return void 0;
-    }
-    const fields = recordSet.fields?.slice(0, OPERATIONAL_REPORT_MAX_FIELDS).map((field) => {
-      const key = operationalReportText(
-        field.key,
-        OPERATIONAL_REPORT_MAX_LABEL_LENGTH
-      );
-      const label = operationalReportText(
-        field.label,
-        OPERATIONAL_REPORT_MAX_LABEL_LENGTH
-      );
-      return key && label ? { key, label } : void 0;
-    }).filter((field) => Boolean(field));
-    const records = recordSet.records?.slice(0, OPERATIONAL_REPORT_MAX_RECORDS).map((record, recordIndex) => {
-      const id = operationalReportText(
-        record.id,
-        OPERATIONAL_REPORT_MAX_LABEL_LENGTH
-      ) ?? `${recordSetIndex}:${recordIndex}`;
-      const values = Object.fromEntries(
-        (fields ?? []).map((field) => [
-          field.key,
-          operationalReportText(
-            record.values[field.key],
-            OPERATIONAL_REPORT_MAX_VALUE_LENGTH
-          ) ?? ""
-        ])
-      );
-      const sanitizedRecord = {
-        id,
-        values
-      };
-      const tone = operationalReportTone(record.tone);
-      if (tone) {
-        sanitizedRecord.tone = tone;
-      }
-      return sanitizedRecord;
-    });
-    const sanitizedRecordSet = { title: title2 };
-    if (fields?.length) {
-      sanitizedRecordSet.fields = fields;
-    }
-    const emptyText = operationalReportText(
-      recordSet.emptyText,
-      OPERATIONAL_REPORT_MAX_VALUE_LENGTH
-    );
-    if (emptyText) {
-      sanitizedRecordSet.emptyText = emptyText;
-    }
-    if (records?.length) {
-      sanitizedRecordSet.records = records;
-    }
-    return sanitizedRecordSet;
-  }).filter(
-    (recordSet) => Boolean(recordSet)
-  );
-  const widgets = args.report.widgets?.slice(0, OPERATIONAL_REPORT_MAX_WIDGETS).map((widget, widgetIndex) => {
-    const id = operationalReportText(widget.id, OPERATIONAL_REPORT_MAX_LABEL_LENGTH) ?? String(widgetIndex);
-    const title2 = operationalReportText(
-      widget.title,
-      OPERATIONAL_REPORT_MAX_LABEL_LENGTH
-    );
-    if (!title2) {
-      return void 0;
-    }
-    const seriesEntries = widget.series.slice(0, OPERATIONAL_REPORT_MAX_CHART_SERIES).map((item) => {
-      const key = operationalReportText(
-        item.key,
-        OPERATIONAL_REPORT_MAX_LABEL_LENGTH
-      );
-      const label = operationalReportText(
-        item.label,
-        OPERATIONAL_REPORT_MAX_LABEL_LENGTH
-      );
-      if (!key || !label) {
-        return void 0;
-      }
-      const sanitizedSeries = { key, label };
-      if (item.format === "usd") {
-        sanitizedSeries.format = "usd";
-      }
-      const tone = operationalReportTone(item.tone);
-      if (tone) {
-        sanitizedSeries.tone = tone;
-      }
-      return { sanitizedSeries, sourceKey: item.key };
-    }).filter((item) => Boolean(item));
-    if (!seriesEntries.length) {
-      return void 0;
-    }
-    const series = seriesEntries.map((item) => item.sanitizedSeries);
-    const categories = widget.categories.slice(-OPERATIONAL_REPORT_MAX_CHART_CATEGORIES).map((category, categoryIndex) => ({
-      id: operationalReportText(
-        category.id,
-        OPERATIONAL_REPORT_MAX_LABEL_LENGTH
-      ) ?? `${widgetIndex}:${categoryIndex}`,
-      label: operationalReportText(
-        category.label,
-        OPERATIONAL_REPORT_MAX_LABEL_LENGTH
-      ) ?? String(categoryIndex + 1),
-      values: Object.fromEntries(
-        seriesEntries.map(({ sanitizedSeries, sourceKey }) => [
-          sanitizedSeries.key,
-          Number.isFinite(category.values[sourceKey]) ? category.values[sourceKey] : 0
-        ])
-      )
-    }));
-    const sanitizedWidget = {
-      categories,
-      id,
-      series,
-      title: title2,
-      type: "bar_chart"
-    };
-    const description = operationalReportText(
-      widget.description,
-      OPERATIONAL_REPORT_MAX_VALUE_LENGTH
-    );
-    if (description) {
-      sanitizedWidget.description = description;
-    }
-    const emptyText = operationalReportText(
-      widget.emptyText,
-      OPERATIONAL_REPORT_MAX_VALUE_LENGTH
-    );
-    if (emptyText) {
-      sanitizedWidget.emptyText = emptyText;
-    }
-    const timeRangeDays = widget.timeRangeDays?.filter(
-      (days) => days === 1 || days === 7 || days === 30 || days === 90
-    );
-    if (timeRangeDays?.length) {
-      sanitizedWidget.timeRangeDays = [...new Set(timeRangeDays)];
-    }
-    return sanitizedWidget;
-  }).filter((widget) => Boolean(widget));
-  const sanitized = {
-    pluginName: args.pluginName
-  };
-  const generatedAt = operationalReportText(
-    args.report.generatedAt,
-    OPERATIONAL_REPORT_MAX_VALUE_LENGTH
-  );
-  if (generatedAt) {
-    sanitized.generatedAt = generatedAt;
-  }
-  if (recordSets?.length) {
-    sanitized.recordSets = recordSets;
-  }
-  if (metrics?.length) {
-    sanitized.metrics = metrics;
-  }
-  if (widgets?.length) {
-    sanitized.widgets = widgets;
-  }
-  const title = operationalReportText(
-    args.report.title,
-    OPERATIONAL_REPORT_MAX_LABEL_LENGTH
-  );
-  if (title) {
-    sanitized.title = title;
-  }
-  return sanitized;
-}
-function failedOperationalReport(args) {
-  return {
-    generatedAt: new Date(args.nowMs).toISOString(),
-    pluginName: args.pluginName,
-    metrics: [{ label: "report", tone: "danger", value: "failed" }],
-    title: args.pluginName,
-    recordSets: [
-      {
-        emptyText: "This plugin report failed to load.",
-        title: "Error"
-      }
-    ]
-  };
-}
-async function getPluginOperationalReports(nowMs) {
-  const reports = [];
-  for (const plugin of getPlugins()) {
-    const pluginName = plugin.manifest.name;
-    const hook = plugin.hooks?.operationalReport;
-    if (!hook) {
-      continue;
-    }
-    try {
-      const state = createPluginState(pluginName);
-      const report = await hook({
-        ...basePluginContext(plugin),
-        eventStats: createPluginConversationEventStats(plugin, () => nowMs),
-        nowMs,
-        state: pluginReadState(state)
-      });
-      if (!report) {
-        continue;
-      }
-      reports.push(
-        sanitizeOperationalReport({
-          pluginName,
-          report
-        })
-      );
-    } catch (error) {
-      const log = createPluginLogger(pluginName);
-      log.error("Plugin operational report failed", {
-        error: error instanceof Error ? error.message : String(error)
-      });
-      reports.push(failedOperationalReport({ nowMs, pluginName }));
-    }
-  }
-  return reports;
-}
-async function getPluginProfileReports(args) {
-  const reports = [];
-  for (const plugin of getPlugins()) {
-    const pluginName = plugin.manifest.name;
-    const hook = plugin.hooks?.profileReport;
-    if (!hook) {
-      continue;
-    }
-    try {
-      const state = createPluginState(pluginName);
-      const report = await hook({
-        ...basePluginContext(plugin),
-        nowMs: args.nowMs,
-        state: pluginReadState(state),
-        subject: args.subject,
-        viewer: args.viewer
-      });
-      if (!report) {
-        continue;
-      }
-      reports.push(
-        sanitizeOperationalReport({
-          pluginName,
-          report
-        })
-      );
-    } catch (error) {
-      const log = createPluginLogger(pluginName);
-      log.error("Plugin profile report failed", {
-        error: error instanceof Error ? error.message : String(error)
-      });
-    }
-  }
-  return reports;
-}
-function normalizeEnv(value) {
-  if (!isRecord(value)) {
-    return {};
-  }
-  const env = {};
-  for (const [key, rawValue] of Object.entries(value)) {
-    if (typeof rawValue === "string") {
-      env[key] = rawValue;
-    }
-  }
-  return env;
-}
-function preparationSignal(inputSignal, ownerSignal) {
-  if (!inputSignal) return ownerSignal;
-  if (!ownerSignal) return inputSignal;
-  return AbortSignal.any([inputSignal, ownerSignal]);
-}
-function createSandboxCapability(workspace, ownerSignal) {
-  return {
-    root: SANDBOX_WORKSPACE_ROOT,
-    juniorRoot: `${SANDBOX_WORKSPACE_ROOT}/.junior`,
-    async readFile(filePath) {
-      return await workspace.readFileToBuffer({ path: filePath }) ?? null;
-    },
-    async run(input) {
-      const signal = preparationSignal(input.signal, ownerSignal);
-      const result = await runNonInteractiveCommand(workspace, {
-        ...input,
-        ...signal ? { signal } : void 0
-      });
-      return {
-        exitCode: result.exitCode,
-        stdout: result.stdout,
-        stderr: result.stderr
-      };
-    },
-    async writeFile(input) {
-      await workspace.writeFiles([
-        {
-          path: input.path,
-          content: input.content,
-          ...input.mode !== void 0 ? { mode: input.mode } : void 0
-        }
-      ]);
-    }
-  };
-}
-function createPluginHookRunner(input = {}) {
-  const loaded = getPlugins();
-  return {
-    async afterMcpTool(tool) {
-      for (const plugin of loaded) {
-        if (plugin.manifest.name !== tool.provider) {
-          continue;
-        }
-        const hook = plugin.hooks?.afterMcpTool;
-        if (!hook) {
-          continue;
-        }
-        const annotations = tool.conversationId ? createPluginAnnotations({
-          conversationId: tool.conversationId,
-          db: getDb(),
-          plugin: plugin.manifest.name
-        }) : void 0;
-        try {
-          await hook({
-            ...basePluginContext(plugin),
-            ...tool.conversationId ? { conversationId: tool.conversationId } : void 0,
-            ...annotations ? { annotations } : void 0,
-            result: tool.structuredContent !== void 0 ? { structuredContent: tool.structuredContent } : {},
-            tool: {
-              arguments: tool.arguments,
-              name: tool.toolName
-            }
-          });
-        } catch (error) {
-          logWarn("agent.plugin.after_mcp_tool.failed", {
-            "app.plugin.name": plugin.manifest.name,
-            "gen_ai.tool.name": tool.toolName,
-            "exception.message": error instanceof Error ? error.message : String(error)
-          });
-        }
-      }
-    },
-    async prepareWorkspace(sandbox, repos, signal) {
-      const preparers = new Set(
-        loaded.filter((plugin) => plugin.hooks?.workspacePrepare).map((plugin) => plugin.manifest.name)
-      );
-      const unhandledProviders = [
-        ...new Set(
-          repos.map((repo) => repo.provider).filter((provider) => !preparers.has(provider))
-        )
-      ].sort();
-      if (unhandledProviders.length > 0) {
-        throw new Error(
-          `Workspace repository providers have no preparation hook: ${unhandledProviders.join(", ")}`
-        );
-      }
-      const selectedRepos = repos.map((repo) => ({
-        provider: repo.provider,
-        repo: repo.repo,
-        path: workspaceRepoCheckoutPath(repo.repo)
-      }));
-      const paths = /* @__PURE__ */ new Set();
-      for (const entry of selectedRepos) {
-        const key = entry.path.toLowerCase();
-        if (paths.has(key)) {
-          throw new Error(`Workspace checkout path collision: ${entry.path}`);
-        }
-        paths.add(key);
-      }
-      const sandboxCapability = createSandboxCapability(sandbox, signal);
-      for (const plugin of loaded) {
-        const hook = plugin.hooks?.workspacePrepare;
-        if (!hook) continue;
-        const selected = selectedRepos.filter((repo) => repo.provider === plugin.manifest.name).map((repo) => ({
-          path: repo.path,
-          repo: repo.repo
-        }));
-        if (selected.length === 0) continue;
-        await hook({
-          ...basePluginContext(plugin),
-          repos: selected,
-          sandbox: sandboxCapability
-        });
-      }
-    },
-    async prepareSandbox(sandbox) {
-      const sandboxCapability = createSandboxCapability(sandbox);
-      for (const plugin of loaded) {
-        const pluginName = plugin.manifest.name;
-        const hook = plugin.hooks?.sandboxPrepare;
-        if (!hook) {
-          continue;
-        }
-        logInfo("agent.plugin.sandbox_preparation.started", {
-          "app.plugin.name": pluginName
-        });
-        await hook({
-          ...basePluginContext(plugin),
-          actor: input.actor,
-          sandbox: sandboxCapability
-        });
-      }
-    },
-    async beforeToolExecute(tool) {
-      const env = {};
-      let nextInput = { ...tool.input };
-      const actors = input.actors?.() ?? (input.actor ? [input.actor] : []);
-      for (const plugin of loaded) {
-        const pluginName = plugin.manifest.name;
-        const hook = plugin.hooks?.beforeToolExecute;
-        if (!hook) {
-          continue;
-        }
-        let replacement;
-        let denied;
-        await hook({
-          ...basePluginContext(plugin),
-          actor: input.actor,
-          actors,
-          tool: {
-            name: tool.name,
-            input: nextInput
-          },
-          users: {
-            resolveActor: async () => input.actor ? await readActorIdentity(input.actor) : void 0
-          },
-          env: {
-            get(key) {
-              return env[key] ?? normalizeEnv(nextInput.env)[key];
-            },
-            set(key, value) {
-              env[key] = value;
-            }
-          },
-          decision: {
-            deny(message) {
-              denied = message;
-            },
-            replaceInput(input2) {
-              replacement = input2;
-            }
-          }
-        });
-        if (denied) {
-          throw new PluginHookDeniedError(denied);
-        }
-        if (replacement !== void 0) {
-          if (!isRecord(replacement)) {
-            throw new Error(
-              `Plugin "${pluginName}" replaced tool input with a non-object value`
-            );
-          }
-          nextInput = { ...replacement };
-        }
-      }
-      return {
-        input: nextInput,
-        env
-      };
-    }
-  };
-}
-
-export {
-  listConversationAnnotations,
-  listConversationAnnotationsById,
-  createPluginConversationEvents,
-  renderPluginConversationEvent,
-  createPluginLogger,
-  createPluginModel,
-  createPluginEmbedder,
-  createPluginState,
-  setDashboardConversationLinkOptions,
-  getDashboardConversationLink,
-  getDashboardTaskLink,
-  createResourceEventSubscription,
-  listResourceEventSubscriptions,
-  cancelResourceEventSubscription,
-  cancelSubscriptions,
-  collectResourceEventMatchKeys,
-  findMatchingResourceEventSubscriptions,
-  deliverResourceEventSubscription,
-  RESOURCE_SUBSCRIPTION_DEFAULT_TTL_MS,
-  RESOURCE_SUBSCRIPTION_MAX_TTL_MS,
-  STOP_WATCHING_TOOL_NAME,
-  RESOURCE_WATCH_TOOL_SOURCE,
-  getSlackToolContext,
-  resolveViewerUser,
-  findUserByEmail,
-  updateViewerDisplayName,
-  readActorIdentity,
-  runWithWorkspaceTeamId,
-  getWorkspaceTeamId,
-  SlackActionError,
-  getHeaderString,
-  runWithSlackInstallationToken,
-  normalizeSlackConversationId,
-  withSlackRetries,
-  getSlackClient,
-  isDmChannel,
-  isConversationScopedChannel,
-  getFilePermalink,
-  downloadPrivateSlackFile,
-  bindSlackDirectCredentialSubject,
-  verifySlackDirectCredentialSubject,
-  bindScheduledTaskCredentialSubject,
-  verifyScheduledTaskCredentialSubject,
-  bindEventTaskCredentialSubject,
-  verifyEventTaskCredentialSubject,
-  resolveChannelCapabilities,
-  tryWorkspaceRepoCheckoutPath,
-  workspaceRepoCheckoutPath,
-  getWorkspaceSnapshotBuilder,
-  deleteWorkspaceSnapshotBuilders,
-  SANDBOX_RUNTIME,
-  loadSnapshotsForProfile,
-  invalidateReadySnapshot,
-  setWorkspaceSnapshot,
-  setWorkspaceSnapshotBuild,
-  WorkspaceValidationError,
-  listWorkspaces,
-  getWorkspaceByName,
-  getWorkspace,
-  createWorkspace,
-  updateWorkspace,
-  deleteWorkspace,
-  PluginHookDeniedError,
-  validatePlugins,
-  setPlugins,
-  getPlugins,
-  applyPluginFormatMarkdown,
-  getPluginSystemPromptContributions,
-  getPluginUserPromptContributions,
-  getPluginTools,
-  getPluginRoutes,
-  getPluginApiRoutes,
-  getPluginSlackConversationLink,
-  getPluginOperationalReports,
-  getPluginProfileReports,
-  createPluginHookRunner
-};