cartethyia 2.7.3 → 2.7.5

package/src/providers/integrations/muse/muse.ts

@@ -22,6 +22,7 @@ import type { CanonicalRequest } from "../../../protocol/canonical-model";
 import { GatewayError } from "../../../protocol/gateway-error";
 import { decodeMuseCredential } from "../../../security/credential-codec";
 import { OpenAICompatibleAdapter, withBearerAuthentication } from "../../adapters/compatible-adapter";
+import { assertCredentialKind } from "../../provider-contracts";
 import type { ProviderDispatchTarget, ProviderDispatchContext, ResolvedCredential } from "../../provider-contracts";
 import { providerBaseUrl } from "../../provider-metadata";
 
@@ -85,19 +86,19 @@ export function parseMuseCodeCredential(
     // as before the extraction.
     const message = error instanceof Error ? error.message : "";
     if (message.endsWith("must be a JSON object")) {
-      throw new GatewayError("invalid_request", 400, "muse: credential must be a JSON object");
+      throw new GatewayError("invalid_request", 400, "muse: credential must be a JSON object (request {requestId}). Wrong key, right door — check the credential 🔑");
     }
     if (message.endsWith("is not a valid JSON blob")) {
       throw new GatewayError(
         "invalid_request",
         400,
-        "muse: credential is not a valid JSON blob; sign in again",
+        "muse: credential is not a valid JSON blob (request {requestId}); sign in again. Wrong key, right door — check the credential 🔑",
       );
     }
     throw new GatewayError(
       "authentication_failed",
       401,
-      "muse: credential is missing oauthAccessToken or apiKey; sign in again",
+      "muse: credential is missing oauthAccessToken or apiKey (request {requestId}); sign in again. Wrong key, right door — check the credential 🔑",
     );
   }
 }
@@ -137,17 +138,13 @@ class MuseCodeAdapter extends OpenAICompatibleAdapter {
     candidate: ProviderDispatchTarget,
   ): Promise<Record<string, string>> {
     if (context.credential.credential_kind !== "oauth") {
-      throw new GatewayError(
-        "invalid_request",
-        400,
-        `muse: OAuth credential required (got credential_kind=${context.credential.credential_kind})`,
-      );
+      assertCredentialKind(context.credential, "oauth", "muse");
     }
     if (!context.credential.secret) {
       throw new GatewayError(
         "authentication_failed",
         401,
-        "muse: OAuth credential secret is required",
+        "muse: OAuth credential secret is required (request {requestId}). Wrong key, right door — check the credential 🔑",
       );
     }
     const { apiKey } = decodeMuseCredential(context.credential.secret);

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

@@ -2,12 +2,14 @@ import { getOpenCodeVersion } from "../../operations/client-versions";
 import { createHash, randomBytes } from "node:crypto";
 
 /**
- * The OpenCode fallback client identity, used only while version discovery has
- * not resolved yet. The live feed (`opencode/latest/<version>/cli`) wins once
- * it is available; upstream accepts a range of releases, so the fallback does
- * not need chasing.
+ * The pinned reference client identity the parity suite asserts on.
+ *
+ * The runtime fallback lives in `VERSION_SOURCES.opencode.fallback`
+ * (`operations/client-versions.ts`); this mirror exists so the parity suite
+ * can pin the exact identity sent before discovery resolves. Keep both in
+ * lockstep when the CLI releases.
  */
-export const OPENCODE_CLIENT_VERSION = "2.1.1";
+export const OPENCODE_CLIENT_VERSION = "2.2.5";
 
 let lastTimestamp = 0;
 let sequenceCounter = 0;

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

@@ -150,17 +150,6 @@ export function isFreeTierZenModel(modelId: string): boolean {
   return bare.endsWith("-free") || KNOWN_FREE_ZEN_IDS.includes(bare) || bare.toLowerCase().includes("free");
 }
 
-/**
- * The anonymous credential the free tier accepts.
- *
- * Captured from a real client dispatch and confirmed live 2026-10-14: without
- * it a free-model request is refused with 403 `FreeTierError` even when every
- * other field is byte-exact, and with it the same request returns 200. It is a
- * sentinel the upstream recognizes, not a secret — but it is a credential
- * value, so it lives here rather than in the shared fingerprint.
- */
-const ANONYMOUS_ZEN_BEARER = "public";
-
 /**
  * The `Accept` a free-tier dispatch advertises.
  *
@@ -184,9 +173,10 @@ function opencodeDesktopHeaders(
       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.
-    ...(freeModel ? { authorization: `Bearer ${ANONYMOUS_ZEN_BEARER}` } : {}),
+    // The free-tier gate accepts dispatches with no `Authorization` at all
+    // (verified live 2026-11-02: the same captured flow answers 200 both with
+    // `Bearer public` and with no auth header, as long as the body/session
+    // fingerprint is valid). No anonymous sentinel is sent.
     // The free-tier gate refuses non-streaming dispatches with 403
     // FreeTierError, so free models always advertise SSE regardless of the
     // client's own Accept; billed models keep the JSON default. The value is
@@ -211,27 +201,28 @@ function opencodeDesktopHeaders(
  * `ToolDefinition`s — every wire codec serializes them, no per-wire patching.
  */
 /**
- * Every tool the free-tier gate recognises, in the order the client declares
- * them, with the client's own description and schema.
+ * Every tool the free-tier gate recognises, in the order the real 2.2.0
+ * client declares them on the wire (mitm capture 2026-11-02, flow 4), with
+ * the client's own description and schema.
  *
  * The gate compares a recognised tool's definition, not just its name: a stub
  * carrying the right name is refused. These are therefore verbatim captures —
- * see `./tool-definitions` for provenance.
+ * see `./tool-definitions` for provenance. A real dispatch carries exactly
+ * these 11 tools (the binary's full `UPt` registry has 14, but the build
+ * agent sends only these).
  */
 const FREE_AGENT_TOOL_NAMES_ORDERED: readonly string[] = [
-  "shell",
+  "edit",
   "glob",
-  "read",
   "grep",
+  "read",
+  "shell",
+  "skill",
+  "subagent",
   "webfetch",
   "websearch",
   "write",
-  "edit",
-  "subagent",
   "execute",
-  "patch",
-  "question",
-  "skill",
 ];
 
 /**
@@ -268,6 +259,8 @@ function ensureFreeAgentRequest(request: CanonicalRequest): CanonicalRequest {
       name,
       description: definition?.description ?? name,
       jsonSchema: (definition?.parameters ?? FREE_AGENT_TOOL_SCHEMA) as ToolDefinition["jsonSchema"],
+      // The real client marks every declared tool strict:false on the wire.
+      strict: false,
     };
   });
   if (missing.length === 0) return request;

package/src/providers/integrations/perplexity.ts

@@ -69,11 +69,11 @@ export function createPerplexityAdapter(fetchImpl?: typeof fetch): ProviderAdapt
       void _candidate;
       const query = extractSearchQuery(request);
       if (!query) {
-        throw new GatewayError("invalid_request", 400, "Search query is required.");
+        throw new GatewayError("invalid_request", 400, "Search query is required (request {requestId}). Check the shape of what you sent — then resend 🪞");
       }
       const token = tokenFromContext(context);
       if (!token) {
-        throw new GatewayError("authentication_failed", 401, "Missing Perplexity API key");
+        throw new GatewayError("authentication_failed", 401, "Missing Perplexity API key (request {requestId}). Wrong key, right door — check the key 🔑");
       }
 
       const fetchFn = (context.outbound_fetch as unknown as typeof fetch | undefined) ?? fetchImpl ?? globalThis.fetch;

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

@@ -86,6 +86,14 @@ interface QoderModelConfig {
    * `false` marks the model as billed.
    */
   readonly is_free?: boolean;
+  /**
+   * The reasoning effort to send when the caller did not ask for one. The IDE
+   * surface follows the `reasoningEffort` field: a model marked `is_reasoning`
+   * may still stream no reasoning unless an effort is present (verified live:
+   * Sonus streams thinking only when effort is sent; DeepSeek thinks by
+   * default). Set only for models that need the push.
+   */
+  readonly default_reasoning_effort?: string;
 }
 
 /**
@@ -112,7 +120,7 @@ export const QODER_CN_MODEL_CONFIGS: Readonly<Record<string, QoderModelConfig>>
 };
 
 /**
- * Global/intl roster (17 keys), from the donor's `qoder_catalog_intl.json`.
+ * Global/intl roster (18 keys), from the donor's `qoder_catalog_intl.json`.
  *
  * Note how the shared keys differ from CN — `auto` is non-reasoning here and
  * `qmodel` carries a 1M window. That is why the rosters are not merged.
@@ -127,19 +135,27 @@ export const QODER_INTL_MODEL_CONFIGS: Readonly<Record<string, QoderModelConfig>
   fast: { id: "fast", display_name: "Fast", max_input_tokens: 1000000, max_output_tokens: 64_000, is_vl: true, is_reasoning: false },
   performance: { id: "performance", display_name: "Performance", max_input_tokens: 1000000, max_output_tokens: 64_000, is_vl: true, is_reasoning: false },
   efficient: { id: "efficient", display_name: "Efficient", max_input_tokens: 200000, max_output_tokens: 64_000, is_vl: true, is_reasoning: false },
-  smodel: { id: "smodel", display_name: "Sonus", max_input_tokens: 1000000, max_output_tokens: 128_000, is_vl: true, is_free: false, is_reasoning: true },
-  cmodel: { id: "cmodel", display_name: "Cantus", max_input_tokens: 1000000, max_output_tokens: 128_000, is_vl: true, is_free: false, is_reasoning: true },
+  // Sonus/Cantus need an explicit effort on the IDE surface; without it the
+  // upstream streams text only, no reasoning (verified live). DeepSeek-family
+  // models think by default and are left untouched.
+  smodel: { id: "smodel", display_name: "Sonus", max_input_tokens: 1000000, max_output_tokens: 128_000, is_vl: true, is_free: false, is_reasoning: true, default_reasoning_effort: "high" },
+  cmodel: { id: "cmodel", display_name: "Cantus", max_input_tokens: 1000000, max_output_tokens: 128_000, is_vl: true, is_free: false, is_reasoning: true, default_reasoning_effort: "high" },
   qmodel_38max: { id: "qmodel_38max", display_name: "Qwen3.8-Max", max_input_tokens: 1000000, max_output_tokens: 131_072, is_vl: true, is_reasoning: true },
   qfmodel: { id: "qfmodel", display_name: "Qwen3.8-Flash", max_input_tokens: 1000000, max_output_tokens: 131_072, is_vl: true, is_free: true, is_reasoning: true },
   qmodel_latest: { id: "qmodel_latest", display_name: "Qwen3.7-Max", max_input_tokens: 1000000, max_output_tokens: 131_072, is_vl: true, is_reasoning: false },
   qmodel: { id: "qmodel", display_name: "Qwen3.7-Plus", max_input_tokens: 1000000, max_output_tokens: 131_072, is_vl: true, is_reasoning: false },
-  kmodel_latest: { id: "kmodel_latest", display_name: "Kimi-K3", max_input_tokens: 1000000, max_output_tokens: 131_072, is_vl: true, is_free: false, is_reasoning: false },
+  kmodel_latest: { id: "kmodel_latest", display_name: "Kimi-K3.1-Pro", max_input_tokens: 1000000, max_output_tokens: 131_072, is_vl: true, is_free: false, is_reasoning: false },
   kmodel: { id: "kmodel", display_name: "Kimi-K2.8-Preview", max_input_tokens: 1000000, max_output_tokens: 65_536, is_vl: true, is_free: false, is_reasoning: false },
   gmodel: { id: "gmodel", display_name: "GLM-5.3", max_input_tokens: 1000000, max_output_tokens: 131_072, is_vl: true, is_free: false, is_reasoning: true },
   gfmodel: { id: "gfmodel", display_name: "GLM-5.3-Flash", max_input_tokens: 1000000, max_output_tokens: 131_072, is_vl: true, is_reasoning: true },
   dmodel: { id: "dmodel", display_name: "DeepSeek-V4-Pro", max_input_tokens: 1000000, max_output_tokens: 384_000, is_vl: true, is_free: false, is_reasoning: true },
-  dfmodel: { id: "dfmodel", display_name: "DeepSeek-Flash", max_input_tokens: 1000000, max_output_tokens: 384_000, is_vl: true, is_free: true, is_reasoning: true },
-  mmodel: { id: "mmodel", display_name: "MiniMax-M3", max_input_tokens: 1000000, max_output_tokens: 512_000, is_vl: true, is_free: false, is_reasoning: false },
+  // Live roster (2026-11-01) reports dfmodel as billed (is_free false); it was
+  // previously marked free. Display names are corrected from the same capture.
+  dfmodel: { id: "dfmodel", display_name: "DeepSeek-Flash", max_input_tokens: 1000000, max_output_tokens: 384_000, is_vl: true, is_free: false, is_reasoning: true },
+  mmodel: { id: "mmodel", display_name: "MiniMax-M3.1-Flash", max_input_tokens: 1000000, max_output_tokens: 512_000, is_vl: true, is_free: false, is_reasoning: false },
+  // `lite` is the free-tier plan package: same 1M window and multimodal input
+  // as `qmodel` (Qwen3.7-Plus), capped at 64k output, free tier.
+  lite: { id: "lite", display_name: "Lite-Qwen-3.7-Plus", max_input_tokens: 1000000, max_output_tokens: 65_536, is_vl: true, is_free: true, is_reasoning: false },
 };
 
 /**
@@ -211,13 +227,24 @@ export function qoderVirtualModels(
         // substitutes the shared unfiled fallback for null — the same marker a
         // hand-added row gets.
         ctx: target.contextLimit ?? null,
-        ...(target.outputLimit === null ? {} : { out: target.outputLimit }),
-        vision: target.modalities.input.includes("image"),
+        // A virtual override wins; otherwise inherit the target's ceiling.
+        ...(virtual.outputLimit !== undefined
+          ? { out: virtual.outputLimit }
+          : target.outputLimit === null
+            ? {}
+            : { out: target.outputLimit }),
+        vision: virtual.vision ?? target.modalities.input.includes("image"),
         reasoning: target.reasoning ?? false,
         toolCall: target.toolCall ?? false,
         // The same model under its caller-facing name belongs to the same tier,
-        // so the pill follows the roster row rather than being restated.
-        ...(target.freeTier === undefined ? {} : { free: target.freeTier, freeTier: target.freeTier }),
+        // so the pill follows the roster row rather than being restated —
+        // unless the virtual card explicitly overrides it (`lite` is a free
+        // plan package over a billed slot).
+        ...(virtual.free !== undefined
+          ? { free: virtual.free, freeTier: virtual.free }
+          : target.freeTier === undefined
+            ? {}
+            : { free: target.freeTier, freeTier: target.freeTier }),
       }),
     );
   }
@@ -272,11 +299,27 @@ export function mapQoderCatalogResponse(raw: unknown): QoderCatalogEntry[] {
   return entries;
 }
 
+/**
+ * The static roster's stated output ceiling for one slot, when the roster
+ * states one.
+ *
+ * Upstream's live `/model/list` rows report no output limit, so a discovered
+ * row cannot read one from the wire. Inheriting the roster's number keeps the
+ * discovered row's `outputLimit` honest — without it `defineModel` falls back
+ * to a base-catalog/majority vote that can sit below the roster's ceiling
+ * (e.g. `qwen3.7-plus` votes 64k while the roster says 131k).
+ */
+function qoderRosterMaxOutputFor(providerId: string, key: string): number | undefined {
+  const configs = providerId === "qodercn" ? QODER_CN_MODEL_CONFIGS : QODER_INTL_MODEL_CONFIGS;
+  return configs[key]?.max_output_tokens;
+}
+
 /** Projects one live catalog row onto a Cartethyia catalog row. */
 export function qoderCatalogModel(
   entry: QoderCatalogEntry,
   providerId: string,
 ): ModelDefinition {
+  const rosterOutput = qoderRosterMaxOutputFor(providerId, entry.key);
   return defineModel({
     id: entry.key,
     providerId,
@@ -293,6 +336,9 @@ export function qoderCatalogModel(
     // a free row bills zero per token and belongs to the provider's free tier.
     free: entry.isFree,
     freeTier: entry.isFree,
+    // The live row carries no output ceiling, so inherit the static roster's
+    // stated one when it exists (see `qoderRosterMaxOutputFor`).
+    ...(rosterOutput === undefined ? {} : { out: rosterOutput }),
   });
 }
 
@@ -353,6 +399,14 @@ interface CachedRoster {
 /** Per-realm live-list cache; keyed by realm, not by account. */
 const discoveryCache = new Map<QoderRealm, CachedRoster>();
 
+/**
+ * Per-realm max-context window per roster key, taken from the live list's
+ * `context_config` (the widest selectable window). This is what dispatch reads
+ * to send `model_config.max_input_tokens`; without it the request would use the
+ * static roster's *currently active* window (often 180k) instead of the max.
+ */
+const discoveryMaxContextByKey = new Map<QoderRealm, Map<string, number>>();
+
 /**
  * Drops one realm's cached list.
  *
@@ -361,8 +415,21 @@ const discoveryCache = new Map<QoderRealm, CachedRoster>();
  * previous assertion left behind.
  */
 export function resetQoderDiscoveryCache(realm?: QoderRealm): void {
-  if (realm === undefined) discoveryCache.clear();
-  else discoveryCache.delete(realm);
+  if (realm === undefined) {
+    discoveryCache.clear();
+    discoveryMaxContextByKey.clear();
+  } else {
+    discoveryCache.delete(realm);
+    discoveryMaxContextByKey.delete(realm);
+  }
+}
+
+/**
+ * The widest selectable context window per roster key for one realm, from the
+ * live model list. Empty when discovery has not succeeded for that realm yet.
+ */
+export function qoderDiscoveredMaxContexts(realm: QoderRealm): ReadonlyMap<string, number> {
+  return discoveryMaxContextByKey.get(realm) ?? new Map();
 }
 
 export async function discoverQoderModels(input: {
@@ -389,7 +456,7 @@ export async function discoverQoderModels(input: {
     throw new GatewayError(
       "authentication_failed",
       401,
-      "Qoder model discovery requires an account credential.",
+      "Qoder model discovery requires an account credential (request {requestId}). Wrong key, right door — check the credential 🔑",
       { providerId, realm: input.realm },
     );
   }
@@ -398,7 +465,7 @@ export async function discoverQoderModels(input: {
     throw new GatewayError(
       "invalid_request",
       400,
-      "Qoder model discovery requires a validated outbound fetch",
+      "Qoder model discovery requires a validated outbound fetch (request {requestId}). No bridge to cross — configure a pool first 🏗️",
       { providerId, realm: input.realm },
     );
   }
@@ -409,6 +476,11 @@ export async function discoverQoderModels(input: {
     const url = `${host}${QODER_MODELS_PATH}`;
     try {
       const headers = await input.headers(url, signedBody);
+      // GET, not POST: upstream refuses POST on the model-list surface (400
+      // "Request method 'POST' not supported"). The signature covers the body,
+      // so the body must accompany the GET. The gateway's validated egress
+      // dials GET+body through the Node http(s) client (the runtime fetch
+      // rejects GET bodies), which is exactly the shape the donor client sends.
       const response = await fetcher(url, {
         method: "GET",
         headers: headers as unknown as HeadersInit,
@@ -429,10 +501,53 @@ export async function discoverQoderModels(input: {
         lastError = new Error("Qoder model list returned no usable models");
         continue;
       }
-      const models = enabled.map((entry) => qoderCatalogModel(entry, providerId));
+      const models = enabled.flatMap((entry) => {
+        // Publish caller-facing virtual ids (`sonus`, `lite-qwen-3.7-plus`, …)
+        // instead of the opaque roster keys (`smodel`, `qmodel`, …). A discovery
+        // row must look like what the UI offers and what a caller can type;
+        // keeping the raw key here made live-synced rows appear under names
+        // nobody can route to by display, and hid overridden cards like `lite`.
+        // More than one virtual may share a slot (`lite-qwen-3.7-plus` and
+        // `qwen3.7-plus` both dispatch to `qmodel`), so every match on the slot
+        // is published.
+        const virtuals = QODER_VIRTUAL_MODELS.filter((virtual) => virtual.target === entry.key);
+        if (virtuals.length === 0) return [qoderCatalogModel(entry, providerId)];
+        const rosterOutput = qoderRosterMaxOutputFor(providerId, entry.key);
+        return virtuals.map((virtual) =>
+          defineModel({
+            id: virtual.id,
+            providerId,
+            wireFamily: "chat",
+            endpoint: QODER_CHAT_PATH,
+            ctx: entry.maxInputTokens ?? null,
+            vision: virtual.vision ?? entry.isVl,
+            reasoning: entry.isReasoning,
+            // A virtual override wins; otherwise inherit the static roster's
+            // ceiling for the slot instead of a base-catalog/majority estimate
+            // (see `qoderRosterMaxOutputFor`).
+            ...(virtual.outputLimit !== undefined
+              ? { out: virtual.outputLimit }
+              : rosterOutput === undefined
+                ? {}
+                : { out: rosterOutput }),
+            free: virtual.free ?? entry.isFree,
+            freeTier: virtual.free ?? entry.isFree,
+          }),
+        );
+      });
+      // Index the widest selectable window per key (from `context_config`,
+      // already computed into `maxInputTokens` by `mapQoderCatalogResponse`) so
+      // dispatch can send the maximum rather than the currently active one.
+      const maxCtx = new Map<string, number>();
+      for (const entry of enabled) {
+        if (entry.maxInputTokens !== undefined && entry.key.length > 0) {
+          maxCtx.set(entry.key, entry.maxInputTokens);
+        }
+      }
       // Cached only after a host actually answered: a failure must stay
       // retryable on the next call rather than being frozen for five minutes.
       discoveryCache.set(input.realm, { at: Date.now(), models });
+      discoveryMaxContextByKey.set(input.realm, maxCtx);
       return models;
     } catch (error) {
       lastError = error;
@@ -441,9 +556,9 @@ export async function discoverQoderModels(input: {
   throw new GatewayError(
     "transport_unavailable",
     502,
-    `Qoder model discovery failed for ${input.realm}: ${
+    `Qoder model discovery failed for ${input.realm} (request {requestId}): ${
       lastError instanceof Error ? lastError.message : "unknown error"
-    }`,
+    }. The connection ghosted us — come back in a moment 👻`,
     { providerId, realm: input.realm },
     "upstream",
   );

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

@@ -175,15 +175,18 @@ async function tryClaimDaily(
   if (campaigns === null) {
     return { state: "error", amount: 0, error: "Campaign list unavailable." };
   }
-  for (const campaign of campaigns) {
+  // Claim a `CLAIMABLE` CREDITS-kind campaign. Promo rows (`VIEW_DETAILS`,
+  // no benefit) are not credit grants and must not be claimed — claiming one
+  // spends the account's daily slot for nothing and makes the sweep report a
+  // misleading `claimed` with 0 credits.
+  const claimable = campaigns.filter((c) => {
+    if (String(c["claim_status"] ?? "").toUpperCase() !== "CLAIMABLE") return false;
+    const kind = String(asRecord(c["benefit"])?.["kind"] ?? "").toUpperCase();
+    const action = String(c["action_type"] ?? "").toUpperCase();
+    return kind === "CREDITS" || action === "CLAIM_BENEFIT";
+  });
+  for (const campaign of claimable) {
     const benefit = asRecord(campaign["benefit"]);
-    const kind = String(benefit?.["kind"] ?? "").toUpperCase();
-    if (kind !== "CREDITS" && kind !== "") continue;
-    const actionType = String(campaign["action_type"] ?? "");
-    if (actionType !== "" && actionType !== "CLAIM_BENEFIT") continue;
-    const claimStatus = String(campaign["claim_status"] ?? "").toUpperCase();
-    if (claimStatus === "CLAIMED") return { state: "already_claimed", amount: 0, error: null };
-    if (claimStatus !== "CLAIMABLE") continue;
     const campaignId = String(campaign["campaign_id"] ?? "");
     if (!campaignId) continue;
     const claim = await claimWithHeaders(base, campaignId, headers, fetcher);
@@ -195,6 +198,18 @@ async function tryClaimDaily(
     if (claim.state === "not_eligible") return { state: "not_eligible", amount: 0, error: null };
     return { state: "error", amount: 0, error: "Campaign claim failed." };
   }
+  // Nothing claimable. Only a CREDITS-kind campaign that is `CLAIMED` proves
+  // today's credit was already taken; a claimed promo (`VIEW_DETAILS`, no
+  // benefit) says nothing about the daily grant, so it must not be reported
+  // as already_claimed. When the CREDITS campaign is absent entirely, the
+  // daily grant is simply not present (or hidden) for this account.
+  const anyCreditsClaimed = campaigns.some((c) => {
+    if (String(c["claim_status"] ?? "").toUpperCase() !== "CLAIMED") return false;
+    const kind = String(asRecord(c["benefit"])?.["kind"] ?? "").toUpperCase();
+    const action = String(c["action_type"] ?? "").toUpperCase();
+    return kind === "CREDITS" || action === "CLAIM_BENEFIT";
+  });
+  if (anyCreditsClaimed) return { state: "already_claimed", amount: 0, error: null };
   return { state: "unavailable", amount: 0, error: "No daily CREDITS campaign claimable." };
 }
 
@@ -224,6 +239,9 @@ async function probeDailyClaim(
 ): Promise<{ result: { state: DailyCheckinState; amount: number; error: string | null }; identity: QoderNativeIdentity | null }> {
   const basic = await tryClaimDaily(base, campaignHeaders(credential), fetcher);
   if (basic.state === "claimed" || basic.state === "already_claimed") {
+    // `tryClaimDaily` only claims CREDITS-kind campaigns, so a `claimed` or
+    // `already_claimed` basic result is already about the daily credit grant —
+    // terminal, no identity probe needed.
     return { result: basic, identity: null };
   }
   if (basic.state === "unavailable") {

package/src/providers/integrations/qoder/qoder-native-identity-store.ts

@@ -2,15 +2,16 @@
  * Persistence for the Qoder native machine identity (UMID) bound to an
  * account.
  *
- * The daily 100-credit check-in grant is device-scoped upstream, and the
- * server accepts only genuine, non-VM device identities. A device identity is
- * a deterministic function of a seed file (`~/.config/.locale_cfg`), so each
- * account gets its own minted seed — its own "device". The bound record lives
- * in `provider_accounts.native_identity` (plain JSON, not a secret).
+ * Same-account probes found that daily 100-credit grant visibility does not
+ * depend on machine headers. This store preserves native identities and seeds
+ * for deterministic replay and other surfaces that may use device identity.
+ * A native identity is a deterministic function of a seed file
+ * (`~/.config/.locale_cfg`). The bound record lives in
+ * `provider_accounts.native_identity` (plain JSON, not a secret).
  *
  * Uniqueness of the device is enforced by the partial unique index on the
- * extracted `machineToken`; this store keeps the JS side of that invariant
- * and surfaces the DB constraint as the backstop.
+ * extracted `machineToken`; this store keeps the JS side of that internal
+ * identity-allocation invariant and surfaces the DB constraint as the backstop.
  */
 import { and, eq, isNotNull, ne } from "drizzle-orm";
 import type { CartethyiaDatabase } from "../../../persistence/db-handle";
@@ -30,7 +31,7 @@ export interface QoderNativeIdentityStore {
   get(providerId: string, accountId: string): Promise<NativeIdentityRecord | undefined>;
   /**
    * Machine tokens already bound to **other** accounts, so a caller can mint
-   * a fresh device without colliding. A bound token is a physical device, and
+   * a fresh identity without colliding. A bound token represents a device identity, and
    * the unique index that backs this spans all `provider_accounts` rows. The
    * account's own bound token is not "occupied" — reusing one's own device is
    * the point.