cartethyia 2.7.5 → 2.7.7

package/src/providers/integrations/trae/trae.ts

@@ -7,7 +7,7 @@
 import { GatewayError } from "../../../protocol/gateway-error";
 import type { CanonicalEvent, CanonicalMessage, CanonicalRequest, CanonicalStopReason } from "../../../protocol/canonical-model";
 import type { UsageRecord } from "../../../protocol/canonical-model";
-import { applyCacheMode, usageFromProvider } from "../../provider-usage";
+import { usageFromProvider } from "../../provider-usage";
 import {
   readCredentialSecret,
   assertWireFamily,
@@ -482,7 +482,7 @@ class TraeAdapter implements ProviderAdapter {
     // prefixes we estimate them locally (see trae-cache.ts). Then the
     // operator's cache mode decides whether a hit makes the whole input count
     // as cached.
-    return applyCacheMode(estimateTraeSessionCache(record, sessionId, messages));
+    return estimateTraeSessionCache(record, sessionId, messages);
   }
 
 }

package/src/providers/operations/account-error-classification.ts

@@ -458,6 +458,26 @@ function banWording(lower: string): boolean {
   );
 }
 
+/**
+ * Whether GitHub Copilot stated the account lacks a license — a ban-shaped
+ * verdict on the account, not a refreshable auth rejection.
+ *
+ * Observed live (2026-11-03): the health log showed
+ * `unauthorized: not licensed to use Copilot` and `forbidden` on
+ * `gpt-6-luna`. Copilot answers 401 for a bad credential and 403 for a
+ * license/entitlement refusal, so `forbidden`/`unauthorized` on this surface
+ * is the same verdict. No amount of waiting or refreshing changes it — the
+ * subscription cannot serve this credential.
+ */
+function copilotNotLicensed(lower: string): boolean {
+  return (
+    lower.includes("not licensed") ||
+    lower.includes("forbidden") ||
+    lower.includes("unauthorized") ||
+    lower.includes("license")
+  );
+}
+
 /**
  * Bounded to a day, matching `MAX_COOLDOWN_MS` in the failure policy: a stated
  * window longer than that is a monthly or plan-level limit, and parking an
@@ -1263,6 +1283,33 @@ const ACCOUNT_ERROR_RULES: readonly AccountErrorRule[] = [
         true,
       ),
   },
+  {
+    // GitHub Copilot answers a license/entitlement refusal with 403 and
+    // "not licensed to use Copilot" / "forbidden" / "unauthorized". That is a
+    // verdict on the account: the subscription cannot serve this credential,
+    // and no amount of waiting or refreshing changes it. Cooldown cycling
+    // (auth_invalidated + 5m backoff) kept a dead account in rotation where a
+    // client's retry budget burned sibling accounts — the same failure the
+    // buddy ban exists to prevent. Disable immediately. Must run before
+    // `credential-rejected`, which would claim the bare 403 as a refreshable
+    // auth rejection.
+    name: "github-copilot-not-licensed",
+    match: (s) =>
+      s.origin === "upstream" &&
+      s.providerId === "github" &&
+      copilotNotLicensed(s.lower),
+    decide: (s) =>
+      s.result(
+        "policy_blocked_banned",
+        "disabled",
+        0,
+        null,
+        s.reason("GitHub Copilot account not licensed"),
+        // A license refusal is evidence about the account even at provider
+        // scope, for the same reason a named revocation or a buddy ban is.
+        true,
+      ),
+  },
   {
     name: "credential-rejected",
     match: (s) =>
@@ -1471,7 +1518,7 @@ const ACCOUNT_ERROR_RULES: readonly AccountErrorRule[] = [
   },
   {
     name: "quota-exhausted",
-    match: (s) => s.quotaSignal,
+    match: (s) => s.origin === "upstream" && s.quotaSignal,
     decide: (s) => {
       // xAI Grok Build's free tier resets on a rolling window. Use a duration
       // stated by the provider when present; otherwise park for the conservative
@@ -1525,6 +1572,7 @@ const ACCOUNT_ERROR_RULES: readonly AccountErrorRule[] = [
     // moves to the next account and the flagged one returns almost at once.
     name: "inception-per-minute-limit",
     match: (s) =>
+      s.origin === "upstream" &&
       s.providerId === "inception" &&
       (s.statusCode === 429 ||
         s.providerCode === "rate_limit_reached" ||
@@ -1549,15 +1597,16 @@ const ACCOUNT_ERROR_RULES: readonly AccountErrorRule[] = [
   {
     name: "rate-limit",
     match: (s) =>
-      s.statusCode === 429 ||
-      s.providerCode === "rate_limit_exceeded" ||
-      s.lower.includes("rate_limit") ||
-      s.lower.includes("rate limit") ||
-      s.lower.includes("too many requests") ||
-      s.lower.includes("requests per minute") ||
-      s.lower.includes("tokens per minute") ||
-      s.lower.includes("tpm limit") ||
-      s.lower.includes("rpm limit"),
+      s.origin === "upstream" &&
+      (s.statusCode === 429 ||
+        s.providerCode === "rate_limit_exceeded" ||
+        s.lower.includes("rate_limit") ||
+        s.lower.includes("rate limit") ||
+        s.lower.includes("too many requests") ||
+        s.lower.includes("requests per minute") ||
+        s.lower.includes("tokens per minute") ||
+        s.lower.includes("tpm limit") ||
+        s.lower.includes("rpm limit")),
     decide: (s) => {
       const cooldownMs = s.statedCooldownMs ?? DEFAULT_RATE_LIMIT_COOLDOWN_MS();
       // Same per-account reasoning as quota above: the failing account (or
@@ -1576,13 +1625,14 @@ const ACCOUNT_ERROR_RULES: readonly AccountErrorRule[] = [
   {
     name: "model-capacity",
     match: (s) =>
-      s.statusCode === 503 ||
-      s.statusCode === 529 ||
-      s.providerCode === "model_capacity" ||
-      s.queuedUpstream ||
-      s.lower.includes("model overloaded") ||
-      s.lower.includes("capacity exceeded") ||
-      s.lower.includes("temporarily unavailable"),
+      s.origin === "upstream" &&
+      (s.statusCode === 503 ||
+        s.statusCode === 529 ||
+        s.providerCode === "model_capacity" ||
+        s.queuedUpstream ||
+        s.lower.includes("model overloaded") ||
+        s.lower.includes("capacity exceeded") ||
+        s.lower.includes("temporarily unavailable")),
     decide: (s) => {
       const cooldownMs = s.statedCooldownMs ?? MODEL_CAPACITY_COOLDOWN_MS();
       const modelScopedMutation = s.origin === "upstream" && s.modelId !== undefined;

package/src/providers/operations/byok-wire-profile.ts

@@ -92,12 +92,11 @@ const ENDPOINT_TAIL = /\/(?:v\d+\/)?(?:messages|chat\/completions|responses|comp
  * The root an operator's pasted URL really meant, plus the endpoint tail that
  * was removed.
  *
- * The suggestion is the bare **origin**, not the path left behind. For
- * `https://api.deepseek.com/anthropic/v1/messages` the tail `/v1/messages` is
- * only the last segment; `/anthropic` is part of that same endpoint, and
- * suggesting `https://api.deepseek.com/anthropic` would still derive the model
- * list at `…/anthropic/models` and 404 — the very failure this corrects. A URL
- * that is already a root comes back with an empty `stripped`.
+ * Only the **tail** is stripped. Any path before it belongs to the gateway
+ * root and survives, so `https://api.longcat.ai/anthropic/v1/messages`
+ * resolves to `https://api.longcat.ai/anthropic` (not the bare origin) — the
+ * `/anthropic` prefix is where LongCat actually serves the API. A URL that is
+ * already a root comes back with an empty `stripped`.
  */
 export function splitEndpointBaseUrl(baseUrl: string): { readonly baseUrl: string; readonly stripped: string } {
   const trimmed = baseUrl.replace(/\/+$/, "");
@@ -110,20 +109,22 @@ export function splitEndpointBaseUrl(baseUrl: string): { readonly baseUrl: strin
   const basePath = parsed.pathname.replace(/\/+$/, "");
   const match = ENDPOINT_TAIL.exec(basePath);
   if (match === null) return { baseUrl: trimmed, stripped: "" };
-  return { baseUrl: parsed.origin, stripped: basePath };
+  const keptPath = basePath.slice(0, match.index);
+  return { baseUrl: `${parsed.origin}${keptPath}`, stripped: basePath };
 }
 
 /**
  * Base URL an operator's model list lives under (`<base>/models`). A bare host
  * has no version segment, so it gets the `/v1` prefix; a base that already
  * carries a path (conventionally `/v1`) is used as-is. A pasted endpoint path
- * is stripped first, so `…/anthropic/v1/messages` discovers at `<host>/v1/models`
- * rather than one level below a per-request path.
+ * is stripped first, so `…/anthropic/v1/messages` discovers at
+ * `<origin>/anthropic/v1/models` — the gateway prefix before the endpoint tail
+ * belongs to the root and is preserved.
  */
 export function modelDiscoveryBaseUrl(baseUrl: string): string {
-  // A pasted endpoint is not a base at all, so its whole path is discarded and
-  // the list is looked for at `<origin>/v1`. A base that already IS a root —
-  // bare host, or a version/gateway prefix — keeps that path, because
+  // A pasted endpoint has its tail removed; whatever path came before it is a
+  // real gateway prefix and stays. A base that already IS a root — bare host,
+  // or a version/gateway prefix — keeps that path, because
   // `https://gateway.example/api/v1` legitimately serves its list there.
   const trimmed = baseUrl.replace(/\/+$/, "");
   let parsed: URL;
@@ -133,9 +134,12 @@ export function modelDiscoveryBaseUrl(baseUrl: string): string {
     return `${trimmed}/v1`;
   }
   const basePath = parsed.pathname.replace(/\/+$/, "");
-  const isPastedEndpoint = ENDPOINT_TAIL.test(basePath);
-  const listBase = isPastedEndpoint ? parsed.origin : `${parsed.origin}${basePath}`;
-  if (isPastedEndpoint || basePath === "" || basePath === "/") return `${listBase}/v1`;
+  const match = ENDPOINT_TAIL.exec(basePath);
+  const listBase =
+    match === null
+      ? `${parsed.origin}${basePath}`
+      : `${parsed.origin}${basePath.slice(0, match.index)}`;
+  if (match !== null || basePath === "" || basePath === "/") return `${listBase}/v1`;
   return listBase;
 }
 

package/src/providers/provider-contracts.ts

@@ -270,6 +270,13 @@ export interface ProviderDispatchTarget {
   readonly capabilities: Readonly<Record<string, boolean>>;
   /** Explicit wire dialect (from `models.dialect`), when set. Absent = resolver fallback. */
   readonly dialect?: string;
+  /**
+   * Transport override for a one-shot probe, when the operator explicitly
+   * asked for one. Live dispatch never sets this — it is a probe-only knob
+   * that lets a provider expose a surface the production transports do not
+   * use (Qoder's IDE surface is the only one that echoes strategy metadata).
+   */
+  readonly probe_surface?: "cosy" | "grpc" | "ide";
 }
 
 /** Provider adapter boundary: canonical request/events in, no public HTTP routes. */

package/src/providers/provider-usage.ts

@@ -1,4 +1,5 @@
 import type { UsageRecord } from "../protocol/canonical-model";
+import { resolveUsageInputMode } from "../config/usage";
 export interface OpenAiUsage {
   prompt_tokens: number;
   completion_tokens: number;
@@ -11,7 +12,6 @@ export interface OpenAiUsage {
   };
 }
 import { modelsDevCatalog } from "./discovery/models-dev-catalog";
-import { resolveCacheMode } from "../config/providers";
 
 /**
  * Extract cost multipliers from catalog model cost JSONB.
@@ -126,36 +126,6 @@ export function repriceUsage(
     : { ...usage, estimated_cost: estimatedCost };
 }
 
-/**
- * Simplified cache accounting: when the provider reported a cache hit, the
- * whole prompt counts as cached — request input ber-cache = cache-eligible →
- * input = cache. The cache-write volume is already inside the all-in input
- * total on cache-aware shapes, so it stays separate and is not double-counted
- * as a hit. A reported `0` or an absent report stay a cache miss. In `real`
- * mode the provider's reported split is kept as-is.
- *
- * Exported so the hand-built record producers (Cursor, Kiro) apply the same
- * rule as `normalizeUsage`.
- */
-export function applyCacheMode(usage: UsageRecord): UsageRecord {
-  if (resolveCacheMode() !== "simplified") return usage;
-  if (
-    typeof usage.cached_input_tokens === "number" &&
-    usage.cached_input_tokens > 0 &&
-    usage.input_tokens > 0
-  ) {
-    const writes =
-      typeof usage.cache_write_tokens === "number" ? Math.max(0, usage.cache_write_tokens) : 0;
-    const cached = Math.min(usage.input_tokens, Math.max(0, usage.input_tokens - writes));
-    return {
-      ...usage,
-      cached_input_tokens: cached,
-      uncached_input_tokens: 0,
-    };
-  }
-  return usage;
-}
-
 /**
  * Normalize provider-specific usage data into canonical UsageRecord.
  * Handles Anthropic (cache_read_input_tokens, cache_creation_input_tokens, output_tokens_details.thinking_tokens)
@@ -266,10 +236,21 @@ export function normalizeUsage(input: Record<string, unknown>): UsageRecord {
   const reportedTotal = typeof input.total_tokens === "number" ? input.total_tokens : null;
   const inputAlreadyIncludesCache =
     reportedTotal !== null && reportedTotal === input_tokens + output_tokens;
-  const hasAnthropicCacheShape = anthropic_cache_read !== null && !inputAlreadyIncludesCache;
+  // `inclusive` (default) folds cache into input so every provider reads alike:
+  // IN is always the whole prompt and CACHED its subset. Anthropic's raw shape
+  // is fresh-only with cache separate — and its `total_tokens` equals
+  // input+output by contract, so the `inputAlreadyIncludesCache` heuristic
+  // would otherwise mistake it for already-inclusive and never add the cache,
+  // under-reporting prompt by the entire cached span. `as-is` keeps the raw
+  // upstream semantics (and the legacy heuristic for already-inclusive bridges).
+  const accountInputInclusive = resolveUsageInputMode() === "inclusive";
+  const cacheIsSeparate = anthropic_cache_read !== null;
+  const shouldFoldCache = accountInputInclusive
+    ? cacheIsSeparate
+    : cacheIsSeparate && !inputAlreadyIncludesCache;
   let uncached_input_tokens: number | "unavailable" = "unavailable";
   if (typeof cached_input_tokens === "number") {
-    if (hasAnthropicCacheShape) {
+    if (shouldFoldCache) {
       uncached_input_tokens = input_tokens;
       input_tokens +=
         cached_input_tokens + (typeof cache_write_tokens === "number" ? cache_write_tokens : 0);
@@ -277,25 +258,10 @@ export function normalizeUsage(input: Record<string, unknown>): UsageRecord {
       uncached_input_tokens = Math.max(0, input_tokens - Math.min(input_tokens, cached_input_tokens));
       cached_input_tokens = Math.min(input_tokens, cached_input_tokens);
     }
-  } else if (hasAnthropicCacheShape && typeof cache_write_tokens === "number") {
+  } else if (shouldFoldCache && typeof cache_write_tokens === "number") {
     input_tokens += cache_write_tokens;
   }
 
-  // Simplified cache accounting: a reported hit makes the whole prompt count as
-  // cached — request input ber-cache = cache-eligible → input = cache. The
-  // cache-write volume is already inside the all-in input total on cache-aware
-  // shapes, so it stays separate and is not double-counted as a hit. Applied
-  // before pricing so the estimated cost reads the same simplified split as the
-  // record.
-  if (typeof cached_input_tokens === "number" && cached_input_tokens > 0 && input_tokens > 0) {
-    if (resolveCacheMode() === "simplified") {
-      const writes =
-        typeof cache_write_tokens === "number" ? Math.max(0, cache_write_tokens) : 0;
-      cached_input_tokens = Math.min(input_tokens, Math.max(0, input_tokens - writes));
-      uncached_input_tokens = 0;
-    }
-  }
-
   // Handle reasoning tokens: Anthropic and OpenAI both use output_tokens_details
   let reasoning_tokens: number | "unavailable" = "unavailable";
   const details: NonNullable<UsageRecord["details"]> = {};
@@ -333,6 +299,14 @@ export function normalizeUsage(input: Record<string, unknown>): UsageRecord {
     },
     rawCost,
   ) ?? null;
+  // Provider-billed credits: an explicit `credit_used` wins, then Qoder's
+  // `credits` (COSY terminal frame), then Tencent buddy-meter `credit`.
+  // Negative/NaN values are dropped, never clamped.
+  const creditRaw = input.credit_used ?? input.credits ?? input.credit;
+  const creditUsed =
+    typeof creditRaw === "number" && Number.isFinite(creditRaw) && creditRaw >= 0
+      ? { credit_used: creditRaw }
+      : {};
   return {
     input_tokens,
     cached_input_tokens,
@@ -341,12 +315,7 @@ export function normalizeUsage(input: Record<string, unknown>): UsageRecord {
     output_tokens,
     reasoning_tokens,
     estimated_cost,
-    // Tencent buddy-meter credit: top-level `credit` in the Chat usage frame
-    // (probed live on cb/deepseek-v4.1-flash-sg: 0 on a 29-token turn, 1.01
-    // on a 72k-token turn). Negative/NaN values are dropped, never clamped.
-    ...(typeof input.credit === "number" && Number.isFinite(input.credit) && input.credit >= 0
-      ? { credit_used: input.credit }
-      : {}),
+    ...creditUsed,
     ...(Object.keys(details).length > 0 ? { details } : {}),
   };
 }

package/src/security/abuse.ts

@@ -201,7 +201,7 @@ export class InMemoryIpAbuseStore implements IpAbuseStore {
       typeof windowOrOptions === "number" ? { windowMs: windowOrOptions } : windowOrOptions;
     this.windowMs = options.windowMs ?? 60_000;
     this.clock = options.clock ?? (() => Date.now());
-    // 10k keys is a few MB even at the default 240 RPM ring size; the previous
+    // 10k keys is a few MB even at the default 540 RPM ring size; the previous
     // 100k bound could reach ~190 MB, and a fan-out over unique source IPs is
     // the one input that can actually reach it.
     this.maxKeys = options.maxKeys ?? 10_000;
@@ -382,14 +382,14 @@ export class IpAbuseProtectionService {
   ) {
     if (!store)
       throw new Error("IpAbuseProtectionService requires a store — fail-closed, not no-op");
-    // 240 requests per 60 s window = 4 RPS/IP steady-state cap. Aligns
-    // with the documented default: unset env → 240 RPM per IP, not
+    // 540 requests per 60 s window = 9 RPS/IP steady-state cap. Aligns
+    // with the documented default: unset env → 540 RPM per IP, not
     // unlimited. Operators raise or lower via IP_RATE_MAX_PER_WINDOW.
-    this.maxRequestsPerWindow = opts.maxRequestsPerWindow ?? 240;
+    this.maxRequestsPerWindow = opts.maxRequestsPerWindow ?? 540;
     // A ban only makes sense once the limit was breached, so the threshold is
     // clamped above the cap: below it, escalation would be unreachable (the
     // count can never exceed `maxRequestsPerWindow` without being rejected).
-    this.banThreshold = Math.max(opts.banThreshold ?? 480, this.maxRequestsPerWindow + 1);
+    this.banThreshold = Math.max(opts.banThreshold ?? 1080, this.maxRequestsPerWindow + 1);
     this.banDurationMs = opts.banDurationMs ?? 60 * 60 * 1000;
   }
 

package/src/security/admission/service.ts

@@ -164,13 +164,20 @@ export class ApiKeyAdmissionService {
         const actual = usageTokens(usage);
         await this.store.reconcile(apiKeyId, estimatedTokens, actual, reservationId);
         finalized = true;
-        // Persist against the authenticating key (`snapshot.api_key_id`), not
-        // the admission identity. Share children share the parent's counter
-        // namespace for enforcement, but attribution must still land on the
-        // child row so recipient usage and sumChildrenConsumed stay correct.
+        // Persist the spend against BOTH the authenticating key and the family
+        // owner. The authenticating key (`snapshot.api_key_id`, the child for
+        // a share recipient) carries attribution so `sumChildrenConsumed` and
+        // recipient rows stay correct. The family owner (`admission_identity`,
+        // the template itself for a share child) is the live accumulator the
+        // console reads for total usage — without it the template column never
+        // moved and every figure depended on telemetry rows alone.
         if (this.persistLifetimeUsage) {
+          const ownerId = snapshot.admission_identity ?? snapshot.api_key_id;
           try {
             await this.persistLifetimeUsage({ apiKeyId: snapshot.api_key_id, delta: actual });
+            if (ownerId !== snapshot.api_key_id) {
+              await this.persistLifetimeUsage({ apiKeyId: ownerId, delta: actual });
+            }
           } catch {
             // Non-fatal: the transient counter already reflects reality; a
             // subsequent request will overwrite the row with the fresh count.

package/src/security/api-key-auth.ts

@@ -388,9 +388,11 @@ export async function resolveApiKeyAuthorization(
     tenant_id: row.tenantId,
     // Family quota / concurrency share one admission counter namespace so two
     // recipients cannot each burn a full lifetime/daily budget. In `per_key`
-    // concurrency mode the child is its own admission identity so its cap and
-    // counter are independent.
-    ...(parent && !perKeyConcurrency ? { admission_identity: parent.id } : {}),
+    // concurrency mode the child keeps its own cap and counter for
+    // *concurrency* only — token budgets (daily/monthly/lifetime) stay
+    // family-wide on the parent, so the admission identity is always the
+    // parent's.
+    ...(parent ? { admission_identity: parent.id } : {}),
     ...(policy.modelList ? { model_list: policy.modelList as string[] } : {}),
     model_access_mode: policy.modelAccessMode ?? "whitelist",
     ...(policy.clientRouterDenylist

package/src/transport/dispatch/attempt-finalize.ts

@@ -16,6 +16,7 @@ import { finalizeRequestTelemetry } from "../guards/error-lifecycle";
 import { debitCachedQuota, quotaLens } from "../../providers/quota/cache";
 import { BUDDY_PROVIDER_IDS } from "../../providers/provider-metadata";
 import { log } from "../../observability/logger";
+import { modelsDevCatalog } from "../../providers/discovery/models-dev-catalog";
 import {
   disablePoolForProxyHttpStatus,
   recordPoolDispatchOutcome,
@@ -711,6 +712,32 @@ async function debitBuddySpend(completion: AttemptCompletion): Promise<void> {
   }
 }
 
+/**
+ * Whether a completed attempt is a "degenerate stop": output far smaller than
+ * the model's ceiling, ended by an ordinary `stop` rather than `length`.
+ *
+ * This is the signature of a model truncating itself on a cached prefix — the
+ * pattern that surfaced as short, cut-off chat replies that the upstream still
+ * reported as a clean stop. It is measured so the operator can see how often
+ * it happens instead of eyeballing request detail.
+ */
+export function isDegenerateStop(
+  usage: UsageRecord | undefined,
+  outputLimit: number | undefined,
+): boolean {
+  if (usage === undefined) return false;
+  const output = usage.output_tokens;
+  const reasoning = typeof usage.reasoning_tokens === "number" ? usage.reasoning_tokens : 0;
+  const totalOutput = output + reasoning;
+  if (totalOutput === 0 || totalOutput > 512) return false;
+  // A model with no meaningful ceiling cannot be "far smaller than it can
+  // produce", so the flag is only meaningful when a ceiling exists.
+  if (!(typeof outputLimit === "number" && Number.isFinite(outputLimit) && outputLimit > 0)) {
+    return false;
+  }
+  return totalOutput <= Math.max(1, Math.floor(outputLimit / 10));
+}
+
 export async function completeAttempt(
   state: ProxyRequestState,
   completion: AttemptCompletion,
@@ -761,6 +788,15 @@ export async function completeAttempt(
     ...(completion.firstContentDeltaAtMs === undefined ? {} : { firstContentDeltaAtMs: completion.firstContentDeltaAtMs }),
     ...(completion.lastEventAtMs === undefined ? {} : { lastEventAtMs: completion.lastEventAtMs }),
     ...(completion.reportedModel === undefined ? {} : { reportedModel: completion.reportedModel }),
+    ...(completion.status === "completed" &&
+    isDegenerateStop(
+      completion.usage,
+      completion.providerId !== undefined && completion.modelId !== undefined
+        ? (modelsDevCatalog.resolve(completion.providerId, completion.modelId)?.outputLimit ?? undefined)
+        : undefined,
+    )
+      ? { degenerateStop: true }
+      : {}),
   };
   if (completion.terminal) state.completed = true;
   // Usage reconciliation is bookkeeping, and it is the last thing standing
@@ -785,27 +821,39 @@ export async function completeAttempt(
   // advisory: a failed report must never re-enter the retry path (a retry
   // would see `completed` and skip completion entirely), so it is swallowed.
   if (completion.status !== "cancelled" && !disableProxy) {
-    // DEPLOYMENT_DISABLED and similar infra errors are proxy pool failures,
-    // not account quota. Classify with scope pool so account stays healthy.
-    const msg = completion.error instanceof Error ? completion.error.message.toLowerCase() : "";
-    const isProxyDeploymentError = msg.includes("deployment_disabled") || (msg.includes("sin1::") && msg.includes("deployment"));
-    const evidence = isProxyDeploymentError
-      ? { scope: "pool" as const, origin: "network" as const }
-      : { ...classifyUpstreamFailure(completion.error) };
-    try {
-      await reportAttemptOutcome(completion.db, {
-        accountId: completion.accountId,
-        ...(completion.modelId === undefined ? {} : { modelId: completion.modelId }),
-        ...(completion.status === "failed"
-          ? {
-              error: completion.error,
-              evidence,
-            }
-          : {}),
-        ...(completion.snapshotService ? { snapshotService: completion.snapshotService } : {}),
-      });
-    } catch {
-      // Swallowed: health reporting is non-critical bookkeeping.
+    // Account health records only failures that are evidence about the
+    // provider's own account: upstream verdicts (quota, auth, model
+    // capacity, rate limits), or credential-scoped refusals from the
+    // upstream. Local rejections — API-key admission (`max_concurrent`,
+    // rpm/token budgets), routing capacity, pool selection, request
+    // preparation — are decisions this gateway made about its own limits;
+    // they say nothing about the account and must not cool it or write a
+    // phantom `logged -> cooldown` transition. Success always reports so a
+    // cooling account recovers.
+    const succeeded = completion.status === "completed";
+    const gatewayError = completion.error instanceof GatewayError ? completion.error : undefined;
+    const upstreamVerdict = gatewayError?.origin === "upstream";
+    const isProxyDeploymentError =
+      completion.error instanceof Error ? completion.error.message.toLowerCase().includes("deployment_disabled") || (completion.error.message.toLowerCase().includes("sin1::") && completion.error.message.toLowerCase().includes("deployment")) : false;
+    if (succeeded || isProxyDeploymentError || upstreamVerdict) {
+      const evidence = isProxyDeploymentError
+        ? { scope: "pool" as const, origin: "network" as const }
+        : { ...classifyUpstreamFailure(completion.error) };
+      try {
+        await reportAttemptOutcome(completion.db, {
+          accountId: completion.accountId,
+          ...(completion.modelId === undefined ? {} : { modelId: completion.modelId }),
+          ...(completion.status === "failed"
+            ? {
+                error: completion.error,
+                evidence,
+              }
+            : {}),
+          ...(completion.snapshotService ? { snapshotService: completion.snapshotService } : {}),
+        });
+      } catch {
+        // Swallowed: health reporting is non-critical bookkeeping.
+      }
     }
   }
   if (completion.networkPoolId && completion.status !== "cancelled") {

package/src/transport/dispatch/attempt-loop.ts

@@ -61,6 +61,27 @@ function comboCandidateKey(candidate: RouteCandidate): string {
   ].join(":");
 }
 
+/**
+ * True when the rejection is about the API key or the gateway's own policy,
+ * not about the provider account that was dialled.
+ *
+ * These are decided before the upstream is ever called, so every candidate in
+ * the plan fails identically; walking the rest of the list would just burn
+ * attempts and write phantom account-health rows (a local `capacity_exhausted`
+ * used to read as a provider `rate_limit_transient` cooldown).
+ */
+function isClientScopedRejection(error: unknown): boolean {
+  if (!(error instanceof GatewayError)) return false;
+  return (
+    error.code === "capacity_exhausted" ||
+    error.code === "tenant_capacity_exhausted" ||
+    error.code === "admission_unavailable" ||
+    error.code === "model_not_allowed" ||
+    error.code === "ambiguous_model" ||
+    error.code === "route_unavailable"
+  );
+}
+
 /**
  * Which combo member a candidate belongs to.
  *
@@ -402,6 +423,7 @@ export async function runAttemptLoop<TResult, TAdapter>(
       }
       const terminalAttempt =
         cancelled ||
+        isClientScopedRejection(error) ||
         !isRetryableFailure(error) ||
         (index === candidates.length - 1 && !poolScopedFailure);
       // Track only the most recent fired exchange; the array this replaced

package/src/transport/dispatch/upstream.ts

@@ -85,8 +85,10 @@ export function buildUpstreamDispatchContext(input: {
           const requestHeaders =
             init?.headers ?? (request instanceof Request ? request.headers : undefined);
           const headers = new Headers(requestHeaders);
-          // Provider identity is authoritative; route identity fills only a missing header.
-          if (!headers.has("user-agent")) headers.set("user-agent", userAgent);
+          // A route-level user agent is an explicit operator override: it
+          // replaces whatever identity the provider would otherwise send.
+          // Absent route identity leaves the provider's own header untouched.
+          if (userAgent) headers.set("user-agent", userAgent);
           return sourceFetch(request, { ...init, headers });
         }
       : sourceFetch;

package/src/transport/failure-policy.ts

@@ -920,7 +920,21 @@ export async function mapUpstreamHttpError(response: Response, providerId: strin
       ? { code: "context_length_exceeded" as const, status: 413, origin: "upstream" as const }
       : classifyUpstreamError(response.status, identifier);
   const extracted = extractUpstreamMessage(parsedBody ?? text);
-  const message = (extracted.length > 0 ? extracted : text.trim() || `Provider returned HTTP ${response.status}.`).slice(0, MAX_UPSTREAM_ERROR_BYTES).replace(/[\r\n]+/g, " ");
+  let message =
+    extracted.length > 0
+      ? extracted
+      : text.trim() || `Provider returned HTTP ${response.status}.`;
+  // A bare "Provider returned HTTP <5xx>" tells the operator nothing actionable;
+  // platform-unavailable fallbacks get the same human sign-off every other
+  // gateway error carries. The raw upstream body stays in `details.raw` for
+  // diagnostics either way.
+  if (
+    classification.code === "platform_unavailable" &&
+    message === `Provider returned HTTP ${response.status}.`
+  ) {
+    message = `The provider's service is temporarily unavailable (HTTP ${response.status}) (request {requestId}). Your request did not go through — wait a moment and try again. Hold tight ☁️`;
+  }
+  message = message.slice(0, MAX_UPSTREAM_ERROR_BYTES).replace(/[\r\n]+/g, " ");
   const headerWaitMs = parseUpstreamBackoff(response.headers);
   // A queue carries its own interval, which is the one the caller must honour:
   // it is what the upstream promised, while `Retry-After` may be absent or may

package/src/transport/guards/error-lifecycle.ts

@@ -312,6 +312,7 @@ function requestLogMetadata(
             cachedInputTokens: state.outcome.usage.cached_input_tokens,
             reasoningTokens: state.outcome.usage.reasoning_tokens,
             estimatedCost: state.outcome.usage.estimated_cost,
+            ...(state.outcome.degenerateStop ? { degenerateStop: true } : {}),
           },
         }
       : {}),
@@ -385,6 +386,9 @@ function requestTelemetryEvent(
     ...(state.payloadCaptureState === undefined
       ? {}
       : { payloadCaptureState: state.payloadCaptureState }),
+    // Degenerate stop (short output ended by an ordinary `stop`) — measured
+    // so a remote operator can spot the pattern in the request list.
+    ...(state.outcome?.degenerateStop ? { degenerateStop: true } : {}),
   };
 }