cartethyia 2.7.8 → 2.8.0

package/src/transport/surface/chat/encode.ts

@@ -262,11 +262,30 @@ export function jsonCompletion(
   };
   const terminal = events.findLast((event) => event.type === "terminal");
   if (terminal?.type === "terminal" && terminal.state === "failed") {
-    result.error = {
-      type: "server_error",
-      code: terminal.stop_reason ?? "provider_error",
-      message: "The upstream response failed",
+    const raw = isRecord(terminal.stop_details) ? terminal.stop_details : undefined;
+    const errorMessage =
+      typeof raw?.["message"] === "string" && raw["message"].length > 0
+        ? raw["message"]
+        : "The upstream response failed";
+    // A failed terminal returns an error response, not a completion with a
+    // finish_reason: the client must be able to tell the refusal/limit from a
+    // finished answer. OpenAI error responses carry no `choices`.
+    const errorResult: JsonObject = {
+      id,
+      object: "chat.completion",
+      created,
+      model,
+      usage,
+      error: {
+        type: "server_error",
+        code: terminal.stop_reason ?? "provider_error",
+        ...(typeof raw?.["status"] === "number" ? { status: raw["status"] } : {}),
+        message: errorMessage,
+      },
     };
+    const serviceTier = options.service_tier ?? options.serviceTier;
+    if (serviceTier !== undefined) errorResult.service_tier = serviceTier;
+    return errorResult;
   }
   const serviceTier = options.service_tier ?? options.serviceTier;
   if (serviceTier !== undefined) result.service_tier = serviceTier;
@@ -482,6 +501,30 @@ export class ChatStreamEncoder extends SurfaceStreamEncoder<CanonicalEvent, Json
     if (event.type === "terminal") {
       this.terminalState = event.state;
       this.terminalReason = finishReason(event.stop_reason);
+      // A failed terminal is a real failure: emit an error frame with the
+      // upstream's message instead of a `finish_reason: "error"` chunk. The
+      // client receives the reason (rate limit, quota, upstream error) rather
+      // than a bare "error" word it has to guess at. `stop_details` carries
+      // the failure details when the adapter set them; otherwise the stop
+      // reason is the only signal.
+      if (event.state === "failed") {
+        const raw = isRecord(event.stop_details) ? event.stop_details : undefined;
+        const message =
+          typeof raw?.["message"] === "string" && raw["message"].length > 0
+            ? raw["message"]
+            : "The upstream response failed";
+        this.emittedAny = true;
+        return [
+          {
+            error: {
+              type: "server_error",
+              code: event.stop_reason ?? "provider_error",
+              ...(typeof raw?.["status"] === "number" ? { status: raw["status"] } : {}),
+              message,
+            },
+          },
+        ];
+      }
       if (!this.cancelled && event.state !== "aborted" && event.usage)
         this.finalUsage = usageToChatWire(event.usage);
       const usage = this.cancelled || event.state === "aborted" ? null : this.finalUsage;

package/src/transport/surface/chat/parse.ts

@@ -2,7 +2,7 @@ import type { CanonicalMessage, ContentPart, GenerationControls } from "../../..
 import type { SurfaceInput } from "../adapters";
 import { isRecord } from "../../../protocol/codecs";
 import { asNumber } from "../../../shared/coerce";
-import { textPart, normalizeInlineFile } from "../content-parts";
+import { decodeWireBody, textPart, normalizeInlineFile } from "../content-parts";
 import { SERVICE_TIERS } from "../dialects";
 import { readNumber, readString } from "../../../protocol/codecs";
 import type { OpenAiUsage } from "../../../providers/provider-usage";
@@ -61,18 +61,8 @@ function isSurfaceInput(value: unknown): value is SurfaceInput {
   return isRecord(value) && "body" in value && "path" in value && typeof value.path === "string";
 }
 
-export function decodeBody(value: unknown): unknown {
-  if (value instanceof Uint8Array) {
-    return JSON.parse(new TextDecoder().decode(value)) as unknown;
-  }
-  if (typeof value === "string") {
-    return JSON.parse(value) as unknown;
-  }
-  return value;
-}
-
 export function requestBody(input: unknown): unknown {
-  return decodeBody(isSurfaceInput(input) ? input.body : input);
+  return decodeWireBody(isSurfaceInput(input) ? input.body : input);
 }
 
 function nonNegativeNumber(value: unknown): number | undefined {

package/src/transport/surface/completion.ts

@@ -1,11 +1,12 @@
 import { GatewayError } from "../../protocol/gateway-error";
 import type { CanonicalEvent, CanonicalRequest, GenerationControls } from "../../protocol/canonical-model";
-import type { ReasoningIntent } from "../../protocol/canonical-model";
+import { parseReasoningIntent } from "./dialects";
 import type { SurfaceAdapter, SurfaceInput, SurfaceOutput } from "./adapters";
 import { eventText } from "./adapters";
 import { isRecord } from "../../protocol/codecs";
 import { textPart } from "./content-parts";
 import { usageToChatWire, type OpenAiUsage } from "../../providers/provider-usage";
+import { completionFinishReason } from "../../protocol/stop-reason";
 import { TEXT_ENCODER } from "../../protocol/sse-frame";
 import { SurfaceStreamEncoder } from "./stream-frame";
 
@@ -35,24 +36,24 @@ function textPrompts(value: unknown): string[] {
   return value.flatMap((prompt) => (typeof prompt === "string" ? [prompt] : []));
 }
 
-function stopReason(events: readonly CanonicalEvent[]): string | null {
-  const terminal = [...events].reverse().find((event) => event.type === "terminal");
+/**
+ * Completion's wire stop reason from a terminal event (or `null` when no
+ * terminal has been seen). Both the sync adapter and the streaming encoder
+ * derive it through the shared canonical stop-reason mapping so the two
+ * halves of the completion surface cannot drift.
+ */
+function completionStopReason(terminal: CanonicalEvent | undefined): string | null {
   if (terminal?.type !== "terminal") return null;
-  if (terminal.stop_reason === "length") return "length";
-  if (terminal.stop_reason === "content_filter") return "content_filter";
-  if (terminal.state === "complete" || terminal.stop_reason === "stop") return "stop";
-  return null;
+  return completionFinishReason(terminal.stop_reason, terminal.state);
 }
 
 /**
  * Completion wire usage. Delegates to the chat builder (same wire family), so
  * completion responses carry cache/reasoning details, not just the three totals.
  */
-function usage(events: readonly CanonicalEvent[]): OpenAiUsage | undefined {
-  const terminal = [...events].reverse().find((event) => event.type === "terminal");
+function completionUsage(terminal: CanonicalEvent | undefined, usageEvent: CanonicalEvent | undefined): OpenAiUsage | undefined {
   const record = terminal?.type === "terminal" ? terminal.usage : undefined;
-  const event = [...events].reverse().find((item) => item.type === "usage");
-  const source = record ?? (event?.type === "usage" ? event.usage : undefined);
+  const source = record ?? (usageEvent?.type === "usage" ? usageEvent.usage : undefined);
   if (!source) return undefined;
   return usageToChatWire(source);
 }
@@ -103,6 +104,31 @@ export class CompletionStreamEncoder extends SurfaceStreamEncoder<CanonicalEvent
   push(event: CanonicalEvent): Record<string, unknown>[] {
     if (event.type === "terminal") this.terminalEvent = event;
     if (event.type === "usage") this.usageEvent = event;
+    if (event.type === "terminal" && event.state === "failed") {
+      // A failed terminal is a real failure: emit an error object instead of
+      // a completion with a null finish_reason. The client receives the
+      // upstream's message (rate limit, quota, error) rather than a silent
+      // empty completion.
+      const raw = isRecord(event.stop_details) ? event.stop_details : undefined;
+      const message =
+        typeof raw?.["message"] === "string" && raw["message"].length > 0
+          ? raw["message"]
+          : "The upstream response failed";
+      return [
+        {
+          id: this.id,
+          object: "text_completion",
+          created: this.created,
+          model: this.options.model ?? "",
+          error: {
+            type: "server_error",
+            code: event.stop_reason ?? "provider_error",
+            ...(typeof raw?.["status"] === "number" ? { status: raw["status"] } : {}),
+            message,
+          },
+        },
+      ];
+    }
     const text = eventText(event);
     if (text === undefined) {
       if (event.type !== "terminal") return [];
@@ -116,22 +142,12 @@ export class CompletionStreamEncoder extends SurfaceStreamEncoder<CanonicalEvent
 
   /** The wire stop reason from the terminal event seen so far. */
   private stopReason(): string | null {
-    const terminal = this.terminalEvent;
-    if (terminal?.type !== "terminal") return null;
-    if (terminal.stop_reason === "length") return "length";
-    if (terminal.stop_reason === "content_filter") return "content_filter";
-    if (terminal.state === "complete" || terminal.stop_reason === "stop") return "stop";
-    return null;
+    return completionStopReason(this.terminalEvent);
   }
 
   /** The wire usage from the terminal event, else the last usage event. */
   private usage(): OpenAiUsage | undefined {
-    const terminal = this.terminalEvent;
-    const record = terminal?.type === "terminal" ? terminal.usage : undefined;
-    const event = this.usageEvent;
-    const source = record ?? (event?.type === "usage" ? event.usage : undefined);
-    if (!source) return undefined;
-    return usageToChatWire(source);
+    return completionUsage(this.terminalEvent, this.usageEvent);
   }
 
   finish(): Record<string, unknown>[] {
@@ -180,14 +196,7 @@ class CompletionAdapter implements SurfaceAdapter {
     if (typeof value.logprobs === "boolean") controls.logprobs = value.logprobs;
     if (typeof value.stop === "string" || (Array.isArray(value.stop) && value.stop.every((item) => typeof item === "string")))
       controls.stop = value.stop as string | readonly string[];
-    const requestedReasoning = value.reasoning_effort ?? value.reasoning_level;
-    const reasoningEfforts = new Set<NonNullable<ReasoningIntent["effort"]>>([
-      "none", "minimal", "low", "medium", "high", "xhigh", "max",
-    ]);
-    const reasoning =
-      typeof requestedReasoning === "string" && reasoningEfforts.has(requestedReasoning as NonNullable<ReasoningIntent["effort"]>)
-        ? { effort: requestedReasoning as NonNullable<ReasoningIntent["effort"]> }
-        : undefined;
+    const reasoning = parseReasoningIntent(value);
     const cacheKey = value.prompt_cache_key;
     const cacheHint =
       (typeof cacheKey === "string" && cacheKey.length > 0) || value.cache_control === "auto"
@@ -211,8 +220,10 @@ class CompletionAdapter implements SurfaceAdapter {
 
   encodeOutput(events: readonly CanonicalEvent[], options: CompletionEncodingOptions = {}): SurfaceOutput {
     const model = modelFor(events, options);
-    const reason = stopReason(events);
-    const responseUsage = usage(events);
+    const terminal = [...events].reverse().find((event) => event.type === "terminal");
+    const usageEvent = [...events].reverse().find((event) => event.type === "usage");
+    const reason = completionStopReason(terminal);
+    const responseUsage = completionUsage(terminal, usageEvent);
     const response = {
       id: options.response_id ?? `cmpl-${crypto.randomUUID()}`,
       object: "text_completion",

package/src/transport/surface/content-parts.ts

@@ -6,6 +6,27 @@ export function textPart(text: string): ContentPart {
   return { kind: "text", text };
 }
 
+/**
+ * Decodes a wire body value into its parsed JSON form.
+ *
+ * Every surface parser receives bodies in the same three shapes — raw bytes,
+ * an already-decoded string, or an object handed in directly (surface
+ * detection and tests pass objects without a wire round-trip). Bytes and
+ * strings are parsed as JSON; anything else passes through unchanged. The
+ * `SyntaxError` thrown on malformed JSON propagates to the same
+ * error-normalization path on every surface, so one shared decoder keeps the
+ * four surfaces' wire-read convention identical.
+ */
+export function decodeWireBody(value: unknown): unknown {
+  if (value instanceof Uint8Array) {
+    return JSON.parse(new TextDecoder().decode(value)) as unknown;
+  }
+  if (typeof value === "string") {
+    return JSON.parse(value) as unknown;
+  }
+  return value;
+}
+
 /**
  * Fields a raw file/document block may carry, normalized across every origin
  * vocabulary (OpenAI Chat `file`, OpenAI Responses `input_file`, Anthropic

package/src/transport/surface/messages/adapter.ts

@@ -17,6 +17,7 @@ import {
 import { CANONICAL_REASONING_EFFORTS, parseReasoningIntent, parseToolChoice } from "../dialects";
 import { groupedBlocks, startModel, stopData } from "./encode";
 import { finiteNumber, stringValue } from "../../../protocol/codecs";
+import { ANTHROPIC_DEFAULT_MAX_TOKENS } from "../../../protocol/request/messages";
 import { usageToMessagesWire } from "../../../providers/provider-usage";
 
 export class MessagesAdapter implements SurfaceAdapter {
@@ -39,7 +40,7 @@ export class MessagesAdapter implements SurfaceAdapter {
     const headers = options.headers ?? supplied.headers;
     if (!stringValue(body.model)) throw new Error("Messages request requires model");
     if (!Array.isArray(body.messages)) throw new Error("Messages request requires messages[]");
-    const maxTokens = body.max_tokens ?? body.maxTokens;
+    const maxTokens = body.max_tokens ?? body.maxTokens ?? ANTHROPIC_DEFAULT_MAX_TOKENS;
     if (!finiteNumber(maxTokens) || !Number.isInteger(maxTokens) || maxTokens <= 0)
       throw new Error("Messages request requires positive integer max_tokens");
     const declaredSystem = systemBlocks(body.system);
@@ -152,10 +153,16 @@ export class MessagesAdapter implements SurfaceAdapter {
         : data.reason;
     const usage = usageToMessagesWire(data.usage);
     if (data.failed) {
+      const errorEvent = [...events]
+        .reverse()
+        .find((event): event is Extract<CanonicalEvent, { type: "error" }> => event.type === "error");
       return {
         id: responseId,
         type: "error",
-        error: { type: "server_error", message: "The upstream response failed" },
+        error: {
+          type: "server_error",
+          message: errorEvent?.message ?? "The upstream response failed",
+        },
       };
     }
     return {

package/src/transport/surface/messages/encode.ts

@@ -207,11 +207,14 @@ export function groupedBlocks(events: readonly CanonicalEvent[]): {
           previousReasoningText,
           nextText,
         );
-        if (reasoningSummaryHasBoundary(previousReasoningIdentity, identity)) {
+        // A thinking block splits only on a strong boundary (a real paragraph
+        // break). Copilot streams one thought as many items; treating every
+        // identity change as a new block painted dozens of tiny thinking blocks.
+        if (reasoningSummaryHasBoundary(previousReasoningIdentity, identity) && separator === "\n\n") {
           next.thinking = `${separator}${nextText}`;
           blocks.push(next);
         } else {
-          previous.thinking = `${String(previous.thinking ?? "")}${nextText}`;
+          previous.thinking = `${String(previous.thinking ?? "")}${separator}${nextText}`;
         }
         previousReasoningIdentity = identity;
         previousReasoningText = nextText;
@@ -264,7 +267,12 @@ export function stopData(events: readonly CanonicalEvent[]): {
   const usageEvent = [...events]
     .reverse()
     .find((event): event is Extract<CanonicalEvent, { type: "usage" }> => event.type === "usage");
-  const failed = terminal?.state === "failed";
+  // A failed terminal — `failed`, or `aborted` (upstream stream error) —
+  // marks the response as failed. An explicit canonical `error` event before
+  // the terminal also fails it: the upstream declared a failure even when the
+  // terminal state alone does not.
+  const hasErrorEvent = events.some((event) => event.type === "error");
+  const failed = terminal?.state === "failed" || (terminal?.state === "aborted" && hasErrorEvent);
   let reason: string | null;
   if (terminal?.stop_reason !== undefined) reason = mapStopReason(terminal.stop_reason);
   else reason = terminal?.state === "complete" ? "end_turn" : null;

package/src/transport/surface/messages/parse.ts

@@ -50,7 +50,8 @@ export interface MessagesStreamEvent extends MessagesWireObject {
     | "content_block_delta"
     | "content_block_stop"
     | "message_delta"
-    | "message_stop";
+    | "message_stop"
+    | "error";
 }
 
 function contentArray(value: unknown, label: string): unknown[] {

package/src/transport/surface/messages/stream.ts

@@ -1,6 +1,5 @@
 import type { CanonicalEvent, UsageRecord } from "../../../protocol/canonical-model";
 import {
-  reasoningSummaryHasBoundary,
   reasoningSummaryIdentity,
   reasoningSummarySeparator,
   type ReasoningSummaryIdentity,
@@ -62,6 +61,7 @@ export class MessagesStreamEncoder extends SurfaceStreamEncoder<CanonicalEvent,
   private droppedUnnamedToolCalls = 0;
   private usage: UsageRecord | undefined;
   private failed = false;
+  private errorMessage: string | undefined;
   private stopReason: string | null = null;
   private readonly responseId: string;
   private readonly model: string;
@@ -199,6 +199,7 @@ export class MessagesStreamEncoder extends SurfaceStreamEncoder<CanonicalEvent,
       // inevitable terminal push throw, producing a second error frame
       // after message_stop (which Anthropic never sends).
       this.failed = true;
+      if (this.errorMessage === undefined) this.errorMessage = event.message;
       return out;
     }
     if (event.type === "content_delta") {
@@ -247,11 +248,7 @@ export class MessagesStreamEncoder extends SurfaceStreamEncoder<CanonicalEvent,
                 summary,
               )
             : "";
-        if (
-          blockType === "thinking" &&
-          reasoningSummaryHasBoundary(this.openReasoningIdentity, identity) &&
-          this.openBlock?.type === blockType
-        ) {
+        if (blockType === "thinking" && separator === "\n\n" && this.openBlock?.type === blockType) {
           out.push({ type: "content_block_stop", index: this.openBlock.index });
           this.openBlock = undefined;
         }
@@ -401,18 +398,25 @@ export class MessagesStreamEncoder extends SurfaceStreamEncoder<CanonicalEvent,
       resetToolCallTracker(this.tools);
       const finalUsage = usageToMessagesWire(this.usage);
       if (this.failed) {
-        out.push({
-          type: "message_delta",
-          delta: { stop_reason: null, stop_sequence: null },
-          usage: finalUsage,
-        });
-      } else {
-        out.push({
-          type: "message_delta",
-          delta: { stop_reason: this.stopReason, stop_sequence: null },
-          usage: finalUsage,
-        });
+        // The stream is closing on an upstream failure, not a normal end. A
+        // `message_stop` here would hide the failure from the client (it
+        // reads a clean stop), so emit the error event instead — matching the
+        // semantic the non-streaming encoder uses for `failed` terminals.
+        return [
+          {
+            type: "error",
+            error: {
+              type: "server_error",
+              message: this.errorMessage ?? "The upstream response failed",
+            },
+          },
+        ];
       }
+      out.push({
+        type: "message_delta",
+        delta: { stop_reason: this.stopReason, stop_sequence: null },
+        usage: finalUsage,
+      });
       out.push({ type: "message_stop" });
       this.finished = true;
       return out;
@@ -446,6 +450,18 @@ export class MessagesStreamEncoder extends SurfaceStreamEncoder<CanonicalEvent,
       ];
     }
     if (this.finished) return [];
+    if (this.failed) {
+      this.finished = true;
+      return [
+        {
+          type: "error",
+          error: {
+            type: "server_error",
+            message: this.errorMessage ?? "The upstream response failed",
+          },
+        },
+      ];
+    }
     const out: MessagesStreamEvent[] = [];
     out.push(...this.closeOpenBlock());
     out.push(...this.flushToolCalls(true));

package/src/transport/surface/responses/encode.ts

@@ -54,6 +54,7 @@ export class ResponsesEventEncoder extends SurfaceStreamEncoder<CanonicalEvent,
   private inputSequence = -Infinity;
   private started = false;
   private terminal = false;
+  private hasError = false;
   private responseModel: string | undefined;
   private systemFingerprint: string | undefined;
   private usage: UsageRecord | undefined;
@@ -624,21 +625,33 @@ export class ResponsesEventEncoder extends SurfaceStreamEncoder<CanonicalEvent,
     state: "complete" | "failed" | "aborted",
     stopReason?: CanonicalStopReason,
     usage?: UsageRecord,
+    stopDetails?: unknown,
   ): ResponsesWireEvent[] {
     if (this.terminal)
       throw new ResponsesLifecycleError("Responses stream has more than one terminal event");
     if (usage !== undefined) this.usage = usage;
     const events = this.closeAll();
-    const status = terminalResponseStatus(state);
+    // An upstream error event before an `aborted` terminal is a failure, not
+    // an incomplete response: the client must see `response.failed` rather
+    // than `response.incomplete` (the same distinction the Messages encoder
+    // applies in `stopData`).
+    const effectiveState = state === "aborted" && this.hasError ? "failed" : state;
+    const status = terminalResponseStatus(effectiveState);
     const response = this.responseObject(status.status);
     const incompleteReason =
       status.status === "incomplete" ? incompleteResponseReason(stopReason) : undefined;
     if (incompleteReason !== undefined) response.incomplete_details = { reason: incompleteReason };
-    if (state === "failed") {
+    if (effectiveState === "failed") {
+      const raw = isRecord(stopDetails) ? stopDetails : undefined;
+      const message =
+        typeof raw?.["message"] === "string" && raw["message"].length > 0
+          ? raw["message"]
+          : "The upstream response failed";
       response.error = {
         type: "server_error",
         code: stopReason ?? "provider_error",
-        message: "The upstream response failed",
+        ...(typeof raw?.["status"] === "number" ? { status: raw["status"] } : {}),
+        message,
       };
     }
     events.push(this.emit(status.event, { response }));
@@ -652,8 +665,19 @@ export class ResponsesEventEncoder extends SurfaceStreamEncoder<CanonicalEvent,
         `Canonical sequence_number must increase monotonically: ${event.sequence_number}`,
       );
     this.inputSequence = event.sequence_number;
-    if (this.terminal)
+    if (this.terminal) {
+      // `usage` after terminal is legitimate: several upstreams stream it in
+      // a trailing chunk after the finish-reason chunk (Qoder gRPC does). The
+      // canonical contract allows it, and dropping it here would either throw a
+      // false `invalid_lifecycle` (recording a failed attempt for a response
+      // the client already received complete) or lose the usage. Any *other*
+      // event after terminal is a genuine lifecycle violation.
+      if (event.type === "usage") {
+        this.usage = event.usage;
+        return [];
+      }
       throw new ResponsesLifecycleError("Canonical event arrived after terminal Responses event");
+    }
     if (event.type === "response_start") {
       if (event.system_fingerprint !== undefined)
         this.systemFingerprint = event.system_fingerprint;
@@ -688,12 +712,16 @@ export class ResponsesEventEncoder extends SurfaceStreamEncoder<CanonicalEvent,
       return events;
     }
     if (event.type === "keepalive") return events.concat(this.emit("response.keepalive"));
-    if (event.type === "error")
+    if (event.type === "error") {
+      this.hasError = true;
       return events.concat(
         this.emit("response.error", { category: event.category, message: event.message }),
       );
+    }
     if (event.type === "terminal")
-      return events.concat(this.processTerminal(event.state, event.stop_reason, event.usage));
+      return events.concat(
+        this.processTerminal(event.state, event.stop_reason, event.usage, event.stop_details),
+      );
     throw new ResponsesLifecycleError(`Unsupported canonical event type: ${event.type}`);
   }
 

package/src/transport/surface/responses/parse.ts

@@ -1,6 +1,6 @@
 import type { CanonicalMessage, CanonicalRequest, ContentPart, GenerationControls, ToolDefinition } from "../../../protocol/canonical-model";
 import { isRecord } from "../../../protocol/codecs";
-import { textPart, normalizeInlineFile } from "../content-parts";
+import { decodeWireBody, textPart, normalizeInlineFile } from "../content-parts";
 import {
   isServiceTier,
   parseReasoningIntent,
@@ -66,23 +66,15 @@ export function hasOwn(value: Record<string, unknown>, key: string): boolean {
   return Object.hasOwn(value, key);
 }
 
-function parseJsonBody(value: unknown): unknown {
-  if (value instanceof Uint8Array) {
-    return JSON.parse(new TextDecoder().decode(value)) as unknown;
-  }
-  if (typeof value === "string") return JSON.parse(value) as unknown;
-  return value;
-}
-
 export function unwrapBody(input: unknown): unknown {
   if (
     isRecord(input) &&
     hasOwn(input, "body") &&
     (hasOwn(input, "headers") || hasOwn(input, "path"))
   ) {
-    return parseJsonBody(input.body);
+    return decodeWireBody(input.body);
   }
-  return parseJsonBody(input);
+  return decodeWireBody(input);
 }
 
 /**

package/src/workers/daily-checkin.ts

@@ -4,7 +4,7 @@
 // inside the account loop (B-02) so the boot graph stays clean — this runs
 // as a ride-along with the quota sweep, not at startup.
 //
-// WorkBuddy/CodeBuddy grant a free credit package once per calendar day. This
+// CodeBuddy grants a free credit package once per calendar day. This
 // claims it for every stored account and logs one line per account, so an
 // operator can confirm each account got its daily login credit.
 //

package/src/workers/quota-refresh-sweep.ts

@@ -265,7 +265,7 @@ function quotaPhrase(outcome: QuotaRefreshOutcome): string {
  * nothing to report.
  *
  * Only providers that expose the check-in route appear here at all: the sweep
- * skips the rest, and `daily unsupported` on every non-WorkBuddy account is
+ * skips the rest, and `daily unsupported` on every non-CodeBuddy account is
  * pure noise. The routine "nothing to claim today" states collapse to one
  * short phrase so the line stays scannable; only a real grant or a failure
  * carries detail.

package/src/workers/scheduler.ts

@@ -28,6 +28,19 @@ export interface ScheduledTask {
    * and foreground sharing one tick.
    */
   readonly deferWhenBusy?: boolean;
+  /**
+   * True when this task must NOT be gated by the process-wide `busy` latch
+   * (one maintenance task at a time per process).
+   *
+   * The gate exists so sweeps that contend for the same rows/files never run
+   * at once. A task that only does independent network reads (client-version
+   * discovery) has nothing to contend over — and a heavy sweep that runs
+   * nearly continuously (quota-refresh on a large account set) otherwise
+   * starves every rarer task on the same gate: a 30-minute monitor skipped at
+   * its single initial tick is not retried for another 30 minutes. Opt-in;
+   * side-effecting sweeps must not set it.
+   */
+  readonly skipGate?: boolean;
   /**
    * Whether this task's work is SHARED across the fleet, so only one process
    * should run it per interval.
@@ -321,7 +334,10 @@ export class ScheduledTaskRegistry {
     // handles, and the same single core. Queuing the skipped tick would mean
     // every task fires at once once the blocker finishes, which is the burst
     // this rule exists to prevent.
-    if (this.busy !== undefined) return;
+    // `skipGate` tasks (independent network reads) are exempt: they have no
+    // shared state to contend over, and gating them starves rare tasks when a
+    // heavy sweep runs nearly continuously.
+    if (this.busy !== undefined && task.skipGate !== true) return;
     // G-03: a foreground-deferring task waits out foreground activity (bounded)
     // before latching the shared gate. The gate is NOT latched during the wait,
     // so the re-check below is required: a different task can claim the gate
@@ -329,9 +345,9 @@ export class ScheduledTaskRegistry {
     if (task.deferWhenBusy === true) {
       await deferForForeground(this.now, (ms) => new Promise((r) => setTimeout(r, ms)));
     }
-    if (this.running.has(task.name) || this.busy !== undefined) return;
+    if (this.running.has(task.name) || (this.busy !== undefined && task.skipGate !== true)) return;
     this.running.add(task.name);
-    this.busy = task.name;
+    if (task.skipGate !== true) this.busy = task.name;
     let lease: Awaited<ReturnType<MaintenanceLeaseStore["tryAcquire"]>> | undefined;
     try {
       // The gate above is latched before this await so a concurrent tick cannot
@@ -409,7 +425,9 @@ export class ScheduledTaskRegistry {
     } finally {
       this.inFlight.delete(done);
       this.running.delete(task.name);
-      this.busy = undefined;
+      // Only clear the shared gate if THIS task held it — a `skipGate` task
+      // never latches it and must not release another task's latch.
+      if (this.busy === task.name) this.busy = undefined;
     }
   }
 }

package/dist/dashboard/assets/BannedPage-DeIbIiBU.js

@@ -1 +0,0 @@
-import{t as e}from"./jsx-runtime-CXUMngI_.js";import{at as t,t as n}from"./entry-Ca7LSCet.js";var r=e();function i(){return(0,r.jsx)(n,{title:`Access Restricted`,description:`Security policy lockout or untrusted origin address`,icon:(0,r.jsx)(t,{size:24}),logoClassName:`bg-red bg-none`,children:(0,r.jsxs)(`div`,{className:`rounded-panel border border-inner-border bg-surface-2 p-7 text-caption leading-relaxed text-text-secondary`,children:[(0,r.jsx)(`strong`,{className:`block text-text-primary mb-2`,children:`HTTP 403 Forbidden`}),`This client IP has been temporarily locked out due to repeated invalid credential attempts or untrusted proxy headers.`]})})}export{i as default};