@sentry/junior 0.76.1 → 0.78.0

package/dist/{agent-hooks-ZOE7RIED.js → agent-hooks-OFDNZJB2.js}

@@ -1,6 +1,7 @@
 import {
   PluginHookDeniedError,
   createPluginHookRunner,
+  getPluginDashboardRoutes,
   getPluginOperationalReports,
   getPluginRoutes,
   getPluginSlackConversationLink,
@@ -10,11 +11,11 @@ import {
   getPlugins,
   setPlugins,
   validatePlugins
-} from "./chunk-NFTMTIP3.js";
-import "./chunk-56TBVRJG.js";
-import "./chunk-NYKJ3KON.js";
+} from "./chunk-SSWBYEFH.js";
+import "./chunk-RARSKPVT.js";
+import "./chunk-237T7XAN.js";
 import "./chunk-G3E7SCME.js";
-import "./chunk-Y5OFBCBZ.js";
+import "./chunk-LXTPBU4K.js";
 import "./chunk-Q6XFTRV5.js";
 import "./chunk-T77LUIX3.js";
 import "./chunk-VALUBQ7R.js";
@@ -25,6 +26,7 @@ import "./chunk-MLKGABMK.js";
 export {
   PluginHookDeniedError,
   createPluginHookRunner,
+  getPluginDashboardRoutes,
   getPluginOperationalReports,
   getPluginRoutes,
   getPluginSlackConversationLink,

package/dist/api-reference.d.ts

@@ -1,8 +1,8 @@
 export { createApp } from "./app";
-export type { JuniorAppOptions } from "./app";
+export type { JuniorAppOptions, JuniorDashboardOptions } from "./app";
 export { initSentry } from "./instrumentation";
 export { juniorNitro } from "./nitro";
-export type { JuniorNitroOptions } from "./nitro";
+export type { JuniorNitroDashboardOptions, JuniorNitroOptions } from "./nitro";
 export { defineJuniorPlugins } from "./plugins";
 export type { JuniorPluginInput, JuniorPluginSet, JuniorPluginSetOptions, } from "./plugins";
 export type { PluginRunContext, PluginRunTranscriptEntry, PluginTaskContext, PluginTaskDefinition, PluginTasks, } from "@sentry/junior-plugin-api";

package/dist/app.d.ts

@@ -1,10 +1,13 @@
 import { Hono } from "hono";
+import type { JuniorReporting } from "./reporting";
 import { type JuniorPluginSet } from "./plugins";
 import { type VercelConversationWorkCallbackOptions } from "@/chat/task-execution/vercel-callback";
 import type { WaitUntilFn } from "@/handlers/types";
 export { defineJuniorPlugins } from "./plugins";
 export type { JuniorPluginInput, JuniorPluginSet, JuniorPluginSetOptions, } from "./plugins";
 export interface JuniorAppOptions {
+    /** Authenticated dashboard mounted by core when configured. */
+    dashboard?: JuniorDashboardOptions;
     /** Slack-specific overrides applied after env parsing. */
     slack?: {
         /** Slack emoji shown while Junior is processing. Defaults to `eyes`. */
@@ -29,5 +32,29 @@ export interface JuniorAppOptions {
     };
     waitUntil?: WaitUntilFn;
 }
+export interface JuniorDashboardOptions {
+    /** Browser auth route prefix used by Better Auth. */
+    authPath?: string;
+    /** Require a dashboard browser session before serving dashboard pages and APIs. */
+    authRequired?: boolean;
+    /** Exact Google account emails allowed to open the dashboard. */
+    allowedEmails?: string[];
+    /** Google Workspace domains allowed to open the dashboard. */
+    allowedGoogleDomains?: string[];
+    /** Browser route prefix for the dashboard shell. */
+    basePath?: string;
+    /** Public deployment origin used for auth callbacks and external links. */
+    baseURL?: string;
+    /** Disable dashboard route mounting while preserving serializable config shape. */
+    disabled?: boolean;
+    /** Overlay dashboard visual-QA fixture conversations onto real reporting data. */
+    mockConversations?: boolean;
+    /** Reporting implementation used by dashboard APIs. Defaults to core reporting. */
+    reporting?: JuniorReporting;
+    /** Browser session lifetime in seconds. */
+    sessionMaxAgeSeconds?: number;
+    /** Additional trusted origins accepted by Better Auth. */
+    trustedOrigins?: string[];
+}
 /** Create a Hono app with all Junior routes. */
 export declare function createApp(options?: JuniorAppOptions): Promise<Hono>;

package/dist/app.js

@@ -71,7 +71,7 @@ import {
   updateConversationStats,
   uploadFilesToThread,
   upsertConversationMessage
-} from "./chunk-FFGXUXMD.js";
+} from "./chunk-2MSW5BZY.js";
 import {
   CONVERSATION_WORK_CHECK_IN_INTERVAL_MS,
   CONVERSATION_WORK_STALE_ENQUEUE_MS,
@@ -90,12 +90,12 @@ import {
   requestConversationContinuation,
   requestConversationWork,
   startConversationWork
-} from "./chunk-R6Z5XWY3.js";
+} from "./chunk-LUNMJQ7D.js";
 import {
   JUNIOR_THREAD_STATE_TTL_MS,
   coerceThreadConversationState
 } from "./chunk-Z4CIQ3EB.js";
-import "./chunk-JBASI5VV.js";
+import "./chunk-PNGAJ75P.js";
 import {
   getVercelConversationWorkQueue,
   resolveConversationWorkQueueTopic,
@@ -113,7 +113,7 @@ import {
   resolveSlackChannelTypeFromMessage,
   resolveSlackConversationContext,
   setConversationTitle
-} from "./chunk-ZQB37HUX.js";
+} from "./chunk-C2YBH4S6.js";
 import {
   abandonAgentTurnSessionRecord,
   buildSlackOutputMessage,
@@ -129,11 +129,11 @@ import {
   recordAuthorizationCompleted,
   splitSlackReplyText,
   truncateStatusText
-} from "./chunk-KOIMO7S3.js";
+} from "./chunk-QDQVOMBA.js";
 import {
   validatePluginEgressCredentialHooks,
   validatePluginRegistrations
-} from "./chunk-XBBC6W45.js";
+} from "./chunk-KIDP757T.js";
 import {
   defineJuniorPlugins,
   pluginCatalogConfigFromEnv,
@@ -142,26 +142,27 @@ import {
 } from "./chunk-SG5WAA7H.js";
 import {
   bindSlackDirectCredentialSubject,
+  getPluginDashboardRoutes,
   getPluginRoutes,
   getPluginSlackConversationLink,
   getPlugins,
   setPlugins,
   validatePlugins,
   verifySlackDirectCredentialSubject
-} from "./chunk-NFTMTIP3.js";
+} from "./chunk-SSWBYEFH.js";
 import {
   createPluginLogger,
   createPluginState
-} from "./chunk-56TBVRJG.js";
+} from "./chunk-RARSKPVT.js";
 import {
   getConversationStore,
   getDb
-} from "./chunk-NYKJ3KON.js";
+} from "./chunk-237T7XAN.js";
 import "./chunk-G3E7SCME.js";
 import {
-  ACTIVE_LOCK_TTL_MS,
+  acquireActiveLock,
   getStateAdapter
-} from "./chunk-Y5OFBCBZ.js";
+} from "./chunk-LXTPBU4K.js";
 import {
   createSlackDestination,
   destinationKey,
@@ -198,7 +199,7 @@ import {
 } from "./chunk-T77LUIX3.js";
 import {
   discoverSkills
-} from "./chunk-4SCWV7TJ.js";
+} from "./chunk-Y3EG7S7P.js";
 import {
   CredentialUnavailableError,
   buildOAuthTokenRequest,
@@ -209,7 +210,7 @@ import {
   isPluginProvider,
   parseOAuthTokenResponse,
   setPluginCatalogConfig
-} from "./chunk-ZLMBNBUG.js";
+} from "./chunk-YLVJRYTD.js";
 import {
   createRequester,
   createSlackRequester,
@@ -247,8 +248,60 @@ import {
 import "./chunk-MLKGABMK.js";
 
 // src/app.ts
+import { createRequire } from "module";
+import { pathToFileURL } from "url";
 import { Hono } from "hono";
 
+// 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(path2, fallback) {
+  const value = path2?.trim() || fallback;
+  const withSlash = value.startsWith("/") ? value : `/${value}`;
+  return stripTrailingSlashes(withSlash);
+}
+function resolveDashboardBaseURL(config) {
+  const explicit = config.baseURL ?? process.env.BETTER_AUTH_URL ?? 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 getDashboardConversationLink(conversationId) {
+  if (!dashboardConversationLinkOptions) {
+    return void 0;
+  }
+  const baseURL = resolveDashboardBaseURL(dashboardConversationLinkOptions);
+  const basePath = normalizeDashboardPath(
+    dashboardConversationLinkOptions.basePath,
+    "/"
+  );
+  const path2 = basePath === "/" ? `/conversations/${encodeURIComponent(conversationId)}` : `${basePath}/conversations/${encodeURIComponent(conversationId)}`;
+  return `${baseURL}${path2}`;
+}
+
 // src/chat/slack/reply.ts
 import { Buffer as Buffer2 } from "buffer";
 
@@ -267,7 +320,7 @@ function buildSlackReplyFooter(args) {
       label: "ID",
       value: conversationId
     };
-    const conversationUrl = getPluginSlackConversationLink(conversationId)?.url ?? buildSentryConversationUrl(conversationId);
+    const conversationUrl = getPluginSlackConversationLink(conversationId)?.url ?? getDashboardConversationLink(conversationId) ?? buildSentryConversationUrl(conversationId);
     if (conversationUrl) {
       idItem.url = conversationUrl;
     }
@@ -2790,7 +2843,7 @@ async function resumeSlackTurn(args) {
   const stateAdapter = getStateAdapter();
   await stateAdapter.connect();
   const lockKey = args.lockKey ?? getDefaultLockKey(args.channelId, args.threadTs);
-  const lock = await stateAdapter.acquireLock(lockKey, ACTIVE_LOCK_TTL_MS);
+  const lock = await acquireActiveLock(stateAdapter, lockKey);
   if (!lock) {
     throw new ResumeTurnBusyError(lockKey);
   }
@@ -6241,6 +6294,14 @@ var IGNORED_MESSAGE_SUBTYPES = /* @__PURE__ */ new Set([
   "ekm_access_denied",
   "tombstone"
 ]);
+var SlackEventPersistenceError = class extends Error {
+  cause;
+  constructor(cause) {
+    super("Slack event durable persistence failed");
+    this.name = "SlackEventPersistenceError";
+    this.cause = cause;
+  }
+};
 function enqueue(waitUntil, task) {
   waitUntil(task);
 }
@@ -6292,7 +6353,7 @@ async function buildThread(args) {
   });
 }
 function shouldIgnoreMessage(message) {
-  return message.author.isMe === true || isExternalSlackUser(message.raw);
+  return message.author.isMe === true || !parseActorUserId(message.author.userId) || isExternalSlackUser(message.raw);
 }
 function shouldPersistBeforeAck(body) {
   return body.event?.type === "app_mention" || body.event?.type === "message";
@@ -6312,6 +6373,8 @@ async function persistSlackMessage(args) {
     conversationStore: args.conversationStore,
     queue: args.queue,
     state: args.state
+  }).catch((error) => {
+    throw new SlackEventPersistenceError(error);
   });
 }
 async function routeParsedMessage(args) {
@@ -6660,9 +6723,16 @@ async function handleSlackWebhook(args) {
       services: args.services
     });
     if (shouldPersistBeforeAck(parsed)) {
-      await eventTask.catch((error) => {
-        logException(error, "slack_event_persist_failed");
-      });
+      try {
+        await eventTask;
+      } catch (error) {
+        if (!(error instanceof SlackEventPersistenceError)) {
+          logException(error, "slack_event_enqueue_failed");
+          return new Response("ok", { status: 200 });
+        }
+        logException(error.cause, "slack_event_persist_failed");
+        return new Response("Slack event persistence failed", { status: 503 });
+      }
     } else {
       enqueue(
         args.waitUntil,
@@ -11141,6 +11211,7 @@ function createProductionConversationWorkOptions(options) {
 }
 
 // src/app.ts
+var DASHBOARD_PACKAGE_NAME = "@sentry/junior-dashboard";
 async function defaultWaitUntil() {
   try {
     const { waitUntil } = await import("@vercel/functions");
@@ -11159,6 +11230,8 @@ async function resolveVirtualConfig() {
   try {
     const mod = await import("#junior/config");
     return {
+      createDashboardApp: mod.createDashboardApp,
+      dashboard: mod.dashboard,
       pluginSet: mod.pluginSet,
       plugins: mod.plugins,
       pluginRuntimeRegistrations: mod.pluginRuntimeRegistrations ?? []
@@ -11221,7 +11294,161 @@ function validateBuildIncludesPluginRuntimeRegistrations(runtimeRegistrations, v
     `createApp() is missing plugin registration(s) with runtime code bundled by juniorNitro(): ${missing.join(", ")}. Pass a runtime-safe plugin module to juniorNitro({ plugins: "./plugins" }) or pass the same defineJuniorPlugins(...) set to createApp({ plugins }).`
   );
 }
-function mountPluginRoutes(app, routes) {
+async function createDashboardRouteRegistrations(args) {
+  if (!args.dashboard || args.dashboard.disabled) {
+    return [];
+  }
+  const createDashboardApp = args.createDashboardApp ?? await loadDashboardAppFactory();
+  return dashboardRouteRegistrations({
+    dashboard: args.dashboard,
+    createDashboardApp,
+    pluginRoutes: args.pluginRoutes
+  });
+}
+async function loadDashboardAppFactory() {
+  try {
+    const appRequire = createRequire(`${process.cwd()}/package.json`);
+    const mod = await import(pathToFileURL(appRequire.resolve(DASHBOARD_PACKAGE_NAME)).href);
+    return dashboardAppFactoryFromModule(mod);
+  } catch (error) {
+    if (isMissingDashboardPackage(error)) {
+      throw new Error(
+        'createApp({ dashboard }) requires installing "@sentry/junior-dashboard"',
+        { cause: error }
+      );
+    }
+    throw error;
+  }
+}
+function dashboardAppFactoryFromModule(mod) {
+  if (!mod || typeof mod !== "object" || typeof mod.createDashboardApp !== "function") {
+    throw new Error(
+      '@sentry/junior-dashboard must export a "createDashboardApp" function'
+    );
+  }
+  return mod.createDashboardApp;
+}
+function isMissingDashboardPackage(error) {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  const code = error.code;
+  return (code === "ERR_MODULE_NOT_FOUND" || code === "MODULE_NOT_FOUND") && error.message.includes("@sentry/junior-dashboard");
+}
+function stripTrailingSlashes2(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 normalizeDashboardPath2(path2, fallback) {
+  const value = path2?.trim() || fallback;
+  const withSlash = value.startsWith("/") ? value : `/${value}`;
+  return stripTrailingSlashes2(withSlash);
+}
+function dashboardHostRoutePaths(dashboard) {
+  const basePath = normalizeDashboardPath2(dashboard.basePath, "/");
+  const authPath = normalizeDashboardPath2(dashboard.authPath, "/api/auth");
+  const pagePaths = basePath === "/" ? [
+    "/",
+    "/conversations",
+    "/conversations/*",
+    "/plugins",
+    "/plugins/*",
+    "/sessions",
+    "/sessions/*"
+  ] : [basePath, `${basePath}/*`];
+  return [
+    ...pagePaths,
+    "/favicon.ico",
+    "/api/dashboard",
+    "/api/dashboard/*",
+    authPath,
+    `${authPath}/*`
+  ];
+}
+function routePrefixCoversPath(routePrefix, path2) {
+  return routePrefix === "/" || path2 === routePrefix || path2.startsWith(`${routePrefix}/`);
+}
+function routeSegments(path2) {
+  return normalizeDashboardPath2(path2, "/").split("/").filter(Boolean);
+}
+function routeSegmentMatches(pattern, value) {
+  return pattern === value || pattern === "*" || pattern.startsWith(":");
+}
+function routePatternMatchesConcretePath(pattern, concretePath) {
+  const patternSegments = routeSegments(pattern);
+  const pathSegments = routeSegments(concretePath);
+  for (let index = 0; index < patternSegments.length; index += 1) {
+    const segment = patternSegments[index];
+    if (segment === "**" || segment === "*") {
+      return true;
+    }
+    const value = pathSegments[index];
+    if (!value || !routeSegmentMatches(segment, value)) {
+      return false;
+    }
+  }
+  return patternSegments.length === pathSegments.length;
+}
+function routePatternExamples(routePath) {
+  const normalized = normalizeDashboardPath2(routePath, "/");
+  if (!normalized.endsWith("/*") && !normalized.endsWith("/**")) {
+    return [normalized];
+  }
+  const prefix = normalizeDashboardPath2(
+    normalized.endsWith("/*") ? normalized.slice(0, -2) : normalized.slice(0, -3),
+    "/"
+  );
+  return [
+    prefix,
+    prefix === "/" ? "/__dashboard__" : `${prefix}/__dashboard__`
+  ];
+}
+function routePatternOverlaps(ownedPath, routePath) {
+  if (ownedPath.endsWith("/*") && routePrefixCoversPath(ownedPath.slice(0, -2), routePath)) {
+    return true;
+  }
+  return routePatternExamples(ownedPath).some(
+    (example) => routePatternMatchesConcretePath(routePath, example)
+  );
+}
+function dashboardOwnedRoutePath(routePath, dashboard) {
+  return dashboardHostRoutePaths(dashboard).some(
+    (path2) => routePatternOverlaps(path2, routePath)
+  );
+}
+function dashboardRouteRegistrations(args) {
+  let app;
+  const fetch2 = (request) => {
+    app ??= args.createDashboardApp({
+      ...args.dashboard,
+      pluginRoutes: args.pluginRoutes
+    });
+    if (!app || typeof app.fetch !== "function") {
+      throw new Error("createDashboardApp() must return an app with fetch()");
+    }
+    return app.fetch(request);
+  };
+  return dashboardHostRoutePaths(args.dashboard).map((path2) => ({
+    handler: fetch2,
+    path: path2
+  }));
+}
+function validateDashboardRouteOwnership(args) {
+  if (!args.dashboard || args.dashboard.disabled) {
+    return;
+  }
+  for (const route of args.routes) {
+    if (dashboardOwnedRoutePath(route.path, args.dashboard)) {
+      throw new Error(
+        `Plugin "${route.pluginName}" route "${route.path}" conflicts with core dashboard routes`
+      );
+    }
+  }
+}
+function mountRoutes(app, routes) {
   for (const route of routes) {
     const handler = (c) => route.handler(c.req.raw);
     const methods = Array.isArray(route.method) ? route.method : [route.method ?? "ALL"];
@@ -11237,6 +11464,7 @@ function mountPluginRoutes(app, routes) {
 }
 async function createApp(options) {
   const virtualConfig = await resolveVirtualConfig();
+  const dashboard = options?.dashboard ?? virtualConfig?.dashboard;
   const configuredPlugins = options?.plugins ?? virtualConfig?.pluginSet;
   const plugins = pluginRuntimeRegistrationsFromPluginSet(configuredPlugins);
   const pluginConfig = configuredPlugins ? pluginCatalogConfigFromPluginSet(configuredPlugins) : virtualConfig?.plugins ?? pluginCatalogConfigFromEnv();
@@ -11251,7 +11479,9 @@ async function createApp(options) {
   const previousPlugins = setPlugins(plugins);
   const previousConfigDefaults = getConfigDefaults();
   const previousSlackReactionConfig = getSlackReactionConfig();
+  const previousDashboardLinkOptions = setDashboardConversationLinkOptions(dashboard);
   let pluginRoutes = [];
+  let pluginDashboardRoutes = [];
   let sandboxEgressTracePropagationDomains = [];
   try {
     sandboxEgressTracePropagationDomains = normalizeSandboxEgressTracePropagationDomains(
@@ -11269,11 +11499,16 @@ async function createApp(options) {
       );
     }
     pluginRoutes = getPluginRoutes();
+    validateDashboardRouteOwnership({ dashboard, routes: pluginRoutes });
+    if (dashboard && !dashboard.disabled) {
+      pluginDashboardRoutes = getPluginDashboardRoutes();
+    }
   } catch (error) {
     setPluginCatalogConfig(previousPluginCatalogConfig);
     setPlugins(previousPlugins);
     setConfigDefaults(previousConfigDefaults);
     setSlackReactionConfig(previousSlackReactionConfig);
+    setDashboardConversationLinkOptions(previousDashboardLinkOptions);
     throw error;
   }
   const waitUntil = options?.waitUntil ?? await defaultWaitUntil();
@@ -11301,7 +11536,15 @@ async function createApp(options) {
       next
     );
   });
-  mountPluginRoutes(app, pluginRoutes);
+  mountRoutes(app, pluginRoutes);
+  mountRoutes(
+    app,
+    await createDashboardRouteRegistrations({
+      dashboard,
+      createDashboardApp: virtualConfig?.createDashboardApp,
+      pluginRoutes: pluginDashboardRoutes
+    })
+  );
   app.get("/", () => GET());
   app.get("/health", () => GET());
   app.get("/api/oauth/callback/mcp/:provider", (c) => {

package/dist/build/copy-build-content.d.ts

@@ -1,4 +1,6 @@
 /** Copy app and declared plugin package content into the server output. */
 export declare function copyAppAndPluginContent(cwd: string, serverRoot: string, packageNames?: unknown): void;
+/** Copy dashboard browser assets when core dashboard routes are enabled. */
+export declare function copyDashboardAssets(cwd: string, serverRoot: string): void;
 /** Copy extra file patterns into server output for files the bundler cannot trace. */
 export declare function copyIncludedFiles(cwd: string, serverRoot: string, patterns?: unknown): void;

package/dist/build/virtual-config.d.ts

@@ -1,5 +1,6 @@
 import type { Nitro } from "nitro/types";
 import type { PluginCatalogConfig } from "@/chat/plugins/types";
+import type { JuniorDashboardOptions } from "@/app";
 import { type JuniorPluginSet } from "@/plugins";
 export interface RuntimePluginModule {
     exportName: string;
@@ -7,6 +8,7 @@ export interface RuntimePluginModule {
 }
 /** Render the virtual config module consumed by createApp(). */
 export declare function renderVirtualConfig(options: {
+    dashboard?: Omit<JuniorDashboardOptions, "reporting">;
     plugins?: PluginCatalogConfig;
     pluginModule?: RuntimePluginModule;
     pluginRuntimeRegistrations?: string[];
@@ -17,4 +19,5 @@ export declare function injectVirtualConfig(nitro: Nitro, options?: {
     pluginModule?: RuntimePluginModule;
     plugins?: PluginCatalogConfig;
     pluginRuntimeRegistrations?: string[];
+    dashboard?: Omit<JuniorDashboardOptions, "reporting">;
 }): void;

package/dist/chat/conversations/store.d.ts

@@ -1,7 +1,7 @@
 import type { Destination } from "@sentry/junior-plugin-api";
 import type { StoredSlackRequester } from "@/chat/requester";
 export type ConversationSource = "api" | "internal" | "local" | "plugin" | "scheduler" | "slack";
-export type ConversationStatus = "awaiting_resume" | "idle" | "pending" | "running";
+export type ConversationStatus = "awaiting_resume" | "failed" | "idle" | "pending" | "running";
 export interface ConversationExecution {
     lastCheckpointAtMs?: number;
     lastEnqueuedAtMs?: number;

package/dist/chat/plugins/agent-hooks.d.ts

@@ -1,4 +1,4 @@
-import type { PluginConversations, PluginRoute, PluginOperationalReport, SlackConversationLink, PluginRegistration } from "@sentry/junior-plugin-api";
+import type { PluginConversations, PluginRoute, PluginOperationalReport, PluginRouteApp, SlackConversationLink, PluginRegistration } from "@sentry/junior-plugin-api";
 import type { PluginPromptContributionContext } from "@/chat/plugins/prompt";
 import type { ToolDefinition } from "@/chat/tools/definition";
 import type { ToolRuntimeContext } from "@/chat/tools/types";
@@ -19,6 +19,10 @@ export interface ToolHookResult {
 export interface PluginRouteRegistration extends PluginRoute {
     pluginName: string;
 }
+export interface PluginDashboardRouteRegistration {
+    app: PluginRouteApp;
+    pluginName: string;
+}
 export interface PluginHookRunner {
     beforeToolExecute(input: ToolHookInput): Promise<ToolHookResult>;
     prepareSandbox(sandbox: SandboxInstance): Promise<void>;
@@ -39,6 +43,8 @@ export declare function getPluginUserPromptContributions(args: {
 export declare function getPluginTools(context: ToolRuntimeContext): Record<string, ToolDefinition<any>>;
 /** Collect route handlers exposed by plugins for app-level mounting. */
 export declare function getPluginRoutes(): PluginRouteRegistration[];
+/** Collect dashboard-scoped route apps exposed by plugins. */
+export declare function getPluginDashboardRoutes(): PluginDashboardRouteRegistration[];
 /** Resolve the first plugin conversation URL for finalized Slack footers. */
 export declare function getPluginSlackConversationLink(conversationId: string): SlackConversationLink | undefined;
 /** Collect read-only operational summaries exposed by plugins. */

package/dist/chat/slack/dashboard-link.d.ts

@@ -0,0 +1,9 @@
+export interface DashboardConversationLinkOptions {
+    basePath?: string;
+    baseURL?: string;
+    disabled?: boolean;
+}
+/** Configure core dashboard links used in Slack footers. */
+export declare function setDashboardConversationLinkOptions(options: DashboardConversationLinkOptions | undefined): DashboardConversationLinkOptions | undefined;
+/** Build the dashboard conversation URL when the core dashboard is enabled. */
+export declare function getDashboardConversationLink(conversationId: string): string | undefined;

package/dist/chat/state/adapter.d.ts

@@ -1,6 +1,5 @@
 import type { RedisStateAdapter } from "@chat-adapter/state-redis";
 import type { StateAdapter } from "chat";
-export declare const ACTIVE_LOCK_TTL_MS = 90000;
 export declare function getConnectedStateContext(): Promise<{
     redisStateAdapter?: RedisStateAdapter;
     stateAdapter: StateAdapter;

package/dist/chat/state/locks.d.ts

@@ -0,0 +1,7 @@
+import type { Lock, StateAdapter } from "chat";
+export declare const ACTIVE_LOCK_TTL_MS = 90000;
+/**
+ * Acquire a lock for long-running work that the queued state adapter should
+ * keep alive while the owning invocation is still making progress.
+ */
+export declare function acquireActiveLock(state: StateAdapter, threadId: string): Promise<Lock | null>;

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

@@ -7,7 +7,7 @@ export declare const CONVERSATION_WORK_LEASE_TTL_MS = 90000;
 export declare const CONVERSATION_WORK_CHECK_IN_INTERVAL_MS = 15000;
 export declare const CONVERSATION_WORK_STALE_ENQUEUE_MS = 60000;
 export type Source = "api" | "internal" | "local" | "plugin" | "scheduler" | "slack";
-export type ExecutionStatus = "awaiting_resume" | "idle" | "pending" | "running";
+export type ExecutionStatus = "awaiting_resume" | "failed" | "idle" | "pending" | "running";
 export interface AgentInput {
     attachments?: unknown[];
     authorId?: string;
@@ -127,6 +127,26 @@ export declare function recordConversationActivity(args: {
     state?: StateAdapter;
     title?: string;
 }): Promise<void>;
+/** Store task-execution metadata for local/no-SQL reporting. */
+export declare function recordConversationExecution(args: {
+    channelName?: string;
+    conversationId: string;
+    createdAtMs: number;
+    destination?: Destination;
+    execution: {
+        lastCheckpointAtMs?: number;
+        lastEnqueuedAtMs?: number;
+        runId?: string;
+        status: ExecutionStatus;
+        updatedAtMs?: number;
+    };
+    lastActivityAtMs: number;
+    requester?: StoredSlackRequester;
+    source?: Source;
+    state?: StateAdapter;
+    title?: string;
+    updatedAtMs: number;
+}): Promise<void>;
 /** Record that a wake-up nudge was accepted for the conversation. */
 export declare function markConversationWorkEnqueued(args: {
     conversationId: string;