cartethyia 2.7.0 → 2.7.2

package/src/providers/integrations/opencode/prompt.ts

@@ -0,0 +1,111 @@
+/**
+ * The minimal system prompt injected into free-tier OpenCode payloads.
+ *
+ * The full CLI prompt is unnecessary: live trimming showed the free-tier gate
+ * accepts any system content that carries the `<env>` block with a
+ * `Working directory:` line — even a ~30-character placeholder passes. The
+ * marker line below is kept so `carriesOpenCodePrompt` can detect an already-
+ * injected prompt and avoid duplication.
+ */
+
+/** The marker that identifies a body already carrying the injected prompt. */
+export const OPENCODE_PROMPT_MARKER = "You are an interactive coding agent that helps users";
+
+/**
+ * Assembles the minimal prompt: the marker line plus the `<env>` block the
+ * gate requires. No model identity, no skills, no style rules — the model is
+ * a gateway proxy and should not claim an upstream identity.
+ */
+export function opencodeSystemPrompt(): string {
+  const directory = process.cwd().trim() || "/workspace";
+  return `You are an interactive coding agent that helps users with software engineering tasks.\n<env>  Working directory: ${directory}</env>`;
+}
+
+/** Flattens a system/instruction value into its text fragments. */
+export function textFragments(value: unknown): string[] {
+  if (typeof value === "string") {
+    return value.trim() === "" ? [] : [value];
+  }
+  if (Array.isArray(value)) return value.flatMap((item) => textFragments(item));
+  if (typeof value === "object" && value !== null) {
+    const record = value as Record<string, unknown>;
+    if (typeof record["text"] === "string") return textFragments(record["text"]);
+    if (record["content"] !== undefined) return textFragments(record["content"]);
+  }
+  return [];
+}
+
+/** Whether any text inside `value` already contains the injected prompt marker. */
+export function carriesOpenCodePrompt(value: unknown): boolean {
+  return textFragments(value).some((part) => part.includes(OPENCODE_PROMPT_MARKER));
+}
+
+/**
+ * Appends the `<env>` block to the first existing system/developer message
+ * instead of prepending a new leading system message. The tool's own system
+ * content (Claude Code, DSH, …) keeps its place; the gate-required env block
+ * is tacked on at the end of it.
+ */
+export function injectChatPrompt(payload: Record<string, unknown>, prompt: string): boolean {
+  const messages = payload["messages"];
+  if (!Array.isArray(messages)) return false;
+  const firstSystem = messages.findIndex((raw) => {
+    if (typeof raw !== "object" || raw === null) return false;
+    const role = (raw as Record<string, unknown>)["role"];
+    return role === "system" || role === "developer";
+  });
+  if (firstSystem === -1) {
+    payload["messages"] = [{ role: "system", content: prompt }, ...messages];
+    return true;
+  }
+  const message = messages[firstSystem] as Record<string, unknown>;
+  if (carriesOpenCodePrompt(message["content"])) return false;
+  const existing = textFragments(message["content"]).join("\n");
+  message["content"] = existing === "" ? prompt : `${existing}\n\n${prompt}`;
+  return true;
+}
+
+/** Appends the prompt to the top-level Anthropic `system` value. */
+export function injectAnthropicPrompt(payload: Record<string, unknown>, prompt: string): boolean {
+  const system = payload["system"];
+  if (system !== undefined && carriesOpenCodePrompt(system)) return false;
+  if (system === undefined) {
+    payload["system"] = prompt;
+    return true;
+  }
+  if (typeof system === "string") {
+    payload["system"] = system.trim() === "" ? prompt : system + "\n\n" + prompt;
+  } else if (Array.isArray(system)) {
+    payload["system"] = [...system, { type: "text", text: prompt }];
+  } else {
+    payload["system"] = prompt;
+  }
+  return true;
+}
+
+/** Appends the prompt to the Responses `instructions` value. */
+export function injectResponsesPrompt(payload: Record<string, unknown>, prompt: string): boolean {
+  const instructions = payload["instructions"];
+  if (instructions !== undefined && carriesOpenCodePrompt(instructions)) return false;
+  if (typeof instructions === "string") {
+    payload["instructions"] = instructions.trim() === "" ? prompt : instructions + "\n\n" + prompt;
+  } else {
+    payload["instructions"] = prompt;
+  }
+  return true;
+}
+
+/**
+ * Injects the prompt into a free-tier payload for the given wire family.
+ * System One payloads are never touched. Reports whether changed.
+ */
+export function injectOpenCodePrompt(
+  payload: Record<string, unknown>,
+  wireFamily: "chat" | "responses" | "messages" | "systemone",
+): boolean {
+  if (wireFamily === "systemone") return false;
+  const prompt = opencodeSystemPrompt();
+  if (wireFamily === "chat") return injectChatPrompt(payload, prompt);
+  if (wireFamily === "messages") return injectAnthropicPrompt(payload, prompt);
+  return injectResponsesPrompt(payload, prompt);
+}

package/src/providers/integrations/opencode/provider.ts

@@ -9,6 +9,7 @@ import type { ApiKeyProviderSpec } from "../../configured-provider";
 import { resolveOpenCodeUnavailableFree } from "../../../config/providers";
 import { buildOpenCodeHeaders } from "./fingerprint";
 import { OPENCODE_TOOL_DEFINITIONS } from "./tool-definitions";
+import { injectOpenCodePrompt } from "./prompt";
 /**
  * OpenCode's three API-key tiers, all served from `opencode.ai`:
  *
@@ -19,8 +20,10 @@ import { OPENCODE_TOOL_DEFINITIONS } from "./tool-definitions";
  * - `opencode-go` (OpenCode Go): billed API-key route on the separate
  *   `/zen/go/v1` base — a bundled, higher-tier model set.
  *
- * Free and Zen dispatch on `/inference/v1`, NOT `/zen/v1`. The catalog is the
- * other way round: `/zen/v1/models` publishes the listing while
+ * Free and Zen dispatch on the `/inference` origin using the 2.1 family
+ * segment: `/inference/openai/v1/...` for chat/responses and
+ * `/inference/anthropic/v1/messages?beta=true` for Anthropic. The catalog is
+ * the other way round: `/zen/v1/models` publishes the listing while
  * `/inference/v1/models` answers 404. A replay that hit `/inference/v1` directly
  * returned 200 while the gateway kept failing, because every model row carried
  * an explicit `/zen/v1` endpoint — which outranks the per-provider wire-family
@@ -30,8 +33,28 @@ import { OPENCODE_TOOL_DEFINITIONS } from "./tool-definitions";
  * (`x-opencode-*` correlation IDs, `user-agent: opencode`). Go is
  * intentionally API-key-only.
  */
-/** Dispatch base for the Free and Zen tiers. */
-const ZEN_PATH_PREFIX = "/inference/v1";
+/**
+ * The v2 upstream path for a wire family on the `/inference` origin, matching
+ * the reference implementation's `v2EndpointPath`: the 2.1 client
+ * groups `/inference` routes by provider family, so chat/responses sit under
+ * `/openai/v1/...` and Anthropic under `/anthropic/v1/messages?beta=true`.
+ * Go keeps the flat `/zen/go/v1/...` shape.
+ */
+function zenEndpoint(wireFamily: string): string {
+  if (wireFamily === "messages") return "/inference/anthropic/v1/messages?beta=true";
+  const protocol = wireFamily === "responses" ? "responses" : "chat/completions";
+  return `/inference/openai/v1/${protocol}`;
+}
+
+/**
+ * The System One decision endpoint on the `/inference` origin. Verified live:
+ * System One does NOT take the v2 family segment — `/inference/openai/v1/systemone`
+ * answers 404 while the flat `/inference/v1/systemone` answers 200 with a valid
+ * `{state, questions}` body.
+ */
+function zenSystemoneEndpoint(): string {
+  return "/inference/v1/systemone";
+}
 const GO_PATH_PREFIX = "/zen/go/v1";
 
 /**
@@ -121,7 +144,10 @@ export function isFreeTierZenModel(modelId: string): boolean {
   // id rather than the prefixed one.
   const bare = modelId.slice(modelId.indexOf("/") + 1);
   if (unavailableFreeZenIds().includes(bare)) return false;
-  return bare.endsWith("-free") || KNOWN_FREE_ZEN_IDS.includes(bare);
+  // The reference gateway's name rule admits any id containing "free" (any
+  // case) in addition to the suffix convention; the explicit lists keep the
+  // measured exclusions and the one free id that carries no marker.
+  return bare.endsWith("-free") || KNOWN_FREE_ZEN_IDS.includes(bare) || bare.toLowerCase().includes("free");
 }
 
 /**
@@ -156,6 +182,7 @@ function opencodeDesktopHeaders(
       undefined,
       context.conversation_affinity,
       context.request_headers?.["x-opencode-project"],
+      context.request_headers?.["x-opencode-session-id"],
     ),
     // The gate reads the anonymous sentinel: a free dispatch with no
     // Authorization is refused regardless of headers, tools, or session shape.
@@ -327,6 +354,34 @@ function clampOpenCodeTools(payload: Record<string, unknown>, request: Canonical
   if (kept.length > OPENCODE_MAX_TOOLS) return;
   payload["tools"] = [...kept, ...rest.slice(0, OPENCODE_MAX_TOOLS - kept.length)];
 }
+/**
+ * The completion ceiling a 2.x client puts on every v2 chat body, matching the
+ * reference gateway's `v2CompletionLimit`. The upstream's free gate expects the
+ * same ceiling; an explicit `max_tokens`/`max_completion_tokens` from the
+ * caller always wins.
+ */
+const OPENCODE_V2_COMPLETION_LIMIT = 32_000;
+
+/** The key order a 2.x client's JSON.stringify emits for a chat body. */
+const V2_CHAT_KEY_ORDER = ["model", "messages", "tools", "stream", "stream_options", "max_completion_tokens"] as const;
+
+/**
+ * Reorders a chat payload's keys to the 2.x client's byte layout: the skeleton
+ * keys first in the client's order, then every remaining key sorted. Values are
+ * untouched; JSON.stringify preserves this insertion order, so the serialized
+ * body matches the reference gateway's `marshalV2ChatBody`.
+ */
+function reorderV2ChatKeys(payload: Record<string, unknown>): void {
+  const keys = [
+    ...V2_CHAT_KEY_ORDER.filter((key) => key in payload),
+    ...Object.keys(payload).filter((key) => !(V2_CHAT_KEY_ORDER as readonly string[]).includes(key)).sort(),
+  ];
+  const next: Record<string, unknown> = {};
+  for (const key of keys) next[key] = payload[key];
+  for (const key of Object.keys(payload)) delete payload[key];
+  Object.assign(payload, next);
+}
+
 function opencodeSpec(providerId: "opencode" | "opencode-zen" | "opencode-go"): ApiKeyProviderSpec {
   // Free-tier gate facts (verified live 2026-10-14 against opencode.ai/zen/v1):
   // a request for a free model with stream:false is ALWAYS refused with 403
@@ -352,19 +407,42 @@ function opencodeSpec(providerId: "opencode" | "opencode-zen" | "opencode-go"):
       if (candidate.wire_family === "responses") {
         payload.store = false;
       }
-      if (candidate.wire_family === "chat" && request.stream) {
-        payload.stream_options = {
-          ...(typeof payload.stream_options === "object" && payload.stream_options !== null
-            ? (payload.stream_options as Record<string, unknown>)
-            : {}),
-          include_usage: true,
-        };
-      }
-      // Free model: force the upstream stream flag regardless of what the
-      // caller asked for. The gate refuses stream:false on free models with
-      // 403 FreeTierError; here it only patches the wire body, never the
+      // Free model: match the reference gateway's free-tier shaping 1:1 —
+      // the official CLI system prompt, the v2 completion ceiling, the
+      // include_usage flag, and the forced upstream stream. The gate refuses
+      // tool-less, non-streaming, or non-agent-shaped free dispatches with 403
+      // FreeTierError; here it only patches the wire body, never the
       // client-visible stream contract.
-      if (isFreeTierZenModel(candidate.model_id)) payload.stream = true;
+      if (isFreeTierZenModel(candidate.model_id)) {
+        if (candidate.wire_family === "chat") {
+          // The wire encoder injects the v2 ceiling (32000) as the default
+          // max_completion_tokens when the caller set no limit. Treat that
+          // sentinel as "unset" so the model's own declared output ceiling can
+          // take its place; an explicit user limit is never touched.
+          const isV2Default =
+            payload["max_completion_tokens"] === OPENCODE_V2_COMPLETION_LIMIT &&
+            payload["max_tokens"] === undefined;
+          if (isV2Default || (payload["max_completion_tokens"] === undefined && payload["max_tokens"] === undefined)) {
+            const ceiling =
+              typeof candidate.output_limit === "number" && candidate.output_limit > 0
+                ? candidate.output_limit
+                : OPENCODE_V2_COMPLETION_LIMIT;
+            payload["max_completion_tokens"] = ceiling;
+          }
+          payload.stream_options = {
+            ...(typeof payload.stream_options === "object" && payload.stream_options !== null
+              ? (payload.stream_options as Record<string, unknown>)
+              : {}),
+            include_usage: true,
+          };
+        }
+        const family = candidate.wire_family;
+        if (family === "chat" || family === "responses" || family === "messages") {
+          injectOpenCodePrompt(payload, family);
+        }
+        payload.stream = true;
+        if (candidate.wire_family === "chat") reorderV2ChatKeys(payload);
+      }
     },
     // OpenCode Free is a genuinely public, unauthenticated endpoint: no
     // credential is ever forwarded, whatever the account configuration says.
@@ -424,7 +502,7 @@ export async function discoverOpenCodeFreeModels(options: {
         ...systemoneLimits(),
         freeTier: true,
         serviceKind: "systemone" as const,
-        endpointPath: `${ZEN_PATH_PREFIX}/systemone`,
+        endpointPath: zenSystemoneEndpoint(),
       };
     });
 }
@@ -436,12 +514,12 @@ export async function discoverOpenCodeFreeModels(options: {
 // OpenCode row understates this model's 1M context limit, so keep the corrected
 // limit explicit for both tiers that serve it.
 const sharedZenChat: readonly ModelDefinition[] = [
-  defineModel({ id: "big-pickle", providerId: "opencode", wireFamily: "chat", endpoint: `${ZEN_PATH_PREFIX}/chat/completions`, vision: true, reasoning: true }),
+  defineModel({ id: "big-pickle", providerId: "opencode", wireFamily: "chat", endpoint: zenEndpoint("chat"), vision: true, reasoning: true }),
   defineModel({
     id: "mimo-v2.6-flash-free",
     providerId: "opencode",
     wireFamily: "chat",
-    endpoint: `${ZEN_PATH_PREFIX}/chat/completions`,
+    endpoint: zenEndpoint("chat"),
     ctx: 1_000_000,
     out: 32_000,
     vision: true,
@@ -478,7 +556,7 @@ const systemoneZen = (id: string, free: boolean): ModelDefinition =>
     providerId: "opencode",
     serviceKind: "systemone",
     wireFamily: "chat",
-    endpoint: `${ZEN_PATH_PREFIX}/systemone`,
+    endpoint: zenSystemoneEndpoint(),
     ctx: SYSTEMONE_LIMITS.context,
     out: SYSTEMONE_LIMITS.output,
     toolCall: false,
@@ -507,8 +585,8 @@ export const OPENCODE_FREE_MODELS: readonly ModelDefinition[] = [
 
 export const OPENCODE_ZEN_MODELS: readonly ModelDefinition[] = [
   ...sharedZenChat,
-  defineModel({ id: "muse-spark-1.2", providerId: "opencode", wireFamily: "responses", endpoint: `${ZEN_PATH_PREFIX}/responses`, vision: true, reasoning: true, reasoningEfforts: MUSE_SPARK_REASONING_EFFORTS }),
-  defineModel({ id: "muse-spark-1.3", providerId: "opencode", wireFamily: "responses", endpoint: `${ZEN_PATH_PREFIX}/responses`, vision: true, reasoning: true, reasoningEfforts: MUSE_SPARK_REASONING_EFFORTS }),
+  defineModel({ id: "muse-spark-1.2", providerId: "opencode", wireFamily: "responses", endpoint: zenEndpoint("responses"), vision: true, reasoning: true, reasoningEfforts: MUSE_SPARK_REASONING_EFFORTS }),
+  defineModel({ id: "muse-spark-1.3", providerId: "opencode", wireFamily: "responses", endpoint: zenEndpoint("responses"), vision: true, reasoning: true, reasoningEfforts: MUSE_SPARK_REASONING_EFFORTS }),
   systemoneZen("jev-1.13", false),
 ];
 

package/src/providers/integrations/opencode/tool-definitions.ts

@@ -6,10 +6,10 @@
  * even one carrying the right name — is refused with `403 FreeTierError`.
  * That is why these are verbatim rather than minimal.
  *
- * Source: the client's own tool registry as embedded by the `opencode2api`
- * gateway (`internal/gateway/opencode_tools.json`), captured from a real
- * dispatch. `patch` is absent from that capture; its description and single
- * `patchText` parameter come from the 2.0.32 CLI binary's own registration.
+ * Source: the client's own tool registry as embedded by the reference
+ * gateway's tool asset, captured from a real dispatch. `patch` is absent from
+ * that capture; its description and single `patchText` parameter come from the
+ * 2.0.32 CLI binary's own registration.
  *
  * Thirteen entries, matching the CLI's internal tool-name set.
  */

package/src/providers/integrations/qoder/qoder-checkin.ts

@@ -0,0 +1,303 @@
+/**
+ * Qoder daily check-in (streak / 100 Credits per day), ported from the
+ * reference bridge (`qoder_accounts.py` in `qoder2api-hub`).
+ *
+ * Two upstream surfaces, tried in order:
+ *
+ * 1. Legacy sash: `GET /sash/api/v1/me/daily-check-in/status` then
+ *    `POST /sash/api/v1/me/daily-check-in/claim`. The status exposes the
+ *    streak (`currentStreakDays`) and the reward (`rewardCredits`, 100).
+ * 2. Activity-platform campaign: when the legacy surface is absent (INTL often
+ *    answers 404), `GET /sash/api/v1/me/campaigns` lists daily rewards and the
+ *    CREDITS-kind claimable one is claimed via
+ *    `POST /sash/api/v1/me/campaigns/{id}/claim`.
+ *
+ * The result shape is the same `DailyCheckinResult` the buddy family uses, so
+ * the shared sweep slot ledger (`daily_checkin_ledger`), the log phrasing, and
+ * the console surface treat Qoder like any other daily-grant provider.
+ */
+import { QODER_REALMS, qoderRealmForProvider } from "./qoder-realm";
+
+/** Structural fetch bound; Bun's own fetch type carries extra host props. */
+type Fetcher = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+import type { DailyCheckinResult, DailyCheckinState } from "../buddy/buddy-checkin";
+
+export const QODER_CHECKIN_PROVIDER_IDS: readonly string[] = ["qoder", "qodercn"];
+
+/** True when this provider id runs the Qoder check-in surface. */
+export function isQoderCheckinProvider(providerId: string): boolean {
+  return (QODER_CHECKIN_PROVIDER_IDS as readonly string[]).includes(providerId);
+}
+
+/** Abort budget for one upstream check-in request. */
+const TIMEOUT_MS = 15_000;
+
+const CHECKIN_STATUS_PATH = "/sash/api/v1/me/daily-check-in/status";
+const CHECKIN_CLAIM_PATH = "/sash/api/v1/me/daily-check-in/claim";
+const CAMPAIGNS_PATH = "/sash/api/v1/me/campaigns";
+const CAMPAIGN_CLAIM_PATH = "/sash/api/v1/me/campaigns/%s/claim";
+
+function asRecord(value: unknown): Record<string, unknown> | null {
+  if (typeof value !== "object" || value === null) return null;
+  return value as Record<string, unknown>;
+}
+
+function asNumber(value: unknown): number | null {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string" && value.trim() !== "") {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : null;
+  }
+  return null;
+}
+
+function safeParse(raw: string): unknown {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+function baseOutcome(
+  providerId: string,
+  accountId: string,
+): { providerId: string; accountId: string; credit: null; streakDays: null; error: null } {
+  return { providerId, accountId, credit: null, streakDays: null, error: null };
+}
+
+function asState(state: string, today: string, lastClaimedAt: unknown): { active: boolean; todayCheckedIn: boolean } {
+  const status = state.toUpperCase();
+  const active = status === "CLAIMABLE" || status === "CLAIMED";
+  let claimedToday = false;
+  if (status === "CLAIMED") {
+    const stamp = asNumber(lastClaimedAt);
+    if (stamp !== null) {
+      const day = new Date(stamp * 1000).toISOString().slice(0, 10);
+      claimedToday = day === today;
+    }
+  }
+  return { active, todayCheckedIn: claimedToday };
+}
+
+/** GET campaign list; returns `null` when the surface is unreachable/unauthorized. */
+async function fetchCampaigns(
+  base: string,
+  credential: string,
+  fetcher: Fetcher,
+): Promise<Record<string, unknown>[] | null> {
+  try {
+    const response = await fetcher(`${base}${CAMPAIGNS_PATH}`, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${credential}`,
+        Accept: "application/json",
+      },
+      signal: AbortSignal.timeout(TIMEOUT_MS),
+    });
+    if (response.status === 401 || response.status === 403) return null;
+    if (!response.ok) return null;
+    const payload: unknown = await response.json().catch(() => null);
+    const rec = asRecord(payload);
+    const list = Array.isArray(rec?.["campaigns"]) ? rec!["campaigns"] : Array.isArray(payload) ? payload : null;
+    return Array.isArray(list) ? (list as Record<string, unknown>[]) : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Claims one campaign and returns the resulting state. Mirrors the donor's
+ * `claim_campaign` idempotence handling: a 409 or `ALREADY_CLAIMED` body is
+ * an already-claimed grant, `SAME_PERSON_ALREADY_CLAIMED`/`BLOCKED` is a
+ * same-person block (not a failure of this account's day), and anything else
+ * is an error.
+ */
+async function claimCampaign(
+  base: string,
+  campaignId: string,
+  credential: string,
+  fetcher: Fetcher,
+): Promise<{ state: DailyCheckinState; amount: number }> {
+  const url = base + CAMPAIGN_CLAIM_PATH.replace("%s", encodeURIComponent(campaignId));
+  let response: Response;
+  try {
+    response = await fetcher(url, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${credential}`,
+        "Content-Type": "application/json",
+        Accept: "application/json",
+      },
+      body: "{}",
+      signal: AbortSignal.timeout(TIMEOUT_MS),
+    });
+  } catch {
+    return { state: "error", amount: 0 };
+  }
+  const raw = await response.text().catch(() => "");
+  const payload: unknown = raw ? safeParse(raw) : null;
+  const rec = asRecord(payload);
+  const status = String(rec?.["status"] ?? "").toUpperCase();
+  const failure = String(rec?.["failureCode"] ?? "").toUpperCase();
+  const success = rec?.["success"] !== false;
+  const benefit = asRecord(rec?.["benefit"]);
+  const amount = asNumber(rec?.["amount"] ?? benefit?.["amount"]) ?? 0;
+  if (response.status === 409 || failure === "ALREADY_CLAIMED" || status === "CLAIMED" && failure === "REPLAYED") {
+    return { state: "already_claimed", amount };
+  }
+  if (failure === "SAME_PERSON_ALREADY_CLAIMED" || status === "BLOCKED") {
+    return { state: "not_eligible", amount: 0 };
+  }
+  if (response.ok && success && (status === "CLAIMED" || status === "GRANTED" || status === "SUCCESS")) {
+    return { state: "claimed", amount };
+  }
+  return { state: "error", amount: 0 };
+}
+
+/** Legacy sash status + claim. Returns `null` when the surface is absent (404/405/410). */
+async function legacySashCheckin(args: {
+  readonly base: string;
+  readonly credential: string;
+  readonly fetcher: Fetcher;
+  readonly now?: () => Date;
+}): Promise<{ state: DailyCheckinState; credit: number; streakDays: number } | null> {
+  const { base, credential, fetcher } = args;
+  const today = (args.now?.() ?? new Date()).toISOString().slice(0, 10);
+  let statusResponse: Response;
+  try {
+    statusResponse = await fetcher(`${base}${CHECKIN_STATUS_PATH}`, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${credential}`,
+        Accept: "application/json",
+      },
+      signal: AbortSignal.timeout(TIMEOUT_MS),
+    });
+  } catch {
+    return { state: "error", credit: 0, streakDays: 0 };
+  }
+  if (statusResponse.status === 401 || statusResponse.status === 403) {
+    return { state: "error", credit: 0, streakDays: 0 };
+  }
+  if (statusResponse.status === 404 || statusResponse.status === 405 || statusResponse.status === 410) {
+    return null; // surface absent — caller falls back to campaign
+  }
+  if (!statusResponse.ok) {
+    return { state: "error", credit: 0, streakDays: 0 };
+  }
+  const payload: unknown = await statusResponse.json().catch(() => null);
+  const rec = asRecord(payload);
+  if (!rec) return { state: "error", credit: 0, streakDays: 0 };
+  const { active, todayCheckedIn } = asState(String(rec["status"] ?? ""), today, rec["lastClaimedAt"]);
+  const streakDays = asNumber(rec["currentStreakDays"]) ?? 0;
+  const credit = asNumber(rec["rewardCredits"]) ?? 100;
+  if (todayCheckedIn) return { state: "already_claimed", credit: 0, streakDays };
+  if (!active) return { state: "not_eligible", credit: 0, streakDays };
+  // Claim.
+  let claimResponse: Response;
+  try {
+    claimResponse = await fetcher(`${base}${CHECKIN_CLAIM_PATH}`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${credential}`,
+        "Content-Type": "application/json",
+        Accept: "application/json",
+      },
+      body: "{}",
+      signal: AbortSignal.timeout(TIMEOUT_MS),
+    });
+  } catch {
+    return { state: "error", credit: 0, streakDays };
+  }
+  const raw = await claimResponse.text().catch(() => "");
+  const lower = raw.toLowerCase();
+  if (claimResponse.status === 409 || lower.includes("already_claimed") || lower.includes("已签到")) {
+    return { state: "already_claimed", credit: 0, streakDays };
+  }
+  const body: unknown = raw ? safeParse(raw) : null;
+  const bodyRec = asRecord(body);
+  const ok = claimResponse.ok && bodyRec?.["success"] !== false;
+  if (!ok) return { state: "error", credit: 0, streakDays };
+  return { state: "claimed", credit, streakDays };
+}
+
+/**
+ * Performs one account's Qoder daily check-in: legacy sash first, campaign
+ * fallback when the sash surface is absent. Returns the same
+ * `DailyCheckinResult` shape the shared sweep consumes.
+ */
+export async function fetchQoderDailyCheckin(args: {
+  readonly providerId: string;
+  readonly accountId: string;
+  readonly credential: string;
+  readonly fetcher: Fetcher;
+  readonly now?: () => Date;
+}): Promise<DailyCheckinResult> {
+  const { providerId, accountId, credential, fetcher } = args;
+  const baseResult = baseOutcome(providerId, accountId);
+  if (!credential) {
+    return { ...baseResult, state: "error", error: "Account has no stored credential." };
+  }
+  const realm = qoderRealmForProvider(providerId);
+  const base = QODER_REALMS[realm].openapi;
+
+  const sash = await legacySashCheckin({
+    base,
+    credential,
+    fetcher,
+    ...(args.now === undefined ? {} : { now: args.now }),
+  });
+  if (sash !== null) {
+    return {
+      ...baseResult,
+      state: sash.state,
+      credit: sash.state === "claimed" ? sash.credit : null,
+      streakDays: sash.streakDays,
+      ...(sash.state === "error" ? { error: "Upstream daily check-in failed." } : {}),
+    };
+  }
+
+  // Legacy surface absent: campaign fallback.
+  const campaigns = await fetchCampaigns(base, credential, fetcher);
+  if (campaigns === null) {
+    return { ...baseResult, state: "error", error: "Check-in surface unavailable (legacy 404 and campaign list failed)." };
+  }
+  let alreadySeen = false;
+  for (const campaign of campaigns) {
+    const rec = asRecord(campaign);
+    if (!rec) continue;
+    const benefit = asRecord(rec["benefit"]);
+    const kind = String(benefit?.["kind"] ?? "").toUpperCase();
+    if (kind !== "CREDITS" && kind !== "") continue;
+    const actionType = String(rec["action_type"] ?? "");
+    if (actionType !== "" && actionType !== "CLAIM_BENEFIT") continue;
+    const claimStatus = String(rec["claim_status"] ?? "").toUpperCase();
+    if (claimStatus === "CLAIMED") {
+      alreadySeen = true;
+      continue;
+    }
+    if (claimStatus !== "CLAIMABLE") continue;
+    const campaignId = String(rec["campaign_id"] ?? "");
+    if (!campaignId) continue;
+    const result = await claimCampaign(base, campaignId, credential, fetcher);
+    if (result.state === "claimed") {
+      const amount = asNumber(benefit?.["amount"]) ?? result.amount;
+      return { ...baseResult, state: "claimed", credit: amount, streakDays: null };
+    }
+    if (result.state === "already_claimed") {
+      alreadySeen = true;
+      continue;
+    }
+    if (result.state === "error") {
+      return { ...baseResult, state: "error", error: "Campaign claim failed." };
+    }
+    // not_eligible (same-person block): stop trying further campaigns.
+    return { ...baseResult, state: "not_eligible", error: "Same-person claim already used today." };
+  }
+  return {
+    ...baseResult,
+    state: alreadySeen ? "already_claimed" : "unavailable",
+    error: alreadySeen ? null : "No daily CREDITS campaign claimable.",
+  };
+}

package/src/providers/integrations/qoder/qoder-oauth.ts

@@ -150,7 +150,18 @@ export interface QoderOAuthState {
 
 /** Reads the persisted Qoder identity; `undefined` when the account predates it. */
 export function parseQoderOAuthState(value: unknown): QoderOAuthState | undefined {
-  const root = record(value);
+  let root = record(value);
+  if (root === undefined && typeof value === "string") {
+    // The credential loader stores `auth_state` as JSON text in SQLite, so
+    // the resolver hands the adapter a string when the cache was cold. Parse
+    // it before giving up — a login that works once must work again after the
+    // cache is evicted.
+    try {
+      root = record(JSON.parse(value));
+    } catch {
+      return undefined;
+    }
+  }
   if (root === undefined) return undefined;
   const userId = nonEmptyTrimmedString(root.userId);
   const machineId = nonEmptyTrimmedString(root.machineId);