@sentry/junior 0.53.0 → 0.54.0

package/dist/chat/xml.d.ts

@@ -0,0 +1 @@
+export declare function escapeXml(value: string): string;

package/dist/{chunk-XPXD3FCE.js → chunk-5LUISFEY.js}

@@ -1,6 +1,3 @@
-// src/chat/plugins/package-discovery.ts
-import path2 from "path";
-
 // src/chat/discovery.ts
 import fs, { statSync } from "fs";
 import path from "path";
@@ -220,9 +217,146 @@ function listReferenceFiles() {
   }
 }
 
+// src/package-resolution.ts
+import { statSync as statSync2 } from "fs";
+import { createRequire } from "module";
+import path2 from "path";
+function isDirectory2(targetPath) {
+  try {
+    return statSync2(targetPath).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function isFile2(targetPath) {
+  try {
+    return statSync2(targetPath).isFile();
+  } catch {
+    return false;
+  }
+}
+function uniqueResolvedPathsInOrder2(values) {
+  const seen = /* @__PURE__ */ new Set();
+  const resolved = [];
+  for (const value of values) {
+    const normalized = path2.resolve(value);
+    if (seen.has(normalized)) {
+      continue;
+    }
+    seen.add(normalized);
+    resolved.push(normalized);
+  }
+  return resolved;
+}
+function ancestorNodeModulesDirs(cwd) {
+  const dirs = [];
+  let current = path2.resolve(cwd);
+  while (true) {
+    const nodeModulesDir = path2.join(current, "node_modules");
+    if (isDirectory2(nodeModulesDir)) {
+      dirs.push(nodeModulesDir);
+    }
+    const parent = path2.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  return dirs;
+}
+function packageDirInNodeModules(nodeModulesDir, packageName) {
+  const packageDir = path2.join(nodeModulesDir, ...packageName.split("/"));
+  return isDirectory2(packageDir) ? path2.resolve(packageDir) : void 0;
+}
+function isValidPackageSegment(segment) {
+  return Boolean(segment) && segment !== "." && segment !== ".." && !segment.startsWith(".") && /^[A-Za-z0-9._~-]+$/.test(segment);
+}
+function isValidPackageName(packageName) {
+  if (!packageName || packageName.includes("\\") || path2.isAbsolute(packageName)) {
+    return false;
+  }
+  const parts = packageName.split("/");
+  if (parts[0].startsWith("@")) {
+    return parts.length === 2 && parts[0].length > 1 && isValidPackageSegment(parts[0].slice(1)) && isValidPackageSegment(parts[1]);
+  }
+  return parts.length === 1 && isValidPackageSegment(parts[0]);
+}
+function findPackageRoot(entryPath) {
+  let dir = path2.dirname(entryPath);
+  while (dir !== path2.dirname(dir)) {
+    if (isFile2(path2.join(dir, "package.json"))) {
+      return path2.resolve(dir);
+    }
+    dir = path2.dirname(dir);
+  }
+  return void 0;
+}
+function findPackageNodeModulesDir(packageDir, packageName) {
+  const parts = path2.resolve(packageDir).split(path2.sep);
+  const packageParts = packageName.split("/");
+  for (let index = parts.length - 1; index >= 0; index -= 1) {
+    if (parts[index] !== "node_modules") {
+      continue;
+    }
+    const candidatePackageParts = parts.slice(
+      index + 1,
+      index + 1 + packageParts.length
+    );
+    if (candidatePackageParts.join("/") !== packageParts.join("/")) {
+      continue;
+    }
+    return path2.resolve(parts.slice(0, index + 1).join(path2.sep) || path2.sep);
+  }
+  return void 0;
+}
+function resolvePackageWithNode(cwd, packageName) {
+  let requireFromCwd;
+  try {
+    requireFromCwd = createRequire(path2.join(cwd, "package.json"));
+  } catch {
+    return void 0;
+  }
+  for (const specifier of [`${packageName}/package.json`, packageName]) {
+    try {
+      const resolved = requireFromCwd.resolve(specifier);
+      const dir = specifier.endsWith("/package.json") ? path2.dirname(resolved) : findPackageRoot(resolved);
+      if (!dir) {
+        continue;
+      }
+      const nodeModulesDir = findPackageNodeModulesDir(dir, packageName);
+      return {
+        dir,
+        ...nodeModulesDir ? { nodeModulesDir } : {}
+      };
+    } catch {
+    }
+  }
+  return void 0;
+}
+function resolvePackageLocation(cwd, packageName, options) {
+  if (!isValidPackageName(packageName)) {
+    return void 0;
+  }
+  const nodeModulesDirs = uniqueResolvedPathsInOrder2([
+    ...options?.nodeModulesDirs ?? [],
+    ...ancestorNodeModulesDirs(cwd)
+  ]);
+  for (const nodeModulesDir of nodeModulesDirs) {
+    const dir = packageDirInNodeModules(nodeModulesDir, packageName);
+    if (dir) {
+      return { dir, nodeModulesDir };
+    }
+  }
+  return resolvePackageWithNode(cwd, packageName);
+}
+function resolvePackageDir(cwd, packageName) {
+  return resolvePackageLocation(cwd, packageName)?.dir;
+}
+
 // src/chat/plugins/package-discovery.ts
+import path3 from "path";
 function normalizeForGlob(targetPath) {
-  return targetPath.split(path2.sep).join("/");
+  return targetPath.split(path3.sep).join("/");
 }
 function uniqueStringsInOrder(values) {
   const seen = /* @__PURE__ */ new Set();
@@ -237,33 +371,47 @@ function uniqueStringsInOrder(values) {
   return resolved;
 }
 function pathForTracingInclude(cwd, targetPath) {
-  const relative = path2.relative(cwd, targetPath);
-  if (!relative || path2.isAbsolute(relative)) {
+  const relative = path3.relative(cwd, targetPath);
+  if (!relative || path3.isAbsolute(relative) || relative === ".." || relative.startsWith(`..${path3.sep}`)) {
     return null;
   }
   const normalized = normalizeForGlob(relative);
   return normalized.startsWith(".") ? normalized : `./${normalized}`;
 }
-var configuredPluginPackages;
-function setPluginPackages(packages) {
-  configuredPluginPackages = packages;
-}
-function resolvePackageDirFromName(packageName, candidateNodeModulesDirs) {
-  for (const nodeModulesDir of candidateNodeModulesDirs) {
-    const packageDir = path2.join(nodeModulesDir, ...packageName.split("/"));
-    if (isDirectory(packageDir)) {
-      return {
-        dir: path2.resolve(packageDir),
-        nodeModulesDir: path2.resolve(nodeModulesDir)
-      };
+function normalizePluginPackageNames(packageNames) {
+  if (packageNames === void 0) {
+    return [];
+  }
+  if (!Array.isArray(packageNames)) {
+    throw new Error("plugins.packages must be an array of package names");
+  }
+  const normalized = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const packageName of packageNames) {
+    const normalizedPackageName = typeof packageName === "string" ? packageName.trim() : "";
+    if (!normalizedPackageName || !isValidPackageName(normalizedPackageName)) {
+      throw new Error("Plugin package names must be valid npm package names");
+    }
+    if (seen.has(normalizedPackageName)) {
+      continue;
     }
+    seen.add(normalizedPackageName);
+    normalized.push(normalizedPackageName);
   }
-  return null;
+  return normalized;
+}
+function formatNodeModulesDirs(candidateNodeModulesDirs) {
+  return candidateNodeModulesDirs.length > 0 ? candidateNodeModulesDirs.join(", ") : "none found";
+}
+function resolvePackageDirFromName(cwd, packageName, candidateNodeModulesDirs) {
+  return resolvePackageLocation(cwd, packageName, {
+    nodeModulesDirs: candidateNodeModulesDirs
+  }) ?? null;
 }
 function readPluginPackageFlags(dir) {
-  const hasRootPluginManifest = isFile(path2.join(dir, "plugin.yaml"));
-  const hasPluginsDir = isDirectory(path2.join(dir, "plugins"));
-  const hasSkillsDir = isDirectory(path2.join(dir, "skills"));
+  const hasRootPluginManifest = isFile(path3.join(dir, "plugin.yaml"));
+  const hasPluginsDir = isDirectory(path3.join(dir, "plugins"));
+  const hasSkillsDir = isDirectory(path3.join(dir, "skills"));
   if (!hasRootPluginManifest && !hasPluginsDir && !hasSkillsDir) {
     return null;
   }
@@ -273,26 +421,29 @@ function readPluginPackageFlags(dir) {
     hasSkillsDir
   };
 }
-function discoverDeclaredPackages(packageNames, candidateNodeModulesDirs) {
+function discoverDeclaredPackages(packageNames, candidateNodeModulesDirs, cwd) {
   const discovered = [];
-  const seenPackageNames = /* @__PURE__ */ new Set();
   const seenPackageDirs = /* @__PURE__ */ new Set();
   for (const packageName of packageNames) {
     const resolved = resolvePackageDirFromName(
+      cwd,
       packageName,
       candidateNodeModulesDirs
     );
     if (!resolved) {
-      continue;
+      throw new Error(
+        `Plugin package "${packageName}" was configured but could not be resolved from node_modules or package resolution (${formatNodeModulesDirs(candidateNodeModulesDirs)})`
+      );
     }
-    if (seenPackageNames.has(packageName) || seenPackageDirs.has(resolved.dir)) {
+    if (seenPackageDirs.has(resolved.dir)) {
       continue;
     }
     const pluginFlags = readPluginPackageFlags(resolved.dir);
     if (!pluginFlags) {
-      continue;
+      throw new Error(
+        `Plugin package "${packageName}" was configured but does not contain plugin content; expected plugin.yaml, plugins/, or skills/ in ${resolved.dir}`
+      );
     }
-    seenPackageNames.add(packageName);
     seenPackageDirs.add(resolved.dir);
     discovered.push({
       name: packageName,
@@ -304,12 +455,13 @@ function discoverDeclaredPackages(packageNames, candidateNodeModulesDirs) {
   return discovered;
 }
 function discoverInstalledPluginPackageContent(cwd = process.cwd(), options) {
-  const resolvedCwd = path2.resolve(cwd);
-  const packageNames = options?.packageNames ?? configuredPluginPackages ?? [];
+  const resolvedCwd = path3.resolve(cwd);
+  const packageNames = normalizePluginPackageNames(options?.packageNames);
   const nodeModulesDirs = options?.nodeModulesDirs ?? discoverNodeModulesDirs(resolvedCwd);
   const discoveredPackages = discoverDeclaredPackages(
     packageNames,
-    nodeModulesDirs
+    nodeModulesDirs,
+    resolvedCwd
   );
   const manifestRoots = [];
   const skillRoots2 = [];
@@ -317,7 +469,7 @@ function discoverInstalledPluginPackageContent(cwd = process.cwd(), options) {
   for (const pkg of discoveredPackages) {
     const tracingBasePath = pkg.nodeModulesDir ? pathForTracingInclude(
       resolvedCwd,
-      path2.join(pkg.nodeModulesDir, ...pkg.name.split("/"))
+      path3.join(pkg.nodeModulesDir, ...pkg.name.split("/"))
     ) : pathForTracingInclude(resolvedCwd, pkg.dir);
     if (pkg.hasRootPluginManifest) {
       manifestRoots.push(pkg.dir);
@@ -326,13 +478,13 @@ function discoverInstalledPluginPackageContent(cwd = process.cwd(), options) {
       }
     }
     if (pkg.hasPluginsDir) {
-      manifestRoots.push(path2.join(pkg.dir, "plugins"));
+      manifestRoots.push(path3.join(pkg.dir, "plugins"));
       if (tracingBasePath) {
         tracingIncludes.push(`${tracingBasePath}/plugins/**/*`);
       }
     }
     if (pkg.hasSkillsDir) {
-      skillRoots2.push(path2.join(pkg.dir, "skills"));
+      skillRoots2.push(path3.join(pkg.dir, "skills"));
       if (tracingBasePath) {
         tracingIncludes.push(`${tracingBasePath}/skills/**/*`);
       }
@@ -355,6 +507,8 @@ export {
   soulPathCandidates,
   worldPathCandidates,
   listReferenceFiles,
-  setPluginPackages,
+  isValidPackageName,
+  resolvePackageDir,
+  normalizePluginPackageNames,
   discoverInstalledPluginPackageContent
 };

package/dist/{chunk-KCOKQLBF.js → chunk-7WTXNEPF.js}

@@ -7,14 +7,14 @@ import {
   serializeGenAiAttribute,
   setSpanAttributes,
   withSpan
-} from "./chunk-Q3FDONU7.js";
+} from "./chunk-YITDDLS3.js";
 
 // src/chat/state/adapter.ts
 import { createMemoryState } from "@chat-adapter/state-memory";
 import { createRedisState } from "@chat-adapter/state-redis";
 
 // src/chat/config.ts
-import { getModel } from "@mariozechner/pi-ai";
+import { getModel } from "@earendil-works/pi-ai";
 
 // src/chat/optional-string.ts
 function toOptionalTrimmed(value) {
@@ -31,11 +31,11 @@ import {
   getEnvApiKey,
   getModels,
   registerApiProvider
-} from "@mariozechner/pi-ai";
+} from "@earendil-works/pi-ai";
 import {
   streamAnthropic,
   streamSimpleAnthropic
-} from "@mariozechner/pi-ai/anthropic";
+} from "@earendil-works/pi-ai/anthropic";
 registerApiProvider({
   api: "anthropic-messages",
   stream: streamAnthropic,
@@ -413,25 +413,124 @@ function getRuntimeMetadata() {
 }
 
 // src/chat/state/adapter.ts
-var MIN_LOCK_TTL_MS = 1e3 * 60 * 5;
+var ACTIVE_LOCK_TTL_MS = 9e4;
+var ACTIVE_LOCK_HEARTBEAT_MS = 3e4;
 var stateAdapter;
 var redisStateAdapter;
-function createQueuedStateAdapter(base) {
+function createQueuedStateAdapter(base, options) {
+  const heartbeats = /* @__PURE__ */ new Map();
+  const effectiveLockTtlMs = (ttlMs) => Math.max(ttlMs, ACTIVE_LOCK_TTL_MS);
+  const shouldHeartbeatLock = (ttlMs) => ttlMs <= ACTIVE_LOCK_TTL_MS;
+  const heartbeatKey = (lock) => `${lock.threadId}:${lock.token}`;
+  const stopHeartbeatByKey = (key) => {
+    const heartbeat = heartbeats.get(key);
+    if (!heartbeat) {
+      return;
+    }
+    clearInterval(heartbeat.timer);
+    heartbeats.delete(key);
+  };
+  const stopHeartbeat = (lock) => {
+    stopHeartbeatByKey(heartbeatKey(lock));
+  };
+  const stopHeartbeatsForThread = (threadId) => {
+    for (const [key, heartbeat] of heartbeats) {
+      if (heartbeat.lock.threadId === threadId) {
+        stopHeartbeatByKey(key);
+      }
+    }
+  };
+  const stopAllHeartbeats = () => {
+    for (const key of heartbeats.keys()) {
+      stopHeartbeatByKey(key);
+    }
+  };
+  const runHeartbeat = async (key) => {
+    const heartbeat = heartbeats.get(key);
+    if (!heartbeat || heartbeat.inFlight) {
+      return;
+    }
+    heartbeat.inFlight = true;
+    try {
+      if (Date.now() - heartbeat.startedAtMs >= options.activeLockMaxAgeMs) {
+        stopHeartbeatByKey(key);
+        return;
+      }
+      const extended = await base.extendLock(heartbeat.lock, heartbeat.ttlMs);
+      if (!extended) {
+        stopHeartbeatByKey(key);
+        return;
+      }
+      heartbeat.lock.expiresAt = Date.now() + heartbeat.ttlMs;
+    } catch {
+    } finally {
+      const current = heartbeats.get(key);
+      if (current === heartbeat) {
+        current.inFlight = false;
+      }
+    }
+  };
+  const startOrUpdateHeartbeat = (lock, ttlMs) => {
+    const key = heartbeatKey(lock);
+    const existing = heartbeats.get(key);
+    if (existing) {
+      existing.ttlMs = ttlMs;
+      return;
+    }
+    const timer = setInterval(() => {
+      void runHeartbeat(key);
+    }, ACTIVE_LOCK_HEARTBEAT_MS);
+    timer.unref?.();
+    heartbeats.set(key, {
+      inFlight: false,
+      lock,
+      startedAtMs: Date.now(),
+      timer,
+      ttlMs
+    });
+  };
   const acquireLock = async (threadId, ttlMs) => {
-    const effectiveTtlMs = Math.max(ttlMs, MIN_LOCK_TTL_MS);
-    return await base.acquireLock(threadId, effectiveTtlMs);
+    const effectiveTtlMs = effectiveLockTtlMs(ttlMs);
+    const lock = await base.acquireLock(threadId, effectiveTtlMs);
+    if (lock && shouldHeartbeatLock(ttlMs)) {
+      startOrUpdateHeartbeat(lock, effectiveTtlMs);
+    }
+    return lock;
   };
   return {
-    appendToList: (key, value, options) => base.appendToList(key, value, options),
+    appendToList: (key, value, options2) => base.appendToList(key, value, options2),
     connect: () => base.connect(),
-    disconnect: () => base.disconnect(),
+    disconnect: async () => {
+      stopAllHeartbeats();
+      await base.disconnect();
+    },
     subscribe: (threadId) => base.subscribe(threadId),
     unsubscribe: (threadId) => base.unsubscribe(threadId),
     isSubscribed: (threadId) => base.isSubscribed(threadId),
     acquireLock,
-    releaseLock: (lock) => base.releaseLock(lock),
-    extendLock: (lock, ttlMs) => base.extendLock(lock, Math.max(ttlMs, MIN_LOCK_TTL_MS)),
-    forceReleaseLock: (threadId) => base.forceReleaseLock(threadId),
+    releaseLock: async (lock) => {
+      stopHeartbeat(lock);
+      await base.releaseLock(lock);
+    },
+    extendLock: async (lock, ttlMs) => {
+      const effectiveTtlMs = effectiveLockTtlMs(ttlMs);
+      const extended = await base.extendLock(lock, effectiveTtlMs);
+      if (extended) {
+        lock.expiresAt = Date.now() + effectiveTtlMs;
+        if (shouldHeartbeatLock(ttlMs)) {
+          startOrUpdateHeartbeat(lock, effectiveTtlMs);
+        } else {
+          stopHeartbeat(lock);
+        }
+      } else {
+        stopHeartbeat(lock);
+      }
+      return extended;
+    },
+    forceReleaseLock: async (threadId) => {
+      stopHeartbeatsForThread(threadId);
+      await base.forceReleaseLock(threadId);
+    },
     enqueue: (threadId, entry, maxSize) => base.enqueue(threadId, entry, maxSize),
     dequeue: (threadId) => base.dequeue(threadId),
     queueDepth: (threadId) => base.queueDepth(threadId),
@@ -444,9 +543,12 @@ function createQueuedStateAdapter(base) {
 }
 function createStateAdapter() {
   const config = getChatConfig();
+  const activeLockMaxAgeMs = config.bot.turnTimeoutMs + ACTIVE_LOCK_TTL_MS;
   if (config.state.adapter === "memory") {
     redisStateAdapter = void 0;
-    return createQueuedStateAdapter(createMemoryState());
+    return createQueuedStateAdapter(createMemoryState(), {
+      activeLockMaxAgeMs
+    });
   }
   if (!config.state.redisUrl) {
     throw new Error("REDIS_URL is required for durable Slack thread state");
@@ -455,7 +557,9 @@ function createStateAdapter() {
     url: config.state.redisUrl
   });
   redisStateAdapter = redisState;
-  return createQueuedStateAdapter(redisState);
+  return createQueuedStateAdapter(redisState, {
+    activeLockMaxAgeMs
+  });
 }
 function getStateAdapter() {
   if (!stateAdapter) {
@@ -1173,6 +1277,7 @@ export {
   getSlackClientId,
   getSlackClientSecret,
   getRuntimeMetadata,
+  ACTIVE_LOCK_TTL_MS,
   getStateAdapter,
   disconnectStateAdapter,
   SANDBOX_WORKSPACE_ROOT,

package/dist/{chunk-ZNFNY53B.js → chunk-QCHPJ4FD.js}

@@ -2,10 +2,10 @@ import {
   getPluginForSkillPath,
   getPluginSkillRoots,
   logWarn
-} from "./chunk-Q3FDONU7.js";
+} from "./chunk-YITDDLS3.js";
 import {
   skillRoots
-} from "./chunk-XPXD3FCE.js";
+} from "./chunk-5LUISFEY.js";
 
 // src/chat/skills.ts
 import fs from "fs/promises";

package/dist/{chunk-Q3FDONU7.js → chunk-YITDDLS3.js}

@@ -3,8 +3,9 @@ import {
 } from "./chunk-Z3YD6NHK.js";
 import {
   discoverInstalledPluginPackageContent,
+  normalizePluginPackageNames,
   pluginRoots
-} from "./chunk-XPXD3FCE.js";
+} from "./chunk-5LUISFEY.js";
 
 // src/chat/logging.ts
 import { AsyncLocalStorage } from "async_hooks";
@@ -2881,33 +2882,9 @@ function normalizePluginRoots(roots) {
   }
   return resolved;
 }
-function getExtraPluginRoots() {
-  const raw = process.env.JUNIOR_EXTRA_PLUGIN_ROOTS?.trim();
-  if (!raw) {
-    return [];
-  }
-  if (raw.startsWith("[")) {
-    try {
-      const parsed = JSON.parse(raw);
-      if (Array.isArray(parsed)) {
-        return normalizePluginRoots(
-          parsed.filter((value) => typeof value === "string")
-        );
-      }
-    } catch {
-      return [];
-    }
-  }
-  return normalizePluginRoots(
-    raw.split(path2.delimiter).map((entry) => entry.trim()).filter((entry) => entry.length > 0)
-  );
-}
 function getPluginCatalogSource() {
-  const packagedContent = discoverInstalledPluginPackageContent();
-  const localRoots = normalizePluginRoots([
-    ...pluginRoots(),
-    ...getExtraPluginRoots()
-  ]);
+  const packagedContent = discoverConfiguredPluginPackageContent();
+  const localRoots = normalizePluginRoots(pluginRoots());
   const manifestRoots = normalizePluginRoots([
     ...localRoots,
     ...packagedContent.manifestRoots
@@ -2924,6 +2901,29 @@ function getPluginCatalogSource() {
     })
   };
 }
+function normalizePluginConfig(config) {
+  if (!config) {
+    return void 0;
+  }
+  return {
+    packages: normalizePluginPackageNames(config.packages),
+    ...config.manifests ? { manifests: structuredClone(config.manifests) } : {}
+  };
+}
+function clonePluginConfig(config) {
+  if (!config) {
+    return void 0;
+  }
+  return {
+    packages: [...config.packages ?? []],
+    ...config.manifests ? { manifests: structuredClone(config.manifests) } : {}
+  };
+}
+function discoverConfiguredPluginPackageContent() {
+  return discoverInstalledPluginPackageContent(process.cwd(), {
+    packageNames: pluginConfig?.packages
+  });
+}
 function buildLoadedPluginState(source) {
   const state = createLoadedPluginState(source.signature);
   for (const skillRoot of source.packagedSkillRoots) {
@@ -3037,7 +3037,12 @@ function ensurePluginsLoaded() {
   return state;
 }
 function setPluginConfig(config) {
-  pluginConfig = config;
+  const previousConfig = clonePluginConfig(pluginConfig);
+  pluginConfig = normalizePluginConfig(config);
+  return previousConfig;
+}
+function getPluginPackageContent() {
+  return discoverConfiguredPluginPackageContent();
 }
 function getPluginCatalogSignature() {
   return ensurePluginsLoaded().signature;
@@ -3208,6 +3213,7 @@ export {
   buildOAuthTokenRequest,
   parseOAuthTokenResponse,
   setPluginConfig,
+  getPluginPackageContent,
   getPluginCatalogSignature,
   getPluginCapabilityProviders,
   getPluginProviders,

package/dist/cli/check.js

@@ -1,11 +1,11 @@
 import {
   parseSkillFile
-} from "../chunk-ZNFNY53B.js";
+} from "../chunk-QCHPJ4FD.js";
 import {
   parsePluginManifest
-} from "../chunk-Q3FDONU7.js";
+} from "../chunk-YITDDLS3.js";
 import "../chunk-Z3YD6NHK.js";
-import "../chunk-XPXD3FCE.js";
+import "../chunk-5LUISFEY.js";
 import "../chunk-2KG3PWR4.js";
 
 // src/cli/check.ts

package/dist/cli/init.js

@@ -171,6 +171,7 @@ Operational context and domain knowledge for ${name}.
     path.join(target, ".env.example"),
     `SLACK_BOT_TOKEN=
 SLACK_SIGNING_SECRET=
+JUNIOR_SECRET=
 JUNIOR_BOT_NAME=
 AI_MODEL=
 AI_FAST_MODEL=

package/dist/cli/snapshot-warmup.js

@@ -1,14 +1,14 @@
 import {
   disconnectStateAdapter,
   resolveRuntimeDependencySnapshot
-} from "../chunk-KCOKQLBF.js";
+} from "../chunk-7WTXNEPF.js";
 import {
   getPluginProviders,
   getPluginRuntimeDependencies,
   getPluginRuntimePostinstall
-} from "../chunk-Q3FDONU7.js";
+} from "../chunk-YITDDLS3.js";
 import "../chunk-Z3YD6NHK.js";
-import "../chunk-XPXD3FCE.js";
+import "../chunk-5LUISFEY.js";
 import "../chunk-2KG3PWR4.js";
 
 // src/cli/snapshot-warmup.ts

package/dist/handlers/diagnostics-dashboard.d.ts

@@ -0,0 +1,2 @@
+/** Serve an HTML diagnostics dashboard showing health, plugins, and skills. */
+export declare function GET(): Promise<Response>;

package/dist/handlers/diagnostics.d.ts

@@ -0,0 +1,2 @@
+/** Return a runtime discovery snapshot for built-app diagnostics. */
+export declare function GET(): Promise<Response>;

package/dist/handlers/health.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Returns a minimal JSON health response for runtime health checks.
+ */
+export declare function GET(): Response;

package/dist/handlers/mcp-oauth-callback.d.ts

@@ -0,0 +1,2 @@
+import type { WaitUntilFn } from "@/handlers/types";
+export declare function GET(request: Request, provider: string, waitUntil: WaitUntilFn): Promise<Response>;

package/dist/handlers/oauth-callback.d.ts

@@ -0,0 +1,2 @@
+import type { WaitUntilFn } from "@/handlers/types";
+export declare function GET(request: Request, provider: string, waitUntil: WaitUntilFn): Promise<Response>;

package/dist/handlers/oauth-html.d.ts

@@ -0,0 +1,2 @@
+/** Build a simple centered HTML callback page. Callers must pre-escape dynamic strings. */
+export declare function htmlCallbackResponse(title: string, message: string, status: number): Response;