@rynfar/meridian 1.65.2 → 1.66.0

package/dist/{cli-syjqjygv.js → cli-nzvbaqjp.js}

@@ -2,6 +2,7 @@ import {
   AssignmentStore,
   ProfileExhaustion,
   choosePriorityProfile,
+  findCooldownReset,
   getActiveProfileId,
   getEffectiveProfiles,
   getPriorityFailbackPolicy,
@@ -13,7 +14,7 @@ import {
   restoreActiveProfile,
   setActiveProfile,
   shouldPromotePriorityAssignment
-} from "./cli-pdpry6q0.js";
+} from "./cli-5jxyma6z.js";
 import {
   isTrackedPlugin,
   recordError,
@@ -53,7 +54,7 @@ import {
   resolveSdkModelDefaults,
   stripExtendedContext,
   subscriptionIncludesExtendedContext
-} from "./cli-0ed6j0vk.js";
+} from "./cli-m9wqgk1q.js";
 import {
   claudeLog,
   createPlatformCredentialStore,
@@ -2827,7 +2828,7 @@ function extractClaudeCodeClientCwd(body) {
   const match2 = systemText.match(/Primary working directory:\s*([^\n<]+)/i);
   return match2?.[1]?.trim() || undefined;
 }
-function extractClaudeCodeSessionId(body) {
+function extractClaudeCodeSessionIdentity(body) {
   if (!body || typeof body !== "object")
     return;
   const metadata = body.metadata;
@@ -2845,7 +2846,17 @@ function extractClaudeCodeSessionId(body) {
   if (!userMetadata || typeof userMetadata !== "object")
     return;
   const sessionId = userMetadata.session_id;
-  return typeof sessionId === "string" && sessionId.length > 0 ? sessionId : undefined;
+  if (typeof sessionId !== "string" || sessionId.length === 0)
+    return;
+  const parentSessionId = userMetadata.parent_session_id;
+  const parent = typeof parentSessionId === "string" && parentSessionId.length > 0 && parentSessionId !== sessionId ? parentSessionId : undefined;
+  return parent ? { sessionId, parentSessionId: parent } : { sessionId };
+}
+function extractClaudeCodeSessionId(body) {
+  return extractClaudeCodeSessionIdentity(body)?.sessionId;
+}
+function extractClaudeCodeParentSessionId(body) {
+  return extractClaudeCodeSessionIdentity(body)?.parentSessionId;
 }
 var claudeCodeAdapter;
 var init_claudecode = __esm(() => {
@@ -2858,6 +2869,9 @@ var init_claudecode = __esm(() => {
     getSessionId(_c, body) {
       return extractClaudeCodeSessionId(body);
     },
+    getParentSessionId(_c, body) {
+      return extractClaudeCodeParentSessionId(body);
+    },
     extractWorkingDirectory(_body) {
       return;
     },
@@ -3121,6 +3135,11 @@ var init_prime = __esm(() => {
     getSessionId(c, body) {
       return c.req.header("x-session-affinity") ?? extractClaudeCodeSessionId(body);
     },
+    getParentSessionId(c, body) {
+      if (c.req.header("x-session-affinity"))
+        return;
+      return extractClaudeCodeParentSessionId(body);
+    },
     extractWorkingDirectory(body) {
       return extractPrimeCwd(body);
     },
@@ -6567,6 +6586,129 @@ function linkRequestAbort(signal) {
   };
 }
 
+// src/proxy/sessionTree.ts
+var EMPTY_CANCELLATION = { keys: [], requestIds: [] };
+var MAX_SUBTREE_DEPTH = 64;
+function truncateSessionKey(key, length = 8) {
+  return key.length > length ? `${key.slice(0, length)}…` : key;
+}
+
+class SessionTreeRegistry {
+  nextToken = 1;
+  entries = new Map;
+  childrenByParent = new Map;
+  propagations = 0;
+  cancelledDescendants = 0;
+  register(entry) {
+    const token = this.nextToken++;
+    this.entries.set(token, entry);
+    const indexedParent = entry.parentKey && entry.parentKey !== entry.sessionKey ? entry.parentKey : undefined;
+    if (indexedParent) {
+      let siblings = this.childrenByParent.get(indexedParent);
+      if (!siblings) {
+        siblings = new Set;
+        this.childrenByParent.set(indexedParent, siblings);
+      }
+      siblings.add(token);
+    }
+    let released = false;
+    return {
+      release: () => {
+        if (released)
+          return;
+        released = true;
+        this.entries.delete(token);
+        if (!indexedParent)
+          return;
+        const siblings = this.childrenByParent.get(indexedParent);
+        if (!siblings)
+          return;
+        siblings.delete(token);
+        if (siblings.size === 0)
+          this.childrenByParent.delete(indexedParent);
+      }
+    };
+  }
+  descendantsOf(sessionKey) {
+    const visitedKeys = new Set([sessionKey]);
+    let frontier = [sessionKey];
+    const found = [];
+    for (let depth = 0;depth < MAX_SUBTREE_DEPTH && frontier.length > 0; depth++) {
+      const next = [];
+      for (const parentKey of frontier) {
+        const tokens = this.childrenByParent.get(parentKey);
+        if (!tokens)
+          continue;
+        for (const token of tokens) {
+          const entry = this.entries.get(token);
+          if (!entry)
+            continue;
+          found.push(entry);
+          if (visitedKeys.has(entry.sessionKey))
+            continue;
+          visitedKeys.add(entry.sessionKey);
+          next.push(entry.sessionKey);
+        }
+      }
+      frontier = next;
+    }
+    return found;
+  }
+  liveRequestsFor(sessionKey) {
+    const found = [];
+    for (const entry of this.entries.values()) {
+      if (entry.sessionKey === sessionKey)
+        found.push(entry);
+    }
+    return found;
+  }
+  cancelDescendants(sessionKey, reason) {
+    return this.cancel(sessionKey, { reason });
+  }
+  cancelSubtree(sessionKey, reason) {
+    return this.cancel(sessionKey, { reason, includeSelf: true });
+  }
+  cancel(sessionKey, options) {
+    const descendants = this.descendantsOf(sessionKey);
+    const targets = options.includeSelf ? [...this.liveRequestsFor(sessionKey), ...descendants] : descendants;
+    if (targets.length === 0)
+      return EMPTY_CANCELLATION;
+    const keys = [];
+    const requestIds = [];
+    for (const entry of targets) {
+      try {
+        entry.abort(options.reason);
+      } catch {}
+      if (!keys.includes(entry.sessionKey))
+        keys.push(entry.sessionKey);
+      requestIds.push(entry.requestId);
+    }
+    this.propagations++;
+    this.cancelledDescendants += descendants.length;
+    return { keys, requestIds };
+  }
+  stats() {
+    let linked = 0;
+    for (const entry of this.entries.values()) {
+      if (entry.parentKey)
+        linked++;
+    }
+    return {
+      tracked: this.entries.size,
+      linked,
+      propagations: this.propagations,
+      cancelledDescendants: this.cancelledDescendants
+    };
+  }
+  clear() {
+    this.entries.clear();
+    this.childrenByParent.clear();
+    this.propagations = 0;
+    this.cancelledDescendants = 0;
+  }
+}
+var processSessionTree = new SessionTreeRegistry;
+
 // src/proxy/concurrency.ts
 var DEFAULT_MAX_CONCURRENT = 10;
 var didWarnInvalidMaxConcurrent = false;
@@ -6746,6 +6888,57 @@ async function closeServerWithGracePeriod(server, options) {
   await closePromise;
 }
 
+// src/proxy/retryAfter.ts
+var RETRYABLE_STATUSES = new Set([429, 503, 529]);
+var OVERLOADED_RETRY_AFTER_SECONDS = 5;
+var RATE_LIMIT_DEFAULT_RETRY_AFTER_SECONDS = 60;
+var RETRY_AFTER_MIN_SECONDS = 1;
+var RETRY_AFTER_MAX_SECONDS = 24 * 60 * 60;
+function parseRetryAfterMs(raw2, now = Date.now()) {
+  if (!raw2)
+    return null;
+  const seconds = Number(raw2);
+  if (Number.isFinite(seconds))
+    return Math.max(0, seconds * 1000);
+  const retryAt = Date.parse(raw2);
+  return Number.isFinite(retryAt) ? Math.max(0, retryAt - now) : null;
+}
+function extractRetryAfterSeconds(errMsg) {
+  if (!errMsg)
+    return null;
+  const match2 = errMsg.match(/retry[-_ ]?after"?\s*[:=]\s*"?(\d+)/i);
+  if (!match2?.[1])
+    return null;
+  const seconds = Number(match2[1]);
+  return Number.isFinite(seconds) ? seconds : null;
+}
+function retryAfterSeconds(input) {
+  if (!RETRYABLE_STATUSES.has(input.status))
+    return null;
+  const now = input.now ?? Date.now();
+  const upstreamMs = parseRetryAfterMs(input.upstreamRetryAfter, now);
+  if (upstreamMs !== null)
+    return clamp(Math.ceil(upstreamMs / 1000));
+  const embedded = extractRetryAfterSeconds(input.errorMessage);
+  if (embedded !== null)
+    return clamp(embedded);
+  if (input.resetAtMs != null && input.resetAtMs > now) {
+    return clamp(Math.ceil((input.resetAtMs - now) / 1000));
+  }
+  return input.status === 429 ? RATE_LIMIT_DEFAULT_RETRY_AFTER_SECONDS : OVERLOADED_RETRY_AFTER_SECONDS;
+}
+function retryAfterHeaders(seconds) {
+  return seconds === null ? {} : { "Retry-After": String(seconds) };
+}
+function retryAfterBodyFields(seconds) {
+  return seconds === null ? {} : { retry_after: seconds };
+}
+function clamp(seconds) {
+  if (!Number.isFinite(seconds))
+    return RATE_LIMIT_DEFAULT_RETRY_AFTER_SECONDS;
+  return Math.min(RETRY_AFTER_MAX_SECONDS, Math.max(RETRY_AFTER_MIN_SECONDS, Math.round(seconds)));
+}
+
 // src/proxy/oauthUsage.ts
 var OAUTH_USAGE_URL = "https://api.anthropic.com/api/oauth/usage";
 var OAUTH_BETA_HEADER = "oauth-2025-04-20";
@@ -6776,15 +6969,6 @@ function normalizeUtilization(raw2) {
     return null;
   return Math.max(0, raw2 / 100);
 }
-function parseRetryAfterMs(raw2) {
-  if (!raw2)
-    return null;
-  const seconds = Number(raw2);
-  if (Number.isFinite(seconds))
-    return Math.max(0, seconds * 1000);
-  const retryAt = Date.parse(raw2);
-  return Number.isFinite(retryAt) ? Math.max(0, retryAt - Date.now()) : null;
-}
 function modelScopedWindowType(limit) {
   if (limit.kind !== "weekly_scoped")
     return null;
@@ -22081,6 +22265,13 @@ function render(s, reqs, logs) {
     + card('Median TTFB', ms(s.ttfb.p50), 'p95: ' + ms(s.ttfb.p95))
     + card('Proxy Overhead', ms(s.proxyOverhead.p50), 'p95: ' + ms(s.proxyOverhead.p95))
     + card('Queue Wait', ms(s.queueWait.p50), 'p95: ' + ms(s.queueWait.p95))
+    // Only rendered when a subagent tree has actually been seen: for a
+    // single-agent client these numbers are permanently zero and would just be
+    // a dead tile. Counts are cumulative, not windowed.
+    + ((s.sessionTree && (s.sessionTree.linked > 0 || s.sessionTree.cancelledDescendants > 0))
+        ? card('Subtree Cancels', s.sessionTree.cancelledDescendants,
+            s.sessionTree.linked + ' linked live / ' + s.sessionTree.propagations + ' propagations')
+        : '')
     + '</div>';
 
   // Token usage cards
@@ -22283,7 +22474,7 @@ timer = setInterval(refresh, 5000);
 // src/telemetry/routes.ts
 var _iconPath = resolve2(dirname2(fileURLToPath(import.meta.url)), "..", "..", "assets", "icon.svg");
 var _iconSvg = existsSync3(_iconPath) ? readFileSync2(_iconPath, "utf-8") : null;
-function createTelemetryRoutes() {
+function createTelemetryRoutes(deps = {}) {
   const routes = new Hono2;
   routes.get("/", (c) => {
     return c.html(dashboardHtml);
@@ -22310,7 +22501,8 @@ function createTelemetryRoutes() {
   routes.get("/summary", (c) => {
     const windowMs = Number.parseInt(c.req.query("window") || "3600000", 10);
     const summary = telemetryStore2.summarize(windowMs);
-    return c.json(summary);
+    const sessionTree = deps.getSessionTree?.();
+    return c.json(sessionTree ? { ...summary, sessionTree } : summary);
   });
   routes.get("/logs", (c) => {
     const limit = Number.parseInt(c.req.query("limit") || "100", 10);
@@ -23355,6 +23547,23 @@ function stopUpdateCheck() {
 }
 
 // src/proxy/openai.ts
+var ANTHROPIC_USAGE_FIELDS = [
+  "input_tokens",
+  "output_tokens",
+  "cache_read_input_tokens",
+  "cache_creation_input_tokens"
+];
+function mergeAnthropicUsage(current, update) {
+  const merged = { ...current };
+  for (const field of ANTHROPIC_USAGE_FIELDS) {
+    if (typeof update[field] === "number")
+      merged[field] = update[field];
+  }
+  return merged;
+}
+function totalAnthropicInputTokens(usage) {
+  return (usage?.input_tokens ?? 0) + (usage?.cache_read_input_tokens ?? 0) + (usage?.cache_creation_input_tokens ?? 0);
+}
 function extractOpenAiContent(content) {
   if (typeof content === "string")
     return content;
@@ -23596,7 +23805,7 @@ function translateAnthropicToOpenAi(response, completionId, model, created, opti
   }));
   const thinkingPassthrough = options?.thinkingPassthrough;
   const thinking = thinkingPassthrough !== false ? contentBlocks.filter((b) => b.type === "thinking").map((b) => b.thinking).join("") : "";
-  const promptTokens = response.usage?.input_tokens ?? 0;
+  const promptTokens = totalAnthropicInputTokens(response.usage);
   const completionTokens = response.usage?.output_tokens ?? 0;
   return {
     id: completionId,
@@ -23616,7 +23825,11 @@ function translateAnthropicToOpenAi(response, completionId, model, created, opti
     usage: {
       prompt_tokens: promptTokens,
       completion_tokens: completionTokens,
-      total_tokens: promptTokens + completionTokens
+      total_tokens: promptTokens + completionTokens,
+      prompt_tokens_details: {
+        cached_tokens: response.usage?.cache_read_input_tokens ?? 0,
+        cache_write_tokens: response.usage?.cache_creation_input_tokens ?? 0
+      }
     }
   };
 }
@@ -23627,15 +23840,18 @@ function createSseTranslator(ctx) {
     if (event.type === "content_block_start" && event.content_block?.type === "tool_use" && typeof event.content_block.name === "string") {
       toolCallIndex++;
     }
+    if (event.type === "message_start" && event.message?.usage) {
+      lastUsage = mergeAnthropicUsage(lastUsage, event.message.usage);
+    }
     if (event.type === "message_delta" && event.usage) {
-      lastUsage = event.usage;
+      lastUsage = mergeAnthropicUsage(lastUsage, event.usage);
     }
     return translateAnthropicSseEvent(event, ctx.completionId, ctx.model, ctx.created, toolCallIndex, ctx.thinkingPassthrough);
   };
   translate.buildUsageChunk = () => {
     if (!ctx.includeUsage || !lastUsage)
       return null;
-    const promptTokens = lastUsage.input_tokens ?? 0;
+    const promptTokens = totalAnthropicInputTokens(lastUsage);
     const completionTokens = lastUsage.output_tokens ?? 0;
     return {
       id: ctx.completionId,
@@ -23646,7 +23862,11 @@ function createSseTranslator(ctx) {
       usage: {
         prompt_tokens: promptTokens,
         completion_tokens: completionTokens,
-        total_tokens: promptTokens + completionTokens
+        total_tokens: promptTokens + completionTokens,
+        prompt_tokens_details: {
+          cached_tokens: lastUsage.cache_read_input_tokens ?? 0,
+          cache_write_tokens: lastUsage.cache_creation_input_tokens ?? 0
+        }
       }
     };
   };
@@ -23988,9 +24208,17 @@ function reasoningRequested(body) {
   return Array.isArray(include) && include.some((v) => typeof v === "string" && v.startsWith("reasoning"));
 }
 function mapUsage(usage) {
-  const input = usage?.input_tokens ?? 0;
+  const input = totalAnthropicInputTokens(usage);
   const output = usage?.output_tokens ?? 0;
-  return { input_tokens: input, output_tokens: output, total_tokens: input + output };
+  return {
+    input_tokens: input,
+    output_tokens: output,
+    total_tokens: input + output,
+    input_tokens_details: {
+      cached_tokens: usage?.cache_read_input_tokens ?? 0,
+      cache_write_tokens: usage?.cache_creation_input_tokens ?? 0
+    }
+  };
 }
 function toResponsesStatus(stopReason) {
   return stopReason === "max_tokens" ? "incomplete" : "completed";
@@ -24048,8 +24276,7 @@ function translateAnthropicToResponses(res, ctx) {
 function createResponsesSseTranslator(ctx) {
   let seq = 0;
   let outputIndex = 0;
-  let inputTokens = 0;
-  let outputTokens = 0;
+  let usage;
   let createdEmitted = false;
   let stopReason;
   const blocks = new Map;
@@ -24070,7 +24297,8 @@ function createResponsesSseTranslator(ctx) {
     const out = [];
     switch (event.type) {
       case "message_start": {
-        inputTokens = event.message?.usage?.input_tokens ?? 0;
+        if (event.message?.usage)
+          usage = mergeAnthropicUsage(usage, event.message.usage);
         if (!createdEmitted) {
           createdEmitted = true;
           out.push(emit("response.created", { response: responseEnvelope("in_progress", { output: [] }) }));
@@ -24186,8 +24414,8 @@ function createResponsesSseTranslator(ctx) {
         break;
       }
       case "message_delta": {
-        if (typeof event.usage?.output_tokens === "number")
-          outputTokens = event.usage.output_tokens;
+        if (event.usage)
+          usage = mergeAnthropicUsage(usage, event.usage);
         if (typeof event.delta?.stop_reason === "string")
           stopReason = event.delta.stop_reason;
         break;
@@ -24197,7 +24425,7 @@ function createResponsesSseTranslator(ctx) {
         out.push(emit(status === "incomplete" ? "response.incomplete" : "response.completed", {
           response: responseEnvelope(status, {
             output: finalOutput,
-            usage: { input_tokens: inputTokens, output_tokens: outputTokens, total_tokens: inputTokens + outputTokens },
+            usage: mapUsage(usage),
             parallel_tool_calls: true,
             tool_choice: "auto",
             tools: [],
@@ -35438,9 +35666,14 @@ function createProxyServer(config2 = {}) {
   const internalHopToken = randomUUID6();
   const errorEnvelope = (shape, type, message) => shape === "anthropic" ? { type: "error", error: { type, message } } : { error: { type, message, code: null } };
   const DRAIN_MESSAGE = "Meridian is shutting down and is not accepting new requests. Retry against another instance.";
+  const TRANSIENT_RETRY_AFTER_HEADERS = retryAfterHeaders(OVERLOADED_RETRY_AFTER_SECONDS);
   const drainingResponse = (shape = "anthropic") => new Response(JSON.stringify(errorEnvelope(shape, "overloaded_error", DRAIN_MESSAGE)), {
     status: 503,
-    headers: { "Content-Type": "application/json", "x-meridian-draining": "1" }
+    headers: {
+      "Content-Type": "application/json",
+      "x-meridian-draining": "1",
+      ...TRANSIENT_RETRY_AFTER_HEADERS
+    }
   });
   async function relayInnerError(internalRes, shape) {
     const errBody = await internalRes.text();
@@ -35456,6 +35689,9 @@ function createProxyServer(config2 = {}) {
     const drainingHeader = internalRes.headers.get("x-meridian-draining");
     if (drainingHeader)
       headers["x-meridian-draining"] = drainingHeader;
+    const innerRetryAfter = internalRes.headers.get("retry-after");
+    if (innerRetryAfter)
+      headers["Retry-After"] = innerRetryAfter;
     return new Response(JSON.stringify(payload), { status: internalRes.status, headers });
   }
   async function* runSdkQueryAttempt(params, signal, requestMeta, mode, activeLocators) {
@@ -35533,13 +35769,20 @@ function createProxyServer(config2 = {}) {
     const setting = getSetting("profileOrder");
     return Array.isArray(setting) && setting.length > 0 ? setting : undefined;
   }
-  function priorityCooldownUntil(profileId, now) {
-    const windows = rateLimitStore.getAll(profileId).map((e) => ({
+  function profileCooldownWindows(profileId) {
+    return rateLimitStore.getAll(profileId).map((e) => ({
       type: e.rateLimitType ?? "",
       resetsAt: e.resetsAt,
       exhausted: e.status === "rejected" || (e.utilization ?? 0) >= 1
     }));
-    return resolveCooldownUntil(windows, now, PRIORITY_DEFAULT_COOLDOWN_MS);
+  }
+  function priorityCooldownUntil(profileId, now) {
+    return resolveCooldownUntil(profileCooldownWindows(profileId), now, PRIORITY_DEFAULT_COOLDOWN_MS);
+  }
+  function observedResetAtMs(profileId, now) {
+    if (!profileId)
+      return null;
+    return findCooldownReset(profileCooldownWindows(profileId), now);
   }
   function refinePriorityCooldown(profileId) {
     const target = getEffectiveProfiles(finalConfig.profiles).find((p) => p.id === profileId);
@@ -35660,7 +35903,7 @@ function createProxyServer(config2 = {}) {
           return options.context.json({
             type: "error",
             error: { type: "overloaded_error", message: "Durable priority attempt state is unavailable" }
-          }, 503);
+          }, 503, TRANSIENT_RETRY_AFTER_HEADERS);
         }
         attemptOwnerToken = claim.ownerToken;
       } catch (error51) {
@@ -35671,7 +35914,7 @@ function createProxyServer(config2 = {}) {
         return options.context.json({
           type: "error",
           error: { type: "overloaded_error", message: "Durable priority attempt state is unavailable" }
-        }, 503);
+        }, 503, TRANSIENT_RETRY_AFTER_HEADERS);
       }
     }
     const settleAttempt = (disposition) => {
@@ -35691,11 +35934,12 @@ function createProxyServer(config2 = {}) {
     const unavailableAttemptResponse = () => options.context.json({
       type: "error",
       error: { type: "overloaded_error", message: "Durable priority attempt state is unavailable" }
-    }, 503);
+    }, 503, TRANSIENT_RETRY_AFTER_HEADERS);
     let lastError = null;
     let lastStatus = 429;
     let previous = null;
     let previousReason = "rate_limit_error";
+    let earliestPoolReset = null;
     for (const [attempt, candidate] of options.candidateIds.entries()) {
       const exposure = { committed: false };
       const priorityPublication = options.durableRoute && options.publicationTurn ? {
@@ -35734,6 +35978,9 @@ function createProxyServer(config2 = {}) {
       const quotaRefusal = isQuotaRefusal(reason);
       const cooldownUntil = quotaRefusal ? priorityCooldownUntil(candidate, Date.now()) : Date.now() + PRIORITY_DEFAULT_COOLDOWN_MS;
       priorityExhaustion.mark(candidate, cooldownUntil, reason);
+      if (earliestPoolReset === null || cooldownUntil < earliestPoolReset) {
+        earliestPoolReset = cooldownUntil;
+      }
       claudeLog("priority.exhausted", { profile: candidate, until: cooldownUntil, reason });
       if (quotaRefusal)
         refinePriorityCooldown(candidate);
@@ -35759,7 +36006,14 @@ data: ${JSON.stringify(lastError)}
         headers: { "content-type": "text/event-stream; charset=utf-8", "cache-control": "no-cache" }
       });
     }
-    return new Response(JSON.stringify(lastError), { status: lastStatus, headers: { "content-type": "application/json" } });
+    const poolRetryAfter = retryAfterSeconds({
+      status: lastStatus,
+      resetAtMs: earliestPoolReset
+    });
+    return new Response(JSON.stringify(lastError), {
+      status: lastStatus,
+      headers: { "content-type": "application/json", ...retryAfterHeaders(poolRetryAfter) }
+    });
   }
   app.use("/auth/*", requireAuth);
   app.get("/", (c) => {
@@ -35769,7 +36023,7 @@ data: ${JSON.stringify(lastError)}
         status: "ok",
         service: "meridian",
         format: "anthropic",
-        endpoints: ["/v1/messages", "/messages", "/v1/chat/completions", "/v1/responses", "/v1/models", "/v1/design/*", "/design-login", "/telemetry", "/metrics", "/health"]
+        endpoints: ["/v1/messages", "/messages", "/v1/chat/completions", "/v1/responses", "/v1/models", "/v1/sessions/:key/cancel", "/v1/design/*", "/design-login", "/telemetry", "/metrics", "/health"]
       });
     }
     return c.html(landingHtml);
@@ -35940,6 +36194,7 @@ data: ${JSON.stringify(lastError)}
         }
         priorityTerminalCommitted = true;
       };
+      let resolvedProfileId;
       try {
         let makePrompt = function() {
           if (structuredMessages) {
@@ -36017,7 +36272,7 @@ data: ${JSON.stringify(lastError)}
                   return c.json({
                     type: "error",
                     error: { type: "overloaded_error", message: "Durable priority routing state is unavailable" }
-                  }, 503);
+                  }, 503, TRANSIENT_RETRY_AFTER_HEADERS);
                 }
                 if (routeResult.status === "found") {
                   durableRoute = { routeKey, expectedGeneration: routeResult.generation };
@@ -36053,7 +36308,7 @@ data: ${JSON.stringify(lastError)}
                     return c.json({
                       type: "error",
                       error: { type: "overloaded_error", message: "Durable priority session state is unavailable" }
-                    }, 503);
+                    }, 503, TRANSIENT_RETRY_AFTER_HEADERS);
                   }
                   routeMappingIsCurrent = mapped.status === "found" && mapped.generation === routeResult.assignment.mappingGeneration;
                   if (!routeMappingIsCurrent) {
@@ -36061,7 +36316,7 @@ data: ${JSON.stringify(lastError)}
                       return c.json({
                         type: "error",
                         error: { type: "overloaded_error", message: "Durable priority session state is unavailable" }
-                      }, 503);
+                      }, 503, TRANSIENT_RETRY_AFTER_HEADERS);
                     }
                     durableRoute = { ...durableRoute, forceFreshReplay: true };
                   }
@@ -36069,7 +36324,7 @@ data: ${JSON.stringify(lastError)}
                   return c.json({
                     type: "error",
                     error: { type: "overloaded_error", message: "Durable priority attempt state is unavailable" }
-                  }, 503);
+                  }, 503, TRANSIENT_RETRY_AFTER_HEADERS);
                 } else if (trustedTurn) {
                   durableRoute = { routeKey, expectedGeneration: routeResult.generation };
                   publicationTurn = trustedTurn;
@@ -36092,7 +36347,7 @@ data: ${JSON.stringify(lastError)}
                 return c.json({
                   type: "error",
                   error: { type: "overloaded_error", message: "Durable priority routing state is unavailable" }
-                }, 503);
+                }, 503, TRANSIENT_RETRY_AFTER_HEADERS);
               }
               const pick2 = choosePriorityProfile(order, (id) => priorityExhaustion.isExhausted(id));
               const first = retainOnlyProfile ?? (shouldPromote ? preferred : assignmentIsHealthy ? assignedProfile : pick2?.id ?? preferred);
@@ -36114,13 +36369,15 @@ data: ${JSON.stringify(lastError)}
           }
         }
         const profile = resolveProfile(finalConfig.profiles, finalConfig.defaultProfile, options.forcedProfileId || c.req.header("x-meridian-profile") || undefined, routingMode === "sticky" ? { routingMode, stickySessionKey: adapter.getSessionId(c, body) } : undefined);
+        resolvedProfileId = profile.id;
         const authStatus = await getClaudeAuthStatusAsync(profile.id !== "default" ? profile.id : undefined, Object.keys(profile.env).length > 0 ? profile.env : undefined);
         const requestSource = c.req.header("x-meridian-source")?.slice(0, 64) || undefined;
         const declaredAgentMode = adapter.getAgentMode?.(c, body) ?? c.req.header("x-opencode-agent-mode") ?? null;
         const isSubagentRequest = declaredAgentMode === "subagent" || requestSource?.startsWith("subagent-") === true;
         const agentMode = isSubagentRequest ? "subagent" : declaredAgentMode;
         const requestedModel = typeof body.model === "string" ? body.model : "sonnet";
-        let model = mapModelToClaudeModel(requestedModel, authStatus?.subscriptionType, agentMode, profile.id);
+        const benchSessionKey = adapter.getSessionId(c, body) || undefined;
+        let model = mapModelToClaudeModel(requestedModel, authStatus?.subscriptionType, agentMode, profile.id, benchSessionKey);
         const envOverrides = explicitModelPin(requestedModel);
         const cwdResolution = resolveSdkWorkingDirectory({
           envOverride: process.env.MERIDIAN_WORKDIR ?? process.env.CLAUDE_PROXY_WORKDIR,
@@ -36825,7 +37082,7 @@ data: ${JSON.stringify(lastError)}
               claudeExecutable = await resolveClaudeExecutableAsync();
             }
             const MAX_RATE_LIMIT_RETRIES = 2;
-            const RATE_LIMIT_BASE_DELAY_MS = 1000;
+            const RATE_LIMIT_BASE_DELAY_MS = envInt("RATE_LIMIT_BASE_DELAY_MS", 1000);
             const response = async function* () {
               let rateLimitRetries = 0;
               if (profileCredentialStore) {
@@ -37085,7 +37342,7 @@ data: ${JSON.stringify(lastError)}
                     if (hasExtendedContext(model)) {
                       const from = model;
                       model = stripExtendedContext(model);
-                      recordExtendedContextRateLimited(profile.id, priorityCooldownUntil(profile.id, Date.now()));
+                      recordExtendedContextRateLimited(profile.id, priorityCooldownUntil(profile.id, Date.now()), benchSessionKey);
                       claudeLog("upstream.context_fallback", {
                         mode: "non_stream",
                         from,
@@ -37608,7 +37865,7 @@ data: ${JSON.stringify({ type: "content_block_stop", index: idx })}
               let nextClientBlockIndex = 0;
               try {
                 const MAX_RATE_LIMIT_RETRIES = 2;
-                const RATE_LIMIT_BASE_DELAY_MS = 1000;
+                const RATE_LIMIT_BASE_DELAY_MS = envInt("RATE_LIMIT_BASE_DELAY_MS", 1000);
                 const response = async function* () {
                   let rateLimitRetries = 0;
                   if (profileCredentialStore) {
@@ -37866,7 +38123,7 @@ data: ${JSON.stringify({ type: "content_block_stop", index: idx })}
                         if (hasExtendedContext(model)) {
                           const from = model;
                           model = stripExtendedContext(model);
-                          recordExtendedContextRateLimited(profile.id, priorityCooldownUntil(profile.id, Date.now()));
+                          recordExtendedContextRateLimited(profile.id, priorityCooldownUntil(profile.id, Date.now()), benchSessionKey);
                           claudeLog("upstream.context_fallback", {
                             mode: "stream",
                             from,
@@ -38798,6 +39055,11 @@ Subprocess stderr: ${stderrOutput}`;
                   message: `Upstream stalled: no data for ${error51.sinceLastMs}ms`
                 } : classifyError(errMsg, model);
                 claudeLog("proxy.anthropic.error", { error: errMsg, classified: streamErr.type });
+                const streamRetryAfter = retryAfterSeconds({
+                  status: streamErr.status,
+                  errorMessage: errMsg,
+                  resetAtMs: observedResetAtMs(profile.id, Date.now())
+                });
                 const sdkTerm = extractSdkTermination(errMsg);
                 const canRecoverAsToolUse = canRecoverCapturedToolUses({
                   reason: sdkTerm.reason,
@@ -39010,7 +39272,7 @@ data: ${JSON.stringify({
                   safeEnqueue(encoder.encode(`event: error
 data: ${JSON.stringify({
                     type: "error",
-                    error: { type: streamErr.type, message: streamErr.message }
+                    error: { type: streamErr.type, message: streamErr.message, ...retryAfterBodyFields(streamRetryAfter) }
                   })}
 
 `), "error_event_before_stop");
@@ -39022,7 +39284,7 @@ data: {"type":"message_stop"}
                   safeEnqueue(encoder.encode(`event: error
 data: ${JSON.stringify({
                     type: "error",
-                    error: { type: streamErr.type, message: streamErr.message }
+                    error: { type: streamErr.type, message: streamErr.message, ...retryAfterBodyFields(streamRetryAfter) }
                   })}
 
 `), "error_event");
@@ -39046,6 +39308,7 @@ data: ${JSON.stringify({
           cancel(reason) {
             requestAbort.abort(reason);
             requestAbort.detach();
+            requestMeta.cascadeSubtreeCancel?.("stream_cancel");
             if (!isIndependentSession && (!managedForkTarget || managedForkPublished || clientAssistantContentExposed)) {
               evictSession2(profileSessionId, profileScopedCwd, lineageMessages, mappingExpectedGeneration);
               claudeLog("passthrough.client_abort_settled", { action: "evict", source: "stream_cancel" });
@@ -39069,6 +39332,11 @@ data: ${JSON.stringify({
           error: errMsg
         });
         const classified = requestAbort.controller.signal.aborted ? { status: 499, type: "request_cancelled", message: "The request was cancelled" } : classifyError(errMsg);
+        const retryAfter = retryAfterSeconds({
+          status: classified.status,
+          errorMessage: errMsg,
+          resetAtMs: observedResetAtMs(resolvedProfileId, Date.now())
+        });
         claudeLog("proxy.error", { error: errMsg, classified: classified.type });
         const sdkTerm = extractSdkTermination(errMsg);
         diagnosticLog2.error(`${requestMeta.requestId} ${formatSdkTermination(sdkTerm, {
@@ -39103,7 +39371,17 @@ data: ${JSON.stringify({
           textEvents: 0,
           error: classified.type
         });
-        return new Response(JSON.stringify({ type: "error", error: { type: classified.type, message: classified.message } }), { status: classified.status, headers: { "Content-Type": "application/json" } });
+        return new Response(JSON.stringify({
+          type: "error",
+          error: {
+            type: classified.type,
+            message: classified.message,
+            ...retryAfterBodyFields(retryAfter)
+          }
+        }), {
+          status: classified.status,
+          headers: { "Content-Type": "application/json", ...retryAfterHeaders(retryAfter) }
+        });
       } finally {
         if (!streamOwnsAbortLink) {
           await abandonManagedFork("request_complete_without_commit");
@@ -39112,6 +39390,17 @@ data: ${JSON.stringify({
       }
     });
   };
+  const logSubtreeCancel = (parentKey, cancelled, requestId, source) => {
+    const children = cancelled.keys.map((key) => truncateSessionKey(key));
+    claudeLog("session.tree_cancel_propagated", {
+      requestId,
+      source,
+      parent: truncateSessionKey(parentKey),
+      children,
+      requests: cancelled.requestIds.length
+    });
+    diagnosticLog2.session(`${requestId} session_tree_cancel source=${source} parent=${truncateSessionKey(parentKey)} ` + `children=${children.join(",")} requests=${cancelled.requestIds.length}`, requestId);
+  };
   const handleWithQueue = async (c, endpoint) => {
     if (draining && c.req.header("x-meridian-internal-hop") !== internalHopToken) {
       return drainingResponse();
@@ -39121,6 +39410,20 @@ data: ${JSON.stringify({
     claudeLog("request.enter", { requestId, endpoint });
     let sessionTurnLease;
     let crossProcessTurnLease;
+    let sessionTreeRegistration;
+    let detachSubtreeAbortWatch;
+    let subtreeSessionKey;
+    let subtreeCascaded = false;
+    const cascadeSubtreeCancel = (source) => {
+      const parentKey = subtreeSessionKey;
+      if (subtreeCascaded || !parentKey)
+        return;
+      subtreeCascaded = true;
+      const cancelled = processSessionTree.cancelDescendants(parentKey, new Error(`Parent session ${truncateSessionKey(parentKey)} was cancelled`));
+      if (cancelled.requestIds.length === 0)
+        return;
+      logSubtreeCancel(parentKey, cancelled, requestId, source);
+    };
     const turnWatchdogAbort = new AbortController;
     activeRequestAborts.add(turnWatchdogAbort);
     let finished = false;
@@ -39160,6 +39463,10 @@ data: ${JSON.stringify({
       } else {
         releaseSessionTurn(false);
       }
+      detachSubtreeAbortWatch?.();
+      detachSubtreeAbortWatch = undefined;
+      sessionTreeRegistration?.release();
+      sessionTreeRegistration = undefined;
       activeRequestAborts.delete(turnWatchdogAbort);
       inFlightRequests--;
     };
@@ -39188,6 +39495,21 @@ data: ${JSON.stringify({
         routingTurnIdentity = adapter.getRoutingTurnIdentity?.(c, body);
         const agentSessionId = adapter.getSessionId(c, body);
         if (agentSessionId) {
+          sessionTreeRegistration = processSessionTree.register({
+            requestId,
+            sessionKey: agentSessionId,
+            parentKey: adapter.getParentSessionId?.(c, body),
+            abort: (reason) => turnWatchdogAbort.abort(reason)
+          });
+          subtreeSessionKey = agentSessionId;
+          const clientSignal = c.req.raw.signal;
+          if (clientSignal.aborted) {
+            cascadeSubtreeCancel("client_abort");
+          } else {
+            const onClientAbort = () => cascadeSubtreeCancel("client_abort");
+            clientSignal.addEventListener("abort", onClientAbort, { once: true });
+            detachSubtreeAbortWatch = () => clientSignal.removeEventListener("abort", onClientAbort);
+          }
           const arrivalProfileIds = new Set(getEffectiveProfiles(finalConfig.profiles).map((profile) => profile.id));
           const explicitlyRequestedProfile = c.req.header("x-meridian-profile")?.trim();
           if (explicitlyRequestedProfile)
@@ -39249,7 +39571,7 @@ data: ${JSON.stringify({
                   type: "overloaded_error",
                   message: "Timed out waiting for another process to finish this session turn"
                 }
-              }), { status: 529, headers: { "Content-Type": "application/json" } });
+              }), { status: 529, headers: { "Content-Type": "application/json", ...TRANSIENT_RETRY_AFTER_HEADERS } });
             }
             throw error51;
           }
@@ -39267,7 +39589,8 @@ data: ${JSON.stringify({
         routingTurnIdentity,
         retainSessionTurnFence: () => {
           retainSessionTurnFence = true;
-        }
+        },
+        cascadeSubtreeCancel
       };
       const response = await handleMessages(c, requestMeta, {
         body,
@@ -39287,7 +39610,29 @@ data: ${JSON.stringify({
   };
   app.post("/v1/messages", (c) => handleWithQueue(c, "/v1/messages"));
   app.post("/messages", (c) => handleWithQueue(c, "/messages"));
-  app.route("/telemetry", createTelemetryRoutes());
+  app.post("/v1/sessions/:key/cancel", (c) => {
+    const key = c.req.param("key");
+    if (!key) {
+      return c.json({ type: "error", error: { type: "invalid_request_error", message: "Session key is required" } }, 400);
+    }
+    const cancelled = processSessionTree.cancelSubtree(key, new Error("Session cancelled by request"));
+    if (cancelled.requestIds.length > 0) {
+      claudeLog("session.tree_cancel_requested", {
+        session: truncateSessionKey(key),
+        keys: cancelled.keys.map((cancelledKey) => truncateSessionKey(cancelledKey)),
+        requests: cancelled.requestIds.length
+      });
+      diagnosticLog2.session(`session_tree_cancel_requested session=${truncateSessionKey(key)} requests=${cancelled.requestIds.length}`);
+    }
+    return c.json({
+      session: key,
+      cancelled: { sessions: cancelled.keys.length, requests: cancelled.requestIds.length },
+      requestIds: cancelled.requestIds
+    });
+  });
+  app.route("/telemetry", createTelemetryRoutes({
+    getSessionTree: () => processSessionTree.stats()
+  }));
   app.get("/settings", (c) => {
     const { settingsPageHtml: settingsPageHtml2 } = (init_settingsPage(), __toCommonJS(exports_settingsPage));
     return c.html(settingsPageHtml2);
@@ -39628,6 +39973,12 @@ data: ${JSON.stringify({
 `);
             buffer = lines.pop() ?? "";
             for (const line of lines) {
+              if (line.startsWith(":")) {
+                controller.enqueue(encoder.encode(`${line}
+
+`));
+                continue;
+              }
               if (!line.startsWith("data: "))
                 continue;
               const dataStr = line.slice(6).trim();
@@ -39746,6 +40097,12 @@ data: ${JSON.stringify({
 `);
             buffer = lines.pop() ?? "";
             for (const line of lines) {
+              if (line.startsWith(":")) {
+                controller.enqueue(encoder.encode(`${line}
+
+`));
+                continue;
+              }
               if (!line.startsWith("data: "))
                 continue;
               const dataStr = line.slice(6).trim();
@@ -39790,7 +40147,9 @@ data: ${JSON.stringify({ response: { id: responseId, status: "failed", error: {
     });
   });
   app.get("/v1/models", async (c) => {
-    const authStatus = await getClaudeAuthStatusAsync();
+    const profile = resolveProfile(finalConfig.profiles, finalConfig.defaultProfile);
+    const profileEnvOverrides = Object.keys(profile.env).length > 0 ? profile.env : undefined;
+    const authStatus = await getClaudeAuthStatusAsync(profile.id !== "default" ? profile.id : undefined, profileEnvOverrides);
     const extendedContext = subscriptionIncludesExtendedContext(authStatus?.subscriptionType);
     return c.json({ object: "list", data: buildModelList(extendedContext) });
   });