@wrongstack/core 0.292.0 → 0.292.1

package/dist/index.js

@@ -1366,12 +1366,43 @@ async function backupConfigFile(filePath, paths) {
   }
 }
 
+// src/utils/connectivity.ts
+var DEFAULT_PROBE_URL = "https://1.1.1.1";
+var DEFAULT_TIMEOUT_MS = 5e3;
+var DEFAULT_TTL_MS = 3e4;
+var cached;
+async function checkConnectivity(opts) {
+  const url = opts?.probeUrl ?? DEFAULT_PROBE_URL;
+  const timeout = opts?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const ttl = opts?.ttlMs ?? DEFAULT_TTL_MS;
+  if (cached && ttl > 0 && Date.now() - cached.at < ttl) {
+    return cached.ok;
+  }
+  cached = { ok: await probe(url, timeout), at: Date.now() };
+  return cached.ok;
+}
+async function probe(url, timeoutMs) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    await fetch(url, { method: "HEAD", signal: controller.signal });
+    return true;
+  } catch {
+    return false;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function resetConnectivityCache() {
+  cached = void 0;
+}
+
 // src/utils/cache-key.ts
 import { createHash } from "node:crypto";
 var keyCache = /* @__PURE__ */ new WeakMap();
 function deriveCachePrefixKey(systemPrompt) {
-  const cached = keyCache.get(systemPrompt);
-  if (cached !== void 0) return cached;
+  const cached2 = keyCache.get(systemPrompt);
+  if (cached2 !== void 0) return cached2;
   const h = createHash("sha256");
   for (const block of systemPrompt) h.update(block.text).update("\0");
   const key = `ws-${h.digest("hex").slice(0, 32)}`;
@@ -3099,8 +3130,8 @@ ${agentList}`;
       modelCapabilities?.supportsVision ? 1 : 0,
       modelCapabilities?.supportsReasoning ? 1 : 0
     ].join("\0");
-    const cached = this.envCacheByRoot.get(cacheKey);
-    if (cached) return cached;
+    const cached2 = this.envCacheByRoot.get(cacheKey);
+    if (cached2) return cached2;
     const today = this.opts.todayIso ?? (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
     const platform4 = `${os2.platform()} ${os2.release()}`;
     const effShell = effectiveShell(os2.platform(), process.env["WRONGSTACK_SHELL"]);
@@ -3460,8 +3491,8 @@ var compactCache = /* @__PURE__ */ new WeakMap();
 function compactToolDefinitionForWire(tool, opts = {}) {
   const useDefaultOptions = opts.descriptionMaxChars === void 0 && opts.schemaDescriptionMaxChars === void 0;
   if (useDefaultOptions && typeof tool === "object" && tool !== null) {
-    const cached = compactCache.get(tool);
-    if (cached) return cached;
+    const cached2 = compactCache.get(tool);
+    if (cached2) return cached2;
   }
   const compact = {
     name: tool.name,
@@ -3649,8 +3680,8 @@ function realAnchoredInputTokens(messages, anchorTokens, anchorMsgCount) {
   return anchorTokens + delta;
 }
 function estimateToolDefTokens(tool) {
-  const cached = tool._estDefTokens;
-  if (typeof cached === "number" && cached > 0) return cached;
+  const cached2 = tool._estDefTokens;
+  if (typeof cached2 === "number" && cached2 > 0) return cached2;
   const compact = compactToolDefinitionForWire(tool);
   return RoughTokenEstimate(tool.name) + RoughTokenEstimate(compact.description) + RoughTokenEstimate(JSON.stringify(compact.inputSchema));
 }
@@ -3661,9 +3692,9 @@ function estimateRequestTokens(messages, systemPrompt, tools, calibrationKey = C
   } else if (Array.isArray(messages)) {
     for (const m of messages) {
       if (typeof m === "object" && m !== null && "content" in m) {
-        const cached = m._estTokens;
-        if (typeof cached === "number" && cached > 0) {
-          messagesTokens += cached;
+        const cached2 = m._estTokens;
+        if (typeof cached2 === "number" && cached2 > 0) {
+          messagesTokens += cached2;
           continue;
         }
         const content = m.content;
@@ -4291,8 +4322,8 @@ var COMPILED_GLOB_CACHE = /* @__PURE__ */ new Map();
 var CACHE_MAX_SIZE = 2e3;
 var NEVER_MATCH = /[^\s\S]/;
 function getCachedGlob(pattern) {
-  const cached = COMPILED_GLOB_CACHE.get(pattern);
-  if (cached) return cached;
+  const cached2 = COMPILED_GLOB_CACHE.get(pattern);
+  if (cached2) return cached2;
   if (COMPILED_GLOB_CACHE.size >= CACHE_MAX_SIZE) {
     const keys = [...COMPILED_GLOB_CACHE.keys()];
     for (let i = 0; i < Math.floor(CACHE_MAX_SIZE / 4); i++) {
@@ -7978,9 +8009,9 @@ var DefaultConfigLoader = class _DefaultConfigLoader {
     try {
       const stat27 = await fs9.stat(file);
       mtimeMs = stat27.mtimeMs;
-      const cached = this.jsonCache.get(file);
-      if (cached && cached.mtimeMs === mtimeMs) {
-        return structuredClone(cached.value);
+      const cached2 = this.jsonCache.get(file);
+      if (cached2 && cached2.mtimeMs === mtimeMs) {
+        return structuredClone(cached2.value);
       }
     } catch (err) {
       if (err.code === "ENOENT") {
@@ -11759,8 +11790,8 @@ var candidateCache = /* @__PURE__ */ new Map();
 function agentPrompt(id) {
   const envDir = process.env["WRONGSTACK_AGENT_INSTRUCTIONS_DIR"] ?? "";
   const cacheKey = `${envDir}\0${id}`;
-  const cached = promptCache.get(cacheKey);
-  if (cached !== void 0) return cached;
+  const cached2 = promptCache.get(cacheKey);
+  if (cached2 !== void 0) return cached2;
   const fileName = `${id}.md`;
   let resolved = "";
   for (const dir of agentPromptDirCandidates(envDir)) {
@@ -11776,8 +11807,8 @@ function agentPrompt(id) {
 function agentPromptDirCandidates(envDir) {
   const globalRoot = process.env["WRONGSTACK_HOME"] || path19.join(os6.homedir(), ".wrongstack");
   const candKey = `${envDir}\0${globalRoot}`;
-  const cached = candidateCache.get(candKey);
-  if (cached !== void 0) return cached;
+  const cached2 = candidateCache.get(candKey);
+  if (cached2 !== void 0) return cached2;
   const here = path19.dirname(fileURLToPath3(import.meta.url));
   const explicitDir = envDir || void 0;
   const candidates = [
@@ -15839,8 +15870,8 @@ import { fileURLToPath as fileURLToPath4 } from "node:url";
 var textCache = /* @__PURE__ */ new Map();
 var rootCandidates;
 function readBundledInstructionText(relativePath) {
-  const cached = textCache.get(relativePath);
-  if (cached !== void 0) return cached;
+  const cached2 = textCache.get(relativePath);
+  if (cached2 !== void 0) return cached2;
   let resolved = "";
   for (const root of instructionRootCandidates()) {
     try {
@@ -17815,7 +17846,8 @@ function effectiveInputTokens(usage) {
 }
 var CONTEXT_OVERFLOW_RE = /context.length|context.window|maximum context|max.*tokens?.*exceeded|prompt is too long|too long|exceeds the context|\btokens\b.*exceed|too many tokens|reduce the length|resulted in \d+ tokens|input.{0,12}too (?:large|long)|context_length_exceeded/i;
 var CONTENT_FILTER_RE = /content.(filter|policy|moderation)|safety (system|filter)/i;
-var QUOTA_EXHAUSTED_RE = /(?:insufficient|exhausted|depleted|exceeded|no|not enough)[-_\s]*(?:quota|credit|balance)|(?:quota|credit|balance)[-_\s]*(?:exhausted|depleted|exceeded|insufficient)|billing[_\s-]*(?:hard[_\s-]*)?limit|payment required|spending limit|plan limit/i;
+var QUOTA_EXHAUSTED_RE = /(?:insufficient|exhausted|depleted|exceeded|no|not enough)[-_\s]*(?:quota|credit|balance)|(?:quota|credit|balance)[-_\s]*(?:exhausted|depleted|exceeded|insufficient)|billing[_\s-]*(?:hard[_\s-]*)?limit|payment required|spending limit|plan limit|usage[-_\s]*limit[-_\s]*(?:reached|exceeded)/i;
+var RATE_LIMIT_EXCEEDED_RE = /rate[-_\s]*limit[-_\s]*exceeded/i;
 function classifyProviderError(status, body, message) {
   const type = body?.type;
   const text2 = [message, body?.message, type, body?.raw].filter(Boolean).join("\n");
@@ -17823,6 +17855,9 @@ function classifyProviderError(status, body, message) {
   if (status === 408) return "timeout";
   if (status === 599) return "stream_hang";
   if (status === 402 || QUOTA_EXHAUSTED_RE.test(text2)) return "quota_exhausted";
+  if (status === 429 && body?.message && RATE_LIMIT_EXCEEDED_RE.test(body.message)) {
+    return "quota_exhausted";
+  }
   if (type === "rate_limit_error" || status === 429) return "rate_limit";
   if (type === "overloaded_error" || status === 529) return "overloaded";
   if (status >= 500) return "server";
@@ -18545,6 +18580,12 @@ function createFallbackModelExtension(deps) {
             continue;
           const status = shouldFallback(lastErr);
           if (status === null) break;
+          if (tracker && !tracker.isAvailable(entry.providerId, entry.model)) {
+            deps.logger?.warn(
+              `provider-status: "${entry.providerId}/${entry.model}" entered the waiting room since the chain was computed \u2014 skipping`
+            );
+            continue;
+          }
           const targetProviderId = entry.providerId;
           const targetModel = entry.model;
           if (targetProviderId === ctx_.provider.id && targetModel === ctx_.model) continue;
@@ -19350,8 +19391,8 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
   async awaitTasks(taskIds) {
     return Promise.all(
       taskIds.map((id) => {
-        const cached = this.completedResults.find((r) => r.taskId === id);
-        if (cached) return cached;
+        const cached2 = this.completedResults.find((r) => r.taskId === id);
+        if (cached2) return cached2;
         return new Promise((resolve34, reject) => {
           const timeout = setTimeout(() => {
             this.off("task.completed", handler);
@@ -21318,8 +21359,8 @@ var Director = class _Director {
   awaitTasks(taskIds) {
     return Promise.all(
       taskIds.map((id) => {
-        const cached = this.completed.get(id);
-        if (cached) return cached;
+        const cached2 = this.completed.get(id);
+        if (cached2) return cached2;
         const existing = this.taskWaiters.get(id);
         if (existing) return existing.promise;
         let resolve34;
@@ -22815,17 +22856,17 @@ var SessionCheckpointCas = class {
     if (!normalized) throw new Error("invalid relative path");
     const output = path25.resolve(target, ...normalized.split("/"));
     if (!isInside(target, output)) throw new Error("path escapes checkpoint target");
-    let probe = output;
+    let probe2 = output;
     for (; ; ) {
       try {
-        const real = await fsp9.realpath(probe);
+        const real = await fsp9.realpath(probe2);
         if (!isInside(realTarget, real)) throw new Error("path resolves through a symlink outside checkpoint target");
         return output;
       } catch (err) {
         if (err.code !== "ENOENT") throw err;
-        const parent = path25.dirname(probe);
-        if (parent === probe) throw err;
-        probe = parent;
+        const parent = path25.dirname(probe2);
+        if (parent === probe2) throw err;
+        probe2 = parent;
       }
     }
   }
@@ -23422,13 +23463,13 @@ var DefaultSessionStore = class _DefaultSessionStore {
     try {
       const s = await fsp11.stat(file);
       const stat27 = { mtimeMs: s.mtimeMs, size: s.size };
-      const cached = this._loadCache.get(id);
-      if (cached && cached.mtimeMs === stat27.mtimeMs && cached.size === stat27.size) {
+      const cached2 = this._loadCache.get(id);
+      if (cached2 && cached2.mtimeMs === stat27.mtimeMs && cached2.size === stat27.size) {
         cacheHit = true;
         this._loadCache.delete(id);
-        this._loadCache.set(id, cached);
-        if (mode.full) return cached.data;
-        return { ...cached.data, messages: [] };
+        this._loadCache.set(id, cached2);
+        if (mode.full) return cached2.data;
+        return { ...cached2.data, messages: [] };
       }
       const events = [];
       let sessionStartEvent;
@@ -23959,8 +24000,8 @@ var DefaultSessionStore = class _DefaultSessionStore {
     return shardKeys;
   }
   async readOrBuildShardManifest(shardKey) {
-    const cached = this.shardManifestCache.get(shardKey);
-    if (cached) return cached;
+    const cached2 = this.shardManifestCache.get(shardKey);
+    if (cached2) return cached2;
     const manifestPath = this.shardManifestPath(shardKey);
     try {
       const raw = await fsp11.readFile(manifestPath, "utf8");
@@ -28102,6 +28143,8 @@ import { timingSafeEqual } from "node:crypto";
 var MAILBOX_HTTP_MAX_BODY_BYTES = 256 * 1024;
 var MAILBOX_HTTP_RATE_LIMIT_PER_MINUTE = 120;
 var MAILBOX_HTTP_RATE_LIMIT_WINDOW_MS = 6e4;
+var MAILBOX_HTTP_DEFAULT_MAX_AGE_MS = 60 * 60 * 1e3;
+var MAILBOX_HTTP_MAX_AGE_CEILING_MS = 7 * 24 * 60 * 60 * 1e3;
 function authorizeMailboxBearerToken(request, expectedToken) {
   const header = request.headers.authorization;
   if (typeof header !== "string") return { allowed: false };
@@ -28145,6 +28188,7 @@ var MailboxHttpRateLimiter = class {
 };
 function createMailboxHttpRouter(options) {
   const maxBodyBytes = options.maxBodyBytes ?? MAILBOX_HTTP_MAX_BODY_BYTES;
+  const defaultMaxAgeMs = options.defaultMaxAgeMs ?? void 0;
   const closeSseStreams = /* @__PURE__ */ new Set();
   return {
     async handle(request, response, routePath) {
@@ -28159,15 +28203,17 @@ function createMailboxHttpRouter(options) {
         if (!access10.allowed) {
           const forwardedFor = request.headers["x-forwarded-for"];
           const clientIp = (Array.isArray(forwardedFor) ? forwardedFor[0] : forwardedFor)?.split(",")[0]?.trim() ?? request.socket?.remoteAddress ?? "unknown";
-          console.warn(JSON.stringify({
-            level: "warn",
-            event: "mailbox.http_auth_failure",
-            message: `Mailbox HTTP auth rejected for ${request.method ?? "?"} ${request.url ?? "?"} from ${clientIp}`,
-            method: request.method,
-            url: request.url,
-            clientIp,
-            timestamp: (/* @__PURE__ */ new Date()).toISOString()
-          }));
+          console.warn(
+            JSON.stringify({
+              level: "warn",
+              event: "mailbox.http_auth_failure",
+              message: `Mailbox HTTP auth rejected for ${request.method ?? "?"} ${request.url ?? "?"} from ${clientIp}`,
+              method: request.method,
+              url: request.url,
+              clientIp,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            })
+          );
           writeJson(
             response,
             access10.status ?? 401,
@@ -28194,7 +28240,9 @@ function createMailboxHttpRouter(options) {
           method,
           url,
           maxBodyBytes,
-          closeSseStreams
+          defaultMaxAgeMs,
+          closeSseStreams,
+          routePath
         );
       } catch (error2) {
         const code = error2 instanceof MailboxHttpValidationError ? "VALIDATION_ERROR" : "INTERNAL_ERROR";
@@ -28213,85 +28261,134 @@ function createMailboxHttpRouter(options) {
     }
   };
 }
-async function dispatchMailboxRoute(mailbox, eventEmitter, request, response, method, url, maxBodyBytes, closeSseStreams) {
-  if (method === "POST" && url === "/mailbox/send") {
+async function dispatchMailboxRoute(mailbox, eventEmitter, request, response, method, url, maxBodyBytes, defaultMaxAgeMs, closeSseStreams, routePath) {
+  if (routePath !== void 0 && routePath.indexOf("?") === 0) {
+    throw validationError(`routePath must not start with '?' (got ${JSON.stringify(routePath)})`);
+  }
+  const queryIndex = url.indexOf("?");
+  const path76 = queryIndex === -1 ? url : url.slice(0, queryIndex);
+  if (method === "POST" && path76 === "/mailbox/send") {
     const input = validateSend(await readJsonBody(request, maxBodyBytes));
     writeJson(response, 201, await mailbox.send(input));
     return;
   }
-  if (method === "POST" && url === "/mailbox/query") {
+  if (method === "POST" && path76 === "/mailbox/query") {
+    const queryContext = parseSinceMs(url, defaultMaxAgeMs);
+    if ("error" in queryContext) {
+      writeJson(response, 400, { error: queryContext.error });
+      return;
+    }
     const messages = await mailbox.query(validateQuery(await readJsonBody(request, maxBodyBytes)));
-    writeJson(response, 200, { data: messages, count: messages.length });
+    const filtered = filterMailboxMessagesByTimestamp(messages, queryContext.minTimestampIso);
+    writeJson(response, 200, { data: filtered, count: filtered.length });
     return;
   }
-  if (method === "POST" && url === "/mailbox/check") {
+  if (method === "POST" && path76 === "/mailbox/check") {
+    const queryContext = parseSinceMs(url, defaultMaxAgeMs);
+    if ("error" in queryContext) {
+      writeJson(response, 400, { error: queryContext.error });
+      return;
+    }
     const result = await checkMailbox(
       mailbox,
-      validateCheck(await readJsonBody(request, maxBodyBytes))
+      validateCheck(await readJsonBody(request, maxBodyBytes)),
+      queryContext.minTimestampIso
     );
     writeJson(response, 200, result);
     return;
   }
-  if (method === "POST" && url === "/mailbox/ack") {
+  if (method === "POST" && path76 === "/mailbox/ack") {
     const updated = await mailbox.ack(validateAck(await readJsonBody(request, maxBodyBytes)));
     writeJson(response, 200, { updated });
     return;
   }
-  if (method === "POST" && url === "/mailbox/ack-many") {
+  if (method === "POST" && path76 === "/mailbox/ack-many") {
     const updated = await mailbox.ackMany(
       validateAckMany(await readJsonBody(request, maxBodyBytes))
     );
     writeJson(response, 200, { updated, count: updated.length });
     return;
   }
-  if (method === "POST" && url === "/mailbox/unread-count") {
+  if (method === "POST" && path76 === "/mailbox/unread-count") {
     const body = await readJsonBody(request, maxBodyBytes);
-    writeJson(response, 200, { count: await mailbox.unreadCount(requireString(body, "forAgentId")) });
+    writeJson(response, 200, {
+      count: await mailbox.unreadCount(requireString(body, "forAgentId"))
+    });
     return;
   }
-  if (method === "POST" && url === "/mailbox/agents/register") {
-    await mailbox.registerAgent(validateAgentRegistration(await readJsonBody(request, maxBodyBytes)));
+  if (method === "POST" && path76 === "/mailbox/agents/register") {
+    await mailbox.registerAgent(
+      validateAgentRegistration(await readJsonBody(request, maxBodyBytes))
+    );
     writeJson(response, 200, { ok: true });
     return;
   }
-  if (method === "POST" && url === "/mailbox/agents/heartbeat") {
+  if (method === "POST" && path76 === "/mailbox/agents/heartbeat") {
     await mailbox.heartbeat(validateAgentHeartbeat(await readJsonBody(request, maxBodyBytes)));
     writeJson(response, 200, { ok: true });
     return;
   }
-  if (method === "POST" && url === "/mailbox/register-client") {
-    await mailbox.registerClient(validateClientRegistration(await readJsonBody(request, maxBodyBytes)));
+  if (method === "POST" && path76 === "/mailbox/register-client") {
+    await mailbox.registerClient(
+      validateClientRegistration(await readJsonBody(request, maxBodyBytes))
+    );
     writeJson(response, 200, { ok: true });
     return;
   }
-  if (method === "POST" && url === "/mailbox/heartbeat") {
-    await mailbox.clientHeartbeat(validateClientHeartbeat(await readJsonBody(request, maxBodyBytes)));
+  if (method === "POST" && path76 === "/mailbox/heartbeat") {
+    await mailbox.clientHeartbeat(
+      validateClientHeartbeat(await readJsonBody(request, maxBodyBytes))
+    );
     writeJson(response, 200, { ok: true });
     return;
   }
-  if (method === "POST" && url === "/mailbox/purge-clients") {
+  if (method === "POST" && path76 === "/mailbox/purge-clients") {
     writeJson(response, 200, { ok: true, purged: await mailbox.purgeClients() });
     return;
   }
-  if (method === "GET" && url === "/mailbox/agents") {
+  if (method === "GET" && path76 === "/mailbox/agents") {
     const agents = await mailbox.getAgentStatuses();
     writeJson(response, 200, { data: agents, count: agents.length });
     return;
   }
-  if (method === "GET" && url === "/mailbox/agents/online") {
+  if (method === "GET" && path76 === "/mailbox/agents/online") {
     const agents = await mailbox.getOnlineAgents();
     writeJson(response, 200, { data: agents, count: agents.length });
     return;
   }
-  if (method === "GET" && url === "/mailbox/events" && eventEmitter) {
-    handleSse(request, response, eventEmitter, closeSseStreams);
+  if (method === "GET" && path76 === "/mailbox/events" && eventEmitter) {
+    const queryContext = parseSinceMs(url, defaultMaxAgeMs);
+    if ("error" in queryContext) {
+      writeJson(response, 400, { error: queryContext.error });
+      return;
+    }
+    handleSse(request, response, eventEmitter, queryContext.minTimestampIso, closeSseStreams);
     return;
   }
   writeJson(response, 404, {
     error: { code: "NOT_FOUND", message: `no route for ${method} ${url}` }
   });
 }
-function handleSse(request, response, eventEmitter, closeSseStreams) {
+function extractEventTimestamp(event) {
+  if (event === null || typeof event !== "object") return void 0;
+  const top = event.timestamp;
+  if (typeof top === "string") return top;
+  const nestedKeys = ["messageSent", "ackUpdated"];
+  for (const key of nestedKeys) {
+    const nested = event[key];
+    if (nested !== null && typeof nested === "object") {
+      const inner = nested.timestamp;
+      if (typeof inner === "string") return inner;
+    }
+  }
+  return void 0;
+}
+function isEventOlderThan(event, minTimestampIso) {
+  const eventTimestamp = extractEventTimestamp(event);
+  if (eventTimestamp === void 0) return false;
+  return eventTimestamp < minTimestampIso;
+}
+function handleSse(request, response, eventEmitter, minTimestampIso, closeSseStreams) {
   response.writeHead(200, {
     "Content-Type": "text/event-stream",
     "Cache-Control": "no-store",
@@ -28301,6 +28398,9 @@ function handleSse(request, response, eventEmitter, closeSseStreams) {
   response.write(": connected\n\n");
   const unsubscribe2 = eventEmitter.subscribe((event) => {
     try {
+      if (minTimestampIso !== void 0 && isEventOlderThan(event, minTimestampIso)) {
+        return;
+      }
       response.write(`data: ${JSON.stringify(event)}
 
 `);
@@ -28410,6 +28510,52 @@ function optionalNumber(object, key) {
   }
   return value;
 }
+function parseSinceMs(url, defaultMaxAgeMs) {
+  const queryStart = url.indexOf("?");
+  if (queryStart === -1) return resolveDefault(defaultMaxAgeMs, Date.now());
+  const params = new URLSearchParams(url.slice(queryStart + 1));
+  if (!params.has("sinceMs")) return resolveDefault(defaultMaxAgeMs, Date.now());
+  const raw = params.get("sinceMs");
+  if (raw === null || raw === void 0 || raw === "") {
+    return {
+      error: {
+        code: "VALIDATION_ERROR",
+        message: 'query parameter "sinceMs" is required (integer in milliseconds) when present'
+      }
+    };
+  }
+  if (!/^\d+$/.test(raw)) {
+    return {
+      error: {
+        code: "VALIDATION_ERROR",
+        message: 'query parameter "sinceMs" must be a non-negative integer (milliseconds)'
+      }
+    };
+  }
+  const requestedMs = Number(raw);
+  if (!Number.isFinite(requestedMs) || requestedMs > Number.MAX_SAFE_INTEGER) {
+    return {
+      error: {
+        code: "VALIDATION_ERROR",
+        message: `query parameter "sinceMs" is out of range (max ${Number.MAX_SAFE_INTEGER})`
+      }
+    };
+  }
+  const now = Date.now();
+  if (requestedMs === 0) return { minTimestampIso: void 0 };
+  const effectiveMs = Math.min(requestedMs, MAILBOX_HTTP_MAX_AGE_CEILING_MS);
+  return { minTimestampIso: new Date(now - effectiveMs).toISOString() };
+}
+function resolveDefault(defaultMaxAgeMs, now) {
+  if (defaultMaxAgeMs === void 0 || !Number.isFinite(defaultMaxAgeMs) || defaultMaxAgeMs < 0 || defaultMaxAgeMs === 0) {
+    return { minTimestampIso: void 0 };
+  }
+  return { minTimestampIso: new Date(now - defaultMaxAgeMs).toISOString() };
+}
+function filterMailboxMessagesByTimestamp(messages, minTimestampIso) {
+  if (minTimestampIso === void 0) return messages.slice();
+  return messages.filter((message) => message.timestamp >= minTimestampIso);
+}
 function optionalBoolean(object, key) {
   if (typeof object !== "object" || object === null) return void 0;
   const value = object[key];
@@ -28530,7 +28676,7 @@ function validateQuery(body) {
   if (incompleteOnly !== void 0) result.incompleteOnly = incompleteOnly;
   return result;
 }
-async function checkMailbox(mailbox, input) {
+async function checkMailbox(mailbox, input, minTimestampIso) {
   const limit = input.limit ?? 20;
   const markRead = input.markRead ?? true;
   const completed = input.completed ?? false;
@@ -28538,8 +28684,9 @@ async function checkMailbox(mailbox, input) {
   const batches = await Promise.all(
     targets.map((to) => mailbox.query({ to, unreadBy: input.agentId, limit }))
   );
+  const withinWindow = filterMailboxMessagesByTimestamp(batches.flat(), minTimestampIso);
   const seen = /* @__PURE__ */ new Set();
-  const messages = batches.flat().filter((message) => {
+  const messages = withinWindow.filter((message) => {
     if (seen.has(message.id) || message.from === input.agentId) return false;
     seen.add(message.id);
     return true;
@@ -28913,11 +29060,11 @@ var DefaultMailbox = class {
   async query(q) {
     const queryType = q.type === void 0 ? void 0 : normalizeMailboxMessageType(q.type);
     const needFullScan = q.unreadBy !== void 0 || q.since !== void 0;
-    const cached = await this._readAllCached(false);
+    const cached2 = await this._readAllCached(false);
     let candidates;
-    let candidatesComplete = !this._messageCacheTruncated || cached !== this._messageCache;
+    let candidatesComplete = !this._messageCacheTruncated || cached2 !== this._messageCache;
     if (needFullScan) {
-      candidates = cached;
+      candidates = cached2;
     } else {
       if (q.to !== void 0) {
         const direct = this._byTo.get(q.to);
@@ -28931,7 +29078,7 @@ var DefaultMailbox = class {
         candidates = Array.from(this._byFrom.get(q.from) ?? []);
         candidatesComplete = !this._messageCacheTruncated;
       } else {
-        candidates = cached;
+        candidates = cached2;
       }
     }
     const limit = q.limit ?? 50;
@@ -30102,19 +30249,24 @@ var ProviderModelStatusTracker = class {
     let newState = s.state;
     let reason = "";
     const quotaExhausted = kind === "quota_exhausted" || isQuotaExhausted(kind, status, message);
+    const endpointUnreachable = isEndpointUnreachable(kind, status, message);
     if (quotaExhausted) {
       newState = "blocked";
       reason = "quota_exhausted";
       s.stateExpiresAt = now + this.cfg.quotaBlockDurationMs;
+    } else if (endpointUnreachable) {
+      newState = "blocked";
+      reason = "endpoint_unreachable";
+      s.stateExpiresAt = now + this.cfg.quotaBlockDurationMs;
     }
-    if (!quotaExhausted && s.state === "healthy") {
+    if (!quotaExhausted && !endpointUnreachable && s.state === "healthy") {
       if (s.consecutiveFailures >= this.cfg.degradedAfterFailures) {
         newState = "degraded";
         reason = `consecutive_failures_${s.consecutiveFailures}`;
         s.stateExpiresAt = now + this.cfg.degradedDurationMs;
       }
     }
-    if (!quotaExhausted && (s.state === "degraded" || s.state === "healthy")) {
+    if (!quotaExhausted && !endpointUnreachable && (s.state === "degraded" || s.state === "healthy")) {
       if (s.rateLimitHits >= this.cfg.blockAfterRateLimitHits) {
         newState = "blocked";
         reason = `rate_limit_threshold_${this.cfg.blockAfterRateLimitHits}`;
@@ -30444,13 +30596,20 @@ function unpairKey(key) {
   if (idx === -1) return [key, ""];
   return [key.slice(0, idx), key.slice(idx + 1)];
 }
-var QUOTA_EXHAUSTED_RE2 = /(?:insufficient|exhausted|depleted|exceeded|no|not enough)[-_\s]*(?:quota|credit|balance)|(?:quota|credit|balance)[-_\s]*(?:exhausted|depleted|exceeded|insufficient)|billing[_\s-]*(?:hard[_\s-]*)?limit|payment required|spending limit|plan limit/i;
+var QUOTA_EXHAUSTED_RE2 = /(?:insufficient|exhausted|depleted|exceeded|no|not enough)[-_\s]*(?:quota|credit|balance)|(?:quota|credit|balance)[-_\s]*(?:exhausted|depleted|exceeded|insufficient)|billing[_\s-]*(?:hard[_\s-]*)?limit|payment required|spending limit|plan limit|usage[-_\s]*limit[-_\s]*(?:reached|exceeded)|rate[-_\s]*limit[-_\s]*exceeded/i;
 function isQuotaExhausted(kind, status, message) {
   if (status === 402) return true;
   if (kind !== "rate_limit" && kind !== "quota_exhausted" && kind !== "invalid_request" && kind !== "auth")
     return false;
   return QUOTA_EXHAUSTED_RE2.test(message);
 }
+var ENDPOINT_UNREACHABLE_RE = /(?:upstream|origin|backend|endpoint)[-_\s]*(?:unreachable|refused|connect(?:ion)?[-_\s]*(?:refused|error|fail)|unavailable|down|timeout)|no[-_\s]*(?:healthy|valid)[-_\s]*upstream|cannot[-_\s]*connect|connection[-_\s]*(?:refused|reset|closed|timed?[-_\s]out)/i;
+function isEndpointUnreachable(kind, status, message) {
+  if (status !== 502 && status !== 503 && status !== 0) return false;
+  if (kind !== "server" && kind !== "network" && kind !== "overloaded" && kind !== "timeout")
+    return false;
+  return ENDPOINT_UNREACHABLE_RE.test(message);
+}
 function safeCount(value) {
   return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.floor(value) : 0;
 }
@@ -39578,8 +39737,8 @@ function eliseOldToolResults(messages, opts) {
   const preserveStart = findPreserveStart(messages, opts.preserveK);
   const tokenCache = /* @__PURE__ */ new Map();
   const tokensFor = (b) => {
-    const cached = tokenCache.get(b);
-    if (cached !== void 0) return cached;
+    const cached2 = tokenCache.get(b);
+    if (cached2 !== void 0) return cached2;
     const t2 = b.type === "tool_result" ? estimateToolResultTokens(b.content) : b.type === "tool_use" ? estimateToolInputTokens(b.input) : 0;
     tokenCache.set(b, t2);
     return t2;
@@ -41436,8 +41595,8 @@ var DefaultDesignKitLoader = class {
   }
   async readBody(id, stack) {
     const key = `${id.toLowerCase()}:${stack ?? "*"}`;
-    const cached = this.bodyCache.get(key);
-    if (cached !== void 0) return cached;
+    const cached2 = this.bodyCache.get(key);
+    if (cached2 !== void 0) return cached2;
     const m = await this.find(id);
     if (!m) throw new Error(`Design kit "${id}" not found`);
     const raw = await fs20.readFile(m.path, "utf8");
@@ -45305,8 +45464,8 @@ var DefaultSkillLoader = class {
   }
   async readBody(name) {
     const key = name.toLowerCase();
-    const cached = this.bodyCache.get(key);
-    if (cached !== void 0) return cached;
+    const cached2 = this.bodyCache.get(key);
+    if (cached2 !== void 0) return cached2;
     const m = await this.find(name);
     if (!m) throw new Error(`Skill "${name}" not found`);
     const body = await fs22.readFile(m.path, "utf8");
@@ -45315,8 +45474,8 @@ var DefaultSkillLoader = class {
   }
   async readSaveBody(name) {
     const key = `save:${name.toLowerCase()}`;
-    const cached = this.bodyCache.get(key);
-    if (cached !== void 0) return cached;
+    const cached2 = this.bodyCache.get(key);
+    if (cached2 !== void 0) return cached2;
     const m = await this.find(name);
     if (!m) throw new Error(`Skill "${name}" not found`);
     const savePath = path42.join(path42.dirname(m.path), "SKILL.save.md");
@@ -46059,19 +46218,19 @@ async function canonicalizeCandidatePath(candidate, ctx) {
   if (path45.isAbsolute(candidate)) return candidate;
   const absolute = path45.resolve(ctx.projectRoot, candidate);
   const canonicalRoot = await realpath3(ctx.projectRoot).catch(() => ctx.projectRoot);
-  let probe = absolute;
+  let probe2 = absolute;
   const missingSegments = [];
   while (true) {
     try {
-      const canonical = path45.join(await realpath3(probe), ...missingSegments);
+      const canonical = path45.join(await realpath3(probe2), ...missingSegments);
       return relativeToProject(canonical, canonicalRoot);
     } catch (cause) {
       const code = cause.code;
       if (code !== "ENOENT" && code !== "ENOTDIR") return absolute;
-      const parent = path45.dirname(probe);
-      if (parent === probe) return absolute;
-      missingSegments.unshift(path45.basename(probe));
-      probe = parent;
+      const parent = path45.dirname(probe2);
+      if (parent === probe2) return absolute;
+      missingSegments.unshift(path45.basename(probe2));
+      probe2 = parent;
     }
   }
 }
@@ -47993,23 +48152,23 @@ var DefaultModelsRegistry = class {
    */
   async loadBase(opts = {}, overlayAvailable = false) {
     if (!opts.force) {
-      const cached = await this.readCacheAt(this.cacheFile);
-      if (cached && this.isFresh(cached.fetchedAt)) {
-        this.fetchedAt = new Date(cached.fetchedAt);
-        return cached.payload;
+      const cached2 = await this.readCacheAt(this.cacheFile);
+      if (cached2 && this.isFresh(cached2.fetchedAt)) {
+        this.fetchedAt = new Date(cached2.fetchedAt);
+        return cached2.payload;
       }
     }
     try {
       return await this.refreshBase();
     } catch (err) {
-      const cached = await this.readCacheAt(this.cacheFile);
-      if (cached && this.isWithinMaxStaleAge(cached.fetchedAt)) {
-        this.fetchedAt = new Date(cached.fetchedAt);
+      const cached2 = await this.readCacheAt(this.cacheFile);
+      if (cached2 && this.isWithinMaxStaleAge(cached2.fetchedAt)) {
+        this.fetchedAt = new Date(cached2.fetchedAt);
         const ageSeconds = Math.floor((Date.now() - this.fetchedAt.getTime()) / 1e3);
         console.warn(
           `ModelsRegistry: models.dev unavailable (${toErrorMessage(err)}); using stale cache from ${formatAge(ageSeconds)} ago. Run \`wstack models refresh\` to retry.`
         );
-        return cached.payload;
+        return cached2.payload;
       }
       if (overlayAvailable) {
         console.warn(
@@ -48084,8 +48243,8 @@ var DefaultModelsRegistry = class {
   async loadOverlayFromUrl(opts) {
     if (!this.overlayUrl || !this.overlayCacheFile) return void 0;
     if (!opts.force) {
-      const cached = await this.readCacheAt(this.overlayCacheFile);
-      if (cached && this.isFresh(cached.fetchedAt)) return cached.payload;
+      const cached2 = await this.readCacheAt(this.overlayCacheFile);
+      if (cached2 && this.isFresh(cached2.fetchedAt)) return cached2.payload;
     }
     try {
       const res = await this.fetchImpl(this.overlayUrl, {
@@ -48108,13 +48267,13 @@ var DefaultModelsRegistry = class {
       });
       return json;
     } catch {
-      const cached = await this.readCacheAt(this.overlayCacheFile);
-      if (cached && this.isWithinMaxStaleAge(cached.fetchedAt)) {
-        const ageSeconds = Math.floor((Date.now() - new Date(cached.fetchedAt).getTime()) / 1e3);
+      const cached2 = await this.readCacheAt(this.overlayCacheFile);
+      if (cached2 && this.isWithinMaxStaleAge(cached2.fetchedAt)) {
+        const ageSeconds = Math.floor((Date.now() - new Date(cached2.fetchedAt).getTime()) / 1e3);
         console.warn(
           `ModelsRegistry: overlay unavailable; using stale overlay from ${formatAge(ageSeconds)} ago.`
         );
-        return cached.payload;
+        return cached2.payload;
       }
       return void 0;
     }
@@ -48175,9 +48334,9 @@ var DefaultModelsRegistry = class {
   }
   async ageSeconds() {
     if (!this.fetchedAt) {
-      const cached = await this.readCacheAt(this.cacheFile);
-      if (!cached) return Number.POSITIVE_INFINITY;
-      return (Date.now() - new Date(cached.fetchedAt).getTime()) / 1e3;
+      const cached2 = await this.readCacheAt(this.cacheFile);
+      if (!cached2) return Number.POSITIVE_INFINITY;
+      return (Date.now() - new Date(cached2.fetchedAt).getTime()) / 1e3;
     }
     return (Date.now() - this.fetchedAt.getTime()) / 1e3;
   }
@@ -48716,7 +48875,7 @@ async function startMetricsServer(opts) {
 
 // src/observability/otlp-metrics.ts
 var DEFAULT_INTERVAL_MS = 3e4;
-var DEFAULT_TIMEOUT_MS = 1e4;
+var DEFAULT_TIMEOUT_MS2 = 1e4;
 function joinEndpoint(base) {
   if (/\/v1\/metrics\/?$/.test(base)) return base;
   return base.replace(/\/$/, "") + "/v1/metrics";
@@ -48779,7 +48938,7 @@ function buildOtlpMetricsRequest(sink, opts = {}) {
 function startOtlpMetricsExporter(opts) {
   const url = joinEndpoint(opts.endpoint);
   const intervalMs = opts.intervalMs ?? DEFAULT_INTERVAL_MS;
-  const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS2;
   const fetchImpl = opts.fetchImpl ?? globalThis.fetch;
   const onError = opts.onError ?? (() => {
   });
@@ -48869,7 +49028,7 @@ var CapturingSpan = class {
 };
 var DEFAULT_INTERVAL_MS2 = 5e3;
 var DEFAULT_BUFFER_CAP = 2048;
-var DEFAULT_TIMEOUT_MS2 = 1e4;
+var DEFAULT_TIMEOUT_MS3 = 1e4;
 function joinEndpoint2(base) {
   if (/\/v1\/traces\/?$/.test(base)) return base;
   return base.replace(/\/$/, "") + "/v1/traces";
@@ -48910,7 +49069,7 @@ function startOtlpTraceExporter(opts) {
   const url = joinEndpoint2(opts.endpoint);
   const intervalMs = opts.intervalMs ?? DEFAULT_INTERVAL_MS2;
   const maxBuffered = opts.maxBufferedSpans ?? DEFAULT_BUFFER_CAP;
-  const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS2;
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS3;
   const fetchImpl = opts.fetchImpl ?? globalThis.fetch;
   const onError = opts.onError ?? (() => {
   });
@@ -49441,8 +49600,8 @@ var DefaultPermissionPolicy = class {
     const subject = subjectForToolInput(tool.name, input, tool.subjectKey);
     const cacheKey = `${tool.name}::${subject ?? tool.name}`;
     if (tool.name !== "write") {
-      const cached = this._evalCache.get(cacheKey);
-      if (cached !== void 0) return cached;
+      const cached2 = this._evalCache.get(cacheKey);
+      if (cached2 !== void 0) return cached2;
     }
     if (this.sessionDenied.has(cacheKey)) {
       this._logDeny(tool.name, subject, "session soft deny (user pressed no)");
@@ -53519,7 +53678,7 @@ function applyModelRuntime(req, opts) {
 }
 
 // src/execution/one-shot-llm.ts
-var DEFAULT_TIMEOUT_MS3 = 3e4;
+var DEFAULT_TIMEOUT_MS4 = 3e4;
 var DEFAULT_MAX_TOKENS = 1024;
 var OneShotOrchestrator = class {
   opts;
@@ -53599,6 +53758,9 @@ var OneShotOrchestrator = class {
     for (const entry of usableChain) {
       if (!evaluateModelCalendar(config.modelAvailabilitySchedule, entry.providerId, entry.model).allowed)
         continue;
+      if (tracker && !tracker.isAvailable(entry.providerId, entry.model)) {
+        continue;
+      }
       if (entry.providerId === provider.id && entry.model === target.model) continue;
       let fbProvider;
       try {
@@ -53682,7 +53844,7 @@ var OneShotOrchestrator = class {
    * timeout, composed with external cancellation when the caller supplies it.
    */
   resolveSignal(input) {
-    const timeoutSignal = AbortSignal.timeout(input.timeoutMs ?? DEFAULT_TIMEOUT_MS3);
+    const timeoutSignal = AbortSignal.timeout(input.timeoutMs ?? DEFAULT_TIMEOUT_MS4);
     return input.signal ? AbortSignal.any([input.signal, timeoutSignal]) : timeoutSignal;
   }
   /**
@@ -55294,8 +55456,8 @@ var PhaseOrchestrator = class {
     });
   }
   getTrackerForPhase(phase) {
-    const cached = this.trackerCache.get(phase.id);
-    if (cached) return cached;
+    const cached2 = this.trackerCache.get(phase.id);
+    if (cached2) return cached2;
     const tracker = new TaskTracker({ store: new DefaultTaskStore() });
     tracker.setGraph(phase.taskGraph);
     this.trackerCache.set(phase.id, tracker);
@@ -56315,7 +56477,7 @@ var CheckpointManager = class {
 
 // src/hooks/shell-executor.ts
 import { spawn as spawn4 } from "node:child_process";
-var DEFAULT_TIMEOUT_MS4 = 5e3;
+var DEFAULT_TIMEOUT_MS5 = 5e3;
 var MAX_OUTPUT_BYTES = 64 * 1024;
 var ALLOWED_SHELL_COMMANDS = /* @__PURE__ */ new Set([
   // POSIX shells + Windows shells
@@ -56441,7 +56603,7 @@ async function runShellHook(spec, input, logger) {
   return result.outcome;
 }
 async function runShellHookDetailed(spec, input, logger, options = {}) {
-  const timeoutMs = Math.max(1, Math.min(spec.timeoutMs ?? DEFAULT_TIMEOUT_MS4, 10 * 6e4));
+  const timeoutMs = Math.max(1, Math.min(spec.timeoutMs ?? DEFAULT_TIMEOUT_MS5, 10 * 6e4));
   const argv = isCommandAllowed(spec.command);
   if (!argv) {
     logger?.warn?.(`hook rejected: command not in allowlist: ${spec.command}`);
@@ -56594,7 +56756,7 @@ function parseHookOutcome(stdout) {
 }
 
 // src/hooks/http-executor.ts
-var DEFAULT_TIMEOUT_MS5 = 5e3;
+var DEFAULT_TIMEOUT_MS6 = 5e3;
 var MAX_OUTPUT_BYTES2 = 64 * 1024;
 function isAllowedUrl(raw) {
   try {
@@ -56616,7 +56778,7 @@ async function runHttpHookDetailed(spec, input, logger, options = {}) {
       }
     };
   }
-  const timeoutMs = Math.max(1, Math.min(spec.timeoutMs ?? DEFAULT_TIMEOUT_MS5, 10 * 6e4));
+  const timeoutMs = Math.max(1, Math.min(spec.timeoutMs ?? DEFAULT_TIMEOUT_MS6, 10 * 6e4));
   const timeoutController = new AbortController();
   const timer = setTimeout(() => timeoutController.abort(new Error("hook timeout")), timeoutMs);
   timer.unref?.();
@@ -56821,7 +56983,7 @@ function hookMatcherMatches(matcher, toolName) {
 }
 
 // src/hooks/runner.ts
-var DEFAULT_TIMEOUT_MS6 = 5e3;
+var DEFAULT_TIMEOUT_MS7 = 5e3;
 var MAX_TIMEOUT_MS = 10 * 6e4;
 function normalizePreToolOutcome(outcome) {
   if ("action" in outcome) return outcome;
@@ -57007,7 +57169,7 @@ var HookRunner = class {
     return this.failureOutcome(entry, payload, result.failure);
   }
   async invokeInProcess(entry, payload, env) {
-    const timeoutMs = Math.max(1, Math.min(entry.timeoutMs ?? DEFAULT_TIMEOUT_MS6, MAX_TIMEOUT_MS));
+    const timeoutMs = Math.max(1, Math.min(entry.timeoutMs ?? DEFAULT_TIMEOUT_MS7, MAX_TIMEOUT_MS));
     const controller = new AbortController();
     let timedOut = false;
     const onParentAbort = () => controller.abort(env.signal?.reason);
@@ -59720,8 +59882,8 @@ function makePluginLLM(owner, hostLLM, providerRegistry, config, getLiveConfig,
       return { provider: liveProvider, providerName };
     }
     const cacheKey = `${providerName}|${model}`;
-    const cached = providerCache.get(cacheKey);
-    if (cached) return { provider: cached, providerName };
+    const cached2 = providerCache.get(cacheKey);
+    if (cached2) return { provider: cached2, providerName };
     let created;
     if (hostLLM.createProvider) {
       created = hostLLM.createProvider(providerName, model);
@@ -64102,9 +64264,9 @@ var ReplayProviderRunner = class {
   opts;
   async run(runOpts) {
     const hash4 = hashRequest(runOpts.request);
-    const cached = await this.opts.log.lookup(this.opts.sessionId, hash4);
+    const cached2 = await this.opts.log.lookup(this.opts.sessionId, hash4);
     if (this.opts.mode === "replay") {
-      if (!cached) {
+      if (!cached2) {
         this.opts.logger?.warn?.(
           `replay: no recorded response for hash ${hash4} (model ${runOpts.request.model})`
         );
@@ -64113,15 +64275,15 @@ var ReplayProviderRunner = class {
         );
       }
       this.opts.logger?.debug?.(
-        `replay: served cached response for hash ${hash4} (recorded ${cached.ts})`
+        `replay: served cached response for hash ${hash4} (recorded ${cached2.ts})`
       );
-      return cached.response;
+      return cached2.response;
     }
-    if (this.opts.mode === "auto" && cached) {
+    if (this.opts.mode === "auto" && cached2) {
       this.opts.logger?.debug?.(
         `replay: auto-hit hash ${hash4}, served cached response`
       );
-      return cached.response;
+      return cached2.response;
     }
     const response = await this.inner.run(runOpts);
     await this.opts.log.record({
@@ -64341,9 +64503,9 @@ var FileMemoryBackend = class {
   }
   async getIndex(file, scope) {
     const mtime = await this.getMtime(file);
-    const cached = this.indexCache.get(file);
-    if (cached && cached.mtimeMs === mtime) {
-      return cached;
+    const cached2 = this.indexCache.get(file);
+    if (cached2 && cached2.mtimeMs === mtime) {
+      return cached2;
     }
     const entries = await this.loadEntries(file, scope, mtime);
     const index = buildInvertedIndex(entries);
@@ -70189,6 +70351,8 @@ export {
   MAILBOX_HEALTH_DEFAULT_FROM,
   MAILBOX_HEALTH_DEFAULT_INTERVAL_MS,
   MAILBOX_HEALTH_DEFAULT_TIMEOUT_MS,
+  MAILBOX_HTTP_DEFAULT_MAX_AGE_MS,
+  MAILBOX_HTTP_MAX_AGE_CEILING_MS,
   MAILBOX_HTTP_MAX_BODY_BYTES,
   MAILBOX_HTTP_RATE_LIMIT_PER_MINUTE,
   MAILBOX_HTTP_RATE_LIMIT_WINDOW_MS,
@@ -70352,6 +70516,7 @@ export {
   buildTranscriptFromEvents,
   buildUserContentBlocks,
   canonicalProjectRoot,
+  checkConnectivity,
   childChronicleContext,
   classifyFamily,
   classifyMailboxRecipient,
@@ -70728,6 +70893,7 @@ export {
   repairToolUseAdjacency,
   repeatedReadPressure,
   resetCalibration,
+  resetConnectivityCache,
   resolveAuditLevel,
   resolveBrainConfigDefaults,
   resolveBundledDesignKitsDir,