cartethyia 2.7.9 → 2.8.1

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

@@ -153,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 }));
@@ -699,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/buddy-growth-tasks.ts

@@ -29,7 +29,7 @@ import { sleep } from "../shared/sleep";
 import type {
   BuddyGrowthCall,
   BuddyGrowthResult,
-} from "../providers/integrations/buddy/buddy-growth-shared";
+} from "../providers/integrations/buddy/lifecycle";
 import { withDirectFallback } from "./daily-checkin";
 import { providerBaseUrl, BUDDY_PROVIDER_IDS } from "../providers/provider-metadata";
 import type { FetchLike } from "../providers/quota/quota-contracts";
@@ -185,7 +185,7 @@ async function forAccount(
   // The buddy-oauth-shared graph is lazy-loaded: the uid decoder runs once per
   // pass, and only for accounts whose credential carries a JWT (B-02).
   const { buddyAccountUid } = await import(
-    "../providers/integrations/buddy/buddy-oauth-shared"
+    "../providers/integrations/buddy/account"
   );
   const call: BuddyGrowthCall = {
     baseUrl: providerBaseUrl(account.providerId) ?? "",
@@ -264,7 +264,7 @@ export async function buddyStreakTask(deps: BuddyTaskDeps) {
   // The buddy-growth-shared graph is lazy-loaded: this task only runs once a
   // day, and must not pull the integration into the boot graph (B-02).
   const { useBuddyMakeupCard } = await import(
-    "../providers/integrations/buddy/buddy-growth-shared"
+    "../providers/integrations/buddy/lifecycle"
   );
   return runTask(deps, "buddy-streak", (call) => useBuddyMakeupCard(call));
 }
@@ -283,7 +283,7 @@ export async function buddyAdoptTask(deps: BuddyTaskDeps) {
     agreeBuddyAgreement,
     readBuddyFirstTask,
     readBuddyInfo,
-  } = await import("../providers/integrations/buddy/buddy-growth-shared");
+  } = await import("../providers/integrations/buddy/lifecycle");
   return runTask(deps, "buddy-adopt", async (call) => {
     const info = await readBuddyInfo(call);
     if (info === null || info.hasBuddy) return null;
@@ -312,7 +312,7 @@ export async function buddyActivityReportTask(deps: BuddyTaskDeps) {
   // The buddy-checkin graph is lazy-loaded: this task only runs once a day,
   // and must not pull the integration into the boot graph (B-02).
   const { fetchBuddyActivityReport } = await import(
-    "../providers/integrations/buddy/buddy-checkin"
+    "../providers/integrations/buddy/lifecycle"
   );
   return runTask(deps, "buddy-activity-report", async (call) => {
     if (call.uid === undefined) {
@@ -352,13 +352,13 @@ export async function syncBuddyUsage(deps: BuddyTaskDeps): Promise<number> {
   // six-hourly cadence, and must not pull the integrations into the boot
   // graph (B-02).
   const { fetchBuddyRequestUsage } = await import(
-    "../providers/integrations/buddy/buddy-usage-shared"
+    "../providers/integrations/buddy/account"
   );
   const { saveBuddyUsageSnapshots } = await import(
-    "../providers/integrations/buddy/buddy-usage-store"
+    "../providers/integrations/buddy/account"
   );
   const { buddyAccountUid } = await import(
-    "../providers/integrations/buddy/buddy-oauth-shared"
+    "../providers/integrations/buddy/account"
   );
   const startedAt = Date.now();
   const budgetMs = deps.budgetMs;

package/src/workers/daily-checkin.ts

@@ -20,14 +20,14 @@
 //
 
 import { and, eq, inArray } from "drizzle-orm";
-import type { ValidatedFetch } from "../network/outbound-fetch";
-import type { ValidatedNetworkBindingFactory } from "../network/pool/resolver";
+import type { ValidatedFetch } from "../network/egress/fetch";
+import type { ValidatedNetworkBindingFactory } from "../network/egress/factory";
 import type { RedisClient } from "../persistence/redis";
 import type { CartethyiaDatabase } from "../persistence/db-handle";
 import { dailyCheckinLedger, networkPools } from "../persistence/schema";
 import type { ProviderId } from "../providers/provider-contracts";
 import { log } from "../observability/logger";
-import type { DailyCheckinResult } from "../providers/integrations/buddy/buddy-checkin";
+import type { DailyCheckinResult } from "../providers/integrations/buddy/lifecycle";
 import { BUDDY_PROVIDER_IDS } from "../providers/provider-metadata";
 
 export type { DailyCheckinResult };
@@ -486,7 +486,7 @@ export async function attemptDailyGrowthPass(args: {
       });
     } else {
       const { fetchDailyCheckin } = await import(
-        "../providers/integrations/buddy/buddy-checkin"
+        "../providers/integrations/buddy/lifecycle"
       );
       checkin = await fetchDailyCheckin({
         providerId,

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

@@ -26,7 +26,7 @@ import {
   type CachedQuotaEntry,
 } from "../providers/quota/cache";
 import { runSweep } from "./sweep-runner";
-import type { ValidatedFetch } from "../network/outbound-fetch";
+import type { ValidatedFetch } from "../network/egress/fetch";
 import type { ProviderId } from "../providers/provider-contracts";
 import {
   attemptDailyGrowthPass,

package/src/workers/zcode-gift-claim.ts

@@ -5,7 +5,7 @@ import type { CartethyiaDatabase } from "../persistence/db-handle";
 import type { RedisClient } from "../persistence/redis";
 import { providerAccounts } from "../persistence/schema";
 import type { ProviderId } from "../providers/provider-contracts";
-import type { ValidatedFetch } from "../network/outbound-fetch";
+import type { ValidatedFetch } from "../network/egress/fetch";
 import { invalidateQuotaCacheForAccount } from "../providers/quota/cache";
 import { claimZcodeGifts } from "../providers/integrations/zcode-start-plan/gifts";
 import { ZCODE_START_PLAN_PROVIDER_ID } from "../providers/integrations/zcode-start-plan/provider";