@wrongstack/core 0.292.0 → 0.293.0

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)}`;
@@ -2349,8 +2380,8 @@ function resolveTokenSavingTier(val, maxContext) {
       return "off";
     }
     if (maxContext < 32e3) return "medium";
-    if (maxContext < 96e3) return "light";
-    return "off";
+    if (maxContext < 128e3) return "light";
+    return "minimal";
   }
   return normalizeTokenSavingTier(val);
 }
@@ -2360,7 +2391,6 @@ function resolveFleetChatVerbosity(autonomy) {
   if (explicit && FLEET_CHAT_VERBOSITY_VALUES.includes(explicit)) {
     return explicit;
   }
-  if (autonomy?.streamFleet === false) return "off";
   return "off";
 }
 var DEFAULT_TUI_THINKING_WORD = "thinking";
@@ -2710,11 +2740,20 @@ var DefaultSystemPromptBuilder = class {
     const layer5 = await this.buildMode();
     const layer6 = ctx.subagent ? "" : await this.buildActivePlan();
     const core = [
-      tagBlock({ type: "text", text: layer1 }, "identity"),
-      tagBlock({ type: "text", text: layer2 }, "tool-usage")
+      tagBlock(
+        { type: "text", text: layer1, cache_control: { type: "ephemeral" } },
+        "identity"
+      ),
+      tagBlock(
+        { type: "text", text: layer2, cache_control: { type: "ephemeral" } },
+        "tool-usage"
+      )
     ];
     const session = [
-      tagBlock({ type: "text", text: layer3WithDir }, "environment")
+      tagBlock(
+        { type: "text", text: layer3WithDir, cache_control: { type: "ephemeral" } },
+        "environment"
+      )
     ];
     const volatile = [];
     if (layer4.trim()) {
@@ -3099,8 +3138,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 +3499,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 +3688,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 +3700,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 +4330,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++) {
@@ -4817,15 +4856,30 @@ function mergeCustomModelDefs(providerCustomModels, configModels) {
 }
 
 // src/utils/merge-models-payload.ts
+var REMOVE_PROVIDERS_KEY = "_removeProviders";
+var REMOVE_MODELS_KEY = "_removeModels";
 function mergeModelsPayload(base, overlay) {
+  const removeProviders = Array.isArray(overlay[REMOVE_PROVIDERS_KEY]) ? overlay[REMOVE_PROVIDERS_KEY] : [];
+  const removeModels = overlay[REMOVE_MODELS_KEY] && typeof overlay[REMOVE_MODELS_KEY] === "object" ? overlay[REMOVE_MODELS_KEY] : {};
   const out = {};
   for (const [id, provider] of Object.entries(base)) {
     out[id] = cloneProvider(provider);
   }
   for (const [id, ovProvider] of Object.entries(overlay)) {
+    if (id === REMOVE_PROVIDERS_KEY || id === REMOVE_MODELS_KEY) continue;
     const existing = out[id];
     out[id] = existing ? mergeProvider(existing, ovProvider) : cloneProvider(ovProvider);
   }
+  for (const providerId of removeProviders) {
+    delete out[providerId];
+  }
+  for (const [providerId, modelIds] of Object.entries(removeModels)) {
+    const provider = out[providerId];
+    if (!provider || !provider.models) continue;
+    for (const modelId of modelIds) {
+      delete provider.models[modelId];
+    }
+  }
   return out;
 }
 function mergeProvider(base, overlay) {
@@ -7181,9 +7235,10 @@ var BEHAVIOR_DEFAULTS = {
     prompts: true,
     // 'auto' → resolveTokenSavingTier picks a concrete tier from the model's
     // context window ONCE per session (cache-safe): lean prompt on small
-    // windows (<32k medium, <96k light) where the fixed identity+tool prose is
-    // a big fraction; full prompt (off) on 96k+ so nothing changes for the
-    // common large-window case. Explicit tiers are respected verbatim.
+    // windows (<32k medium, <128k light) where the fixed identity+tool prose
+    // is a big fraction; minimal trimming on >=128k so modern large-window
+    // models still get cost savings without capability loss. Explicit tiers
+    // are respected verbatim.
     tokenSavingMode: "auto",
     allowOutsideProjectRoot: true
   },
@@ -7251,7 +7306,7 @@ var BEHAVIOR_DEFAULTS = {
     // Mirrored from the top-level yolo default so the autonomy subsystem
     // (which reads autonomy.yolo) stays consistent with config.yolo.
     yolo: false,
-    streamFleet: true,
+    fleetChatVerbosity: "off",
     chime: false,
     confirmExit: true,
     mouseMode: false,
@@ -7269,7 +7324,7 @@ var BEHAVIOR_DEFAULTS = {
     // silently omitted, and surfaced as a per-request warning. Users who
     // want a specific effort can opt in via `/settings` or the WebUI panel.
     reasoning: { mode: "auto" },
-    cache: {}
+    cache: { ttl: "1h" }
   }
 };
 function isPlainRecord(value) {
@@ -7978,9 +8033,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 +11814,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 +11831,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 +15894,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 +17870,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 +17879,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 +18604,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 +19415,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 +21383,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 +22880,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 +23487,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 +24024,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 +28167,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 +28212,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 +28227,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 +28264,9 @@ function createMailboxHttpRouter(options) {
           method,
           url,
           maxBodyBytes,
-          closeSseStreams
+          defaultMaxAgeMs,
+          closeSseStreams,
+          routePath
         );
       } catch (error2) {
         const code = error2 instanceof MailboxHttpValidationError ? "VALIDATION_ERROR" : "INTERNAL_ERROR";
@@ -28213,85 +28285,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 +28422,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 +28534,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 +28700,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 +28708,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 +29084,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 +29102,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 +30273,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 +30620,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;
 }
@@ -39485,25 +39668,30 @@ var WHITESPACE_COLLAPSE_PATTERN = /\s+/g;
 function compactionDebugEnabled() {
   return process.env["NODE_ENV"] === "development" || process.env["WRONGSTACK_DEBUG"] === "1";
 }
+var _debugLogger;
+function setCompactionDebugLogger(logger) {
+  _debugLogger = logger;
+}
 function emitCompactionMetrics(event, metrics) {
   if (!compactionDebugEnabled()) return;
-  console.log(
-    JSON.stringify({
-      level: "debug",
-      event,
-      messageCount: metrics.messageCount,
-      preserveStart: metrics.preserveStart,
-      fastPathIterations: metrics.fastPathIterations,
-      fastPathInnerIterations: metrics.fastPathInnerIterations,
-      // Ratios — anything > 2.0 indicates the inner loop is running more than expected
-      fastPathInnerPerOuter: metrics.fastPathIterations > 0 ? metrics.fastPathInnerIterations / metrics.fastPathIterations : 0,
-      fullPassIterations: metrics.fullPassIterations,
-      fullPassInnerIterations: metrics.fullPassInnerIterations,
-      fullPassInnerPerOuter: metrics.fullPassIterations > 0 ? metrics.fullPassInnerIterations / metrics.fullPassIterations : 0,
-      tokensSaved: metrics.tokensSaved,
-      changed: metrics.changed
-    })
-  );
+  const ctx = {
+    event,
+    messageCount: metrics.messageCount,
+    preserveStart: metrics.preserveStart,
+    fastPathIterations: metrics.fastPathIterations,
+    fastPathInnerIterations: metrics.fastPathInnerIterations,
+    fastPathInnerPerOuter: metrics.fastPathIterations > 0 ? metrics.fastPathInnerIterations / metrics.fastPathIterations : 0,
+    fullPassIterations: metrics.fullPassIterations,
+    fullPassInnerIterations: metrics.fullPassInnerIterations,
+    fullPassInnerPerOuter: metrics.fullPassIterations > 0 ? metrics.fullPassInnerIterations / metrics.fullPassIterations : 0,
+    tokensSaved: metrics.tokensSaved,
+    changed: metrics.changed
+  };
+  if (_debugLogger) {
+    _debugLogger.debug(`compaction: ${event}`, ctx);
+  } else {
+    console.log(JSON.stringify({ level: "debug", ...ctx }));
+  }
 }
 var estimateMessages = estimateMessageTokens;
 function hasTextContent(m) {
@@ -39535,18 +39723,20 @@ function findPreserveStart(messages, preserveK) {
     preserveStart--;
   }
   if (compactionDebugEnabled()) {
-    console.log(
-      JSON.stringify({
-        level: "debug",
-        event: "compaction.find_preserve_start.ended",
-        messageCount: messages.length,
-        preserveK,
-        preserveStart,
-        pairRepairIterations,
-        pairRepairInnerIterations,
-        pairRepairInnerPerOuter: pairRepairIterations > 0 ? pairRepairInnerIterations / pairRepairIterations : 0
-      })
-    );
+    const ctx = {
+      event: "compaction.find_preserve_start.ended",
+      messageCount: messages.length,
+      preserveK,
+      preserveStart,
+      pairRepairIterations,
+      pairRepairInnerIterations,
+      pairRepairInnerPerOuter: pairRepairIterations > 0 ? pairRepairInnerIterations / pairRepairIterations : 0
+    };
+    if (_debugLogger) {
+      _debugLogger.debug("compaction: find_preserve_start.ended", ctx);
+    } else {
+      console.log(JSON.stringify({ level: "debug", ...ctx }));
+    }
   }
   return preserveStart;
 }
@@ -39578,8 +39768,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;
@@ -39661,16 +39851,18 @@ function eliseOldToolResults(messages, opts) {
     if (compactionDebugEnabled()) {
       const ratio = fullPassInnerIterations / fullPassIterations;
       if (ratio > 10) {
-        console.error(
-          JSON.stringify({
-            level: "error",
-            event: "compaction.elision.regression",
-            message: `fullPassInnerPerOuter=${ratio.toFixed(2)} exceeds threshold 10 \u2014 possible O(n\xB7m) regression`,
-            messageCount: messages.length,
-            fullPassIterations,
-            fullPassInnerIterations
-          })
-        );
+        const ctx = {
+          event: "compaction.elision.regression",
+          message: `fullPassInnerPerOuter=${ratio.toFixed(2)} exceeds threshold 10 \u2014 possible O(n\xB7m) regression`,
+          messageCount: messages.length,
+          fullPassIterations,
+          fullPassInnerIterations
+        };
+        if (_debugLogger) {
+          _debugLogger.error(`compaction: elision.regression \u2014 ratio ${ratio.toFixed(2)}`, ctx);
+        } else {
+          console.error(JSON.stringify({ level: "error", ...ctx }));
+        }
       }
     }
   }
@@ -40630,10 +40822,13 @@ var HybridCompactor = class {
   preserveK;
   eliseThreshold;
   smart;
+  logger;
   constructor(opts = {}) {
     this.preserveK = opts.preserveK ?? 5;
     this.eliseThreshold = opts.eliseThreshold ?? 2e3;
     this.smart = opts.smart ?? false;
+    this.logger = opts.logger ?? noOpLogger;
+    setCompactionDebugLogger(this.logger);
   }
   async compact(ctx, opts = {}) {
     const beforeTokens = estimateMessages(ctx.messages);
@@ -41436,8 +41631,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");
@@ -43791,6 +43986,7 @@ var IntelligentCompactor = class {
   summarizerPrompt;
   summarizerModel;
   oneShotOrchestrator;
+  logger;
   constructor(opts) {
     this.provider = opts.provider;
     this.warnThreshold = opts.warnThreshold ?? 0.5;
@@ -43802,6 +43998,8 @@ var IntelligentCompactor = class {
     this.summarizerPrompt = opts.summarizerPrompt ?? readBundledInstructionText("llm/intelligent-compactor-summarizer.md");
     this.summarizerModel = opts.summarizerModel;
     this.oneShotOrchestrator = opts.oneShotOrchestrator;
+    this.logger = opts.logger ?? noOpLogger;
+    setCompactionDebugLogger(this.logger);
   }
   async compact(ctx, opts = {}) {
     const beforeTokens = estimateMessages(ctx.messages);
@@ -44597,11 +44795,13 @@ var LLMSelector = class {
   systemPrompt;
   maxOutputTokens;
   oneShotOrchestrator;
+  logger;
   constructor(opts) {
     this.provider = opts.provider;
     this.model = opts.model ?? "unknown";
+    this.logger = opts.logger ?? noOpLogger;
     if (this.model === "unknown" && (process.env["NODE_ENV"] === "development" || process.env["WRONGSTACK_DEBUG"] === "1")) {
-      console.warn(
+      this.logger.warn(
         "[LLMSelector] model not set \u2014 selector will use the provider default. Set `model` explicitly in LLMSelectorOptions to silence this warning."
       );
     }
@@ -44651,14 +44851,9 @@ IMPORTANT: Total conversation (${totalTokens} tokens) exceeds budget (${effectiv
       }
     } catch (err) {
       if (err instanceof Error) {
-        console.warn(
-          JSON.stringify({
-            level: "warn",
-            event: "llm_selector.call_failed",
-            message: `selector call failed, using recency fallback: ${err.message}`,
-            timestamp: (/* @__PURE__ */ new Date()).toISOString()
-          })
-        );
+        this.logger.warn(`selector call failed, using recency fallback: ${err.message}`, {
+          event: "llm_selector.call_failed"
+        });
       }
       return this.fallbackSelect(messages, effectiveBudget);
     } finally {
@@ -44765,6 +44960,7 @@ var SelectiveCompactor = class {
   eliseThreshold;
   summarizerModel;
   summarizerPrompt;
+  logger;
   constructor(opts) {
     this.provider = opts.provider;
     this.selector = opts.selector ?? new LLMSelector({ provider: opts.provider, model: opts.selectorModel, maxOutputTokens: opts.selectorMaxOutputTokens });
@@ -44775,8 +44971,10 @@ var SelectiveCompactor = class {
     this.preserveK = opts.preserveK ?? 4;
     this.eliseThreshold = opts.eliseThreshold ?? 300;
     this.summarizerModel = opts.summarizerModel ?? opts.selectorModel;
+    this.logger = opts.logger ?? noOpLogger;
+    setCompactionDebugLogger(this.logger);
     if (this.summarizerModel === void 0 && (process.env["NODE_ENV"] === "development" || process.env["WRONGSTACK_DEBUG"] === "1")) {
-      console.warn(
+      this.logger.warn(
         "[SelectiveCompactor] summarizerModel not set \u2014 will fall back to ctx.model at summarize time. Set `summarizerModel` explicitly to silence this warning."
       );
     }
@@ -45305,8 +45503,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 +45513,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 +46257,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;
     }
   }
 }
@@ -47945,6 +48143,7 @@ var DefaultModelsRegistry = class {
   overlayUrl;
   overlayFile;
   overlayCacheFile;
+  logger;
   constructor(opts) {
     this.cacheFile = opts.cacheFile;
     this.url = opts.url ?? process.env[ENV_URL_KEY] ?? DEFAULT_URL;
@@ -47958,6 +48157,7 @@ var DefaultModelsRegistry = class {
     this.overlayUrl = opts.overlayUrl;
     this.overlayFile = opts.overlayFile;
     this.overlayCacheFile = opts.overlayCacheFile ?? (opts.overlayUrl ? path49.join(path49.dirname(opts.cacheFile), "models-overlay-cache.json") : void 0);
+    this.logger = opts.logger ?? noOpLogger;
   }
   async load(opts = {}) {
     if (this.payload && !opts.force) return this.payload;
@@ -47993,29 +48193,31 @@ 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.`
+        this.logger.warn(
+          `ModelsRegistry: models.dev unavailable (${toErrorMessage(err)}); using stale cache from ${formatAge(ageSeconds)} ago. Run \`wstack models refresh\` to retry.`,
+          { event: "models_registry.stale_cache_fallback" }
         );
-        return cached.payload;
+        return cached2.payload;
       }
       if (overlayAvailable) {
-        console.warn(
+        this.logger.warn(
           `ModelsRegistry: models.dev unavailable (${toErrorMessage(
             err
-          )}); serving curated overlay only.`
+          )}); serving curated overlay only.`,
+          { event: "models_registry.overlay_only_fallback" }
         );
         return {};
       }
@@ -48084,8 +48286,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 +48310,14 @@ 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);
-        console.warn(
-          `ModelsRegistry: overlay unavailable; using stale overlay from ${formatAge(ageSeconds)} ago.`
+      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);
+        this.logger.warn(
+          `ModelsRegistry: overlay unavailable; using stale overlay from ${formatAge(ageSeconds)} ago.`,
+          { event: "models_registry.overlay_stale_fallback", ageSeconds }
         );
-        return cached.payload;
+        return cached2.payload;
       }
       return void 0;
     }
@@ -48175,9 +48378,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 +48919,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 +48982,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 +49072,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 +49113,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 ?? (() => {
   });
@@ -49266,9 +49469,6 @@ var DefaultPermissionPolicy = class {
   loaded = false;
   trustFile;
   yolo;
-  yoloDestructive;
-  /** Deprecated compatibility flag; no longer gates YOLO calls. */
-  confirmDestructive;
   /**
    * Session-scoped "soft deny" map. When the user presses 'n' (block once),
    * the tool+pattern is added here. If the LLM retries in the same session,
@@ -49321,8 +49521,6 @@ var DefaultPermissionPolicy = class {
   constructor(opts) {
     this.trustFile = opts.trustFile;
     this.yolo = opts.yolo ?? false;
-    this.yoloDestructive = opts.yoloDestructive ?? opts.forceAllYolo ?? false;
-    this.confirmDestructive = opts.confirmDestructive ?? false;
     this.promptDelegate = opts.promptDelegate;
   }
   /**
@@ -49343,24 +49541,6 @@ var DefaultPermissionPolicy = class {
   getYolo() {
     return this.yolo;
   }
-  /** Toggle the destructive YOLO override at runtime. */
-  setYoloDestructive(enabled) {
-    if (this.yoloDestructive !== enabled) this._evalCache.clear();
-    this.yoloDestructive = enabled;
-  }
-  /** Check whether the destructive YOLO override is active. */
-  getYoloDestructive() {
-    return this.yoloDestructive;
-  }
-  /** Toggle deprecated destructive confirmation compatibility flag. */
-  setConfirmDestructive(enabled) {
-    if (this.confirmDestructive !== enabled) this._evalCache.clear();
-    this.confirmDestructive = enabled;
-  }
-  /** Check deprecated destructive confirmation compatibility flag. */
-  getConfirmDestructive() {
-    return this.confirmDestructive;
-  }
   /** Read-only diagnostics for policy inspector/editor surfaces. */
   getPolicyDiagnostics() {
     return this.policyDiagnostics.map((diagnostic) => ({ ...diagnostic }));
@@ -49441,8 +49621,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 +53699,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 +53779,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 +53865,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;
   }
   /**
@@ -54718,6 +54901,7 @@ var PhaseOrchestrator = class {
   taskRetryCounts = /* @__PURE__ */ new Map();
   // ── Git-worktree isolation (optional) ──────────────────────────────────────
   worktrees;
+  logger;
   /** Per-phase worktree handles, keyed by phase id. */
   phaseWorktrees = /* @__PURE__ */ new Map();
   /** Serializes all merges back to the base branch (one at a time). */
@@ -54729,6 +54913,7 @@ var PhaseOrchestrator = class {
     this.ctx = opts.ctx;
     this.events = opts.events ?? this.createNoopEventBus();
     this.worktrees = opts.worktrees;
+    this.logger = opts.logger ?? noOpLogger;
     this.opts = {
       maxConcurrentPhases: opts.maxConcurrentPhases ?? 1,
       maxConcurrentTasks: opts.maxConcurrentTasks ?? 2,
@@ -54801,12 +54986,7 @@ var PhaseOrchestrator = class {
     await Promise.allSettled([...this.phaseMergePromise.values()]);
     await this.mergeQueue.catch((err) => {
       const msg = toErrorMessage(err);
-      console.warn(JSON.stringify({
-        level: "warn",
-        event: "orchestrator.merge_queue_failed",
-        message: msg,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      }));
+      this.logger.warn(msg, { event: "orchestrator.merge_queue_failed" });
     });
   }
   /** Pause: active phases continue, but no new phase starts. */
@@ -54818,12 +54998,7 @@ var PhaseOrchestrator = class {
     this.paused = false;
     this.tick().catch((err) => {
       const msg = toErrorMessage(err);
-      console.error(JSON.stringify({
-        level: "error",
-        event: "orchestrator.tick_failed",
-        message: msg,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      }));
+      this.logger.error(msg, { event: "orchestrator.tick_failed" });
     });
   }
   /** Stop completely, including active phases. */
@@ -55044,13 +55219,7 @@ var PhaseOrchestrator = class {
       await Promise.allSettled(depPromises);
       this.mergeQueue = this.mergeQueue.then(() => this.mergeOne(phase, handle)).catch((err) => {
         const msg = toErrorMessage(err);
-        console.error(JSON.stringify({
-          level: "error",
-          event: "orchestrator.merge_failed",
-          phaseId: phase.id,
-          message: msg,
-          timestamp: (/* @__PURE__ */ new Date()).toISOString()
-        }));
+        this.logger.error(msg, { event: "orchestrator.merge_failed", phaseId: phase.id });
         this.markPhaseMergeFailed(phase, msg);
       });
       await this.mergeQueue;
@@ -55294,8 +55463,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 +56484,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 +56610,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 +56763,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 +56785,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 +56990,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;
@@ -56973,7 +57142,7 @@ var HookRunner = class {
     return this.registry.list(event).filter((e) => hookMatcherMatches(e.matcher, toolName));
   }
   async invoke(entry, payload, env) {
-    const allowNonPolicy = this.opts.allowNonPolicy ?? this.opts.allowShell ?? true;
+    const allowNonPolicy = this.opts.allowNonPolicy ?? true;
     if (!allowNonPolicy && !entry.policy) return null;
     let result;
     if (entry.kind === "inprocess") {
@@ -57007,7 +57176,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 +59889,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 +64271,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 +64282,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 +64510,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 +70358,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 +70523,7 @@ export {
   buildTranscriptFromEvents,
   buildUserContentBlocks,
   canonicalProjectRoot,
+  checkConnectivity,
   childChronicleContext,
   classifyFamily,
   classifyMailboxRecipient,
@@ -70728,6 +70900,7 @@ export {
   repairToolUseAdjacency,
   repeatedReadPressure,
   resetCalibration,
+  resetConnectivityCache,
   resolveAuditLevel,
   resolveBrainConfigDefaults,
   resolveBundledDesignKitsDir,