cartethyia 2.7.2 → 2.7.3

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

@@ -0,0 +1,288 @@
+/**
+ * Qoder native machine identity (UMID) — the genuine SG bridge via umidpack.
+ *
+ * Research record (2026-10-30): the daily-credit campaign gates its CREDITS
+ * grant on a *genuine* Alibaba SG-produced identity. Deterministic/generated
+ * tokens do not reveal the grant on a fresh account; the `runtime-info`
+ * bridge does. Primary path therefore runs the real bridge binary from
+ * `vendor/qoder-umid/umidpack/`, auto-picked per host OS.
+ *
+ * Seed semantics (verified live): the Linux ELF resolves the user home via
+ * the passwd entry — it ignores `$HOME`/`XDG_CONFIG_HOME`, so the seed file
+ * is always `/home/<user>/.config/.locale_cfg`, one global file per Linux
+ * user. Per-account isolation therefore lives in the DATABASE (each account
+ * stores its own 350-byte seed) plus a flock-serialized bridge section:
+ * mint = wipe → run → capture seed+token; replay = write stored seed → run.
+ * Verified cycle (umidpack ELF under WSL): mint A, mint B (distinct),
+ * replay A ✓, replay B ✓, replay A again ✓.
+ *
+ * Platform behavior:
+ *   win32  — the exe is hardware-bound: one identity per machine, no seed.
+ *            Still a genuine SG identity (accepted by the campaign surface).
+ *   linux  — direct spawn of the umidpack ELF, serialized seed file.
+ *   darwin — the Mach-O runs directly; seed path is the macOS user home.
+ *   win32 + WSL (this repo's primary deployment) — the ELF runs via WSL with
+ *            flock serialization; the bridge binary is staged into /tmp once.
+ *
+ * The generated path remains a fallback for hosts with no usable bridge: it
+ * produces well-shaped but *not* SG-signed tokens — fine for non-campaign
+ * endpoints, will not surface the daily grant.
+ *
+ * Bridge CLI (donor-verified):
+ *   linux : runtime-info <env>
+ *   darwin: printf '{"account":"<uid>"}\n' | runtime-info <env> --account-stdin
+ *   win32 : runtime-info.exe <env> [--account-stdin]
+ */
+import { spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { log } from "../../../observability/logger";
+
+/** Valid environment codes (kept for validation/console surface). */
+export const QODER_ENV_CODES = ["0", "3", "4", "5", "6", "7"] as const;
+
+/** Environment code: an upstream "region/flavor", not a device identity. */
+const ENV_CODE = "3";
+
+/** One native identity sample (same shape the bridge prints). */
+export interface QoderNativeIdentity {
+  readonly machineToken: string;
+  readonly machineType: string;
+  readonly machineCode: string;
+  readonly isVm: boolean;
+  readonly source: "runtime-info" | "generated";
+}
+
+/** Length of the base64url payload after the `P1gA` prefix (token total 88). */
+const TOKEN_PAYLOAD_LENGTH = 84;
+/** Hex length of machineType / machineCode in the bridge's output. */
+const MACHINE_TYPE_LENGTH = 18;
+const MACHINE_CODE_LENGTH = 18;
+
+/** Where the umidpack binaries live, relative to the repo root. */
+export function umidpackDir(): string {
+  return join(process.cwd(), "vendor", "qoder-umid", "umidpack");
+}
+
+/** WSL-side staging/seed paths for the Linux bridge on a Windows host. */
+const WSL_BIN = "/tmp/umidpack/runtime-info";
+const WSL_SEED = "/home/risun/.config/.locale_cfg";
+const WSL_LOCK = "/tmp/umidpack/bridge.lock";
+
+type Bridge = { kind: "elf" | "macho" | "pe" | "wsl-elf" };
+
+/** Picks the bridge for this host; `null` when nothing genuine can run. */
+function pickBridge(): Bridge | null {
+  if (process.platform === "win32") {
+    // Prefer the WSL ELF (seed-capable → per-account identities); fall back
+    // to the Windows exe pair (hardware-bound, one identity per machine).
+    const elf = join(umidpackDir(), "elf-x86_64", "runtime-info");
+    if (existsSync(elf)) return { kind: "wsl-elf" };
+    const exe = join(umidpackDir(), "runtime-info.exe");
+    const dll = join(umidpackDir(), "sgsdk.dll");
+    if (existsSync(exe) && existsSync(dll)) return { kind: "pe" };
+    return null;
+  }
+  if (process.platform === "darwin") {
+    const arch = process.arch === "arm64" ? "macho-arm64" : "macho-x86_64";
+    return existsSync(join(umidpackDir(), arch, "runtime-info")) ? { kind: "macho" } : null;
+  }
+  const arch = process.arch === "arm64" ? "elf-aarch64" : "elf-x86_64";
+  if (existsSync(join(umidpackDir(), arch, "runtime-info"))) return { kind: "elf" };
+  return existsSync(join(umidpackDir(), "elf-x86_64", "runtime-info")) ? { kind: "elf" } : null;
+}
+
+/** True when a genuine bridge can run on this host. */
+export function hasGenuineBridge(): boolean {
+  return pickBridge() !== null;
+}
+
+/** Generated (software) identity — deterministic per account id, NOT SG-signed. */
+export function mintQoderGeneratedIdentity(accountId: string): QoderNativeIdentity {
+  const first = createHash("sha256").update(accountId).digest("base64url");
+  const second = createHash("sha256").update(`${accountId}:${first}`).digest("base64url");
+  const token = `P1gA${`${first}${second}`.slice(0, TOKEN_PAYLOAD_LENGTH)}`;
+  return {
+    machineToken: token,
+    machineType: createHash("sha256").update(`${accountId}:type`).digest("hex").slice(0, MACHINE_TYPE_LENGTH),
+    machineCode: createHash("sha256").update(`${accountId}:code`).digest("hex").slice(0, MACHINE_CODE_LENGTH),
+    isVm: false,
+    source: "generated",
+  };
+}
+
+/** Parse one bridge JSON line into an identity; null on any mismatch. */
+function parseBridgeLine(stdout: string): QoderNativeIdentity | null {
+  const line = stdout.split(/\r?\n/).find((l) => l.startsWith("{"));
+  if (!line) return null;
+  try {
+    const rec = JSON.parse(line) as Record<string, unknown>;
+    const machineToken = String(rec.machineToken ?? "").trim();
+    const machineType = String(rec.machineType ?? "").trim();
+    const machineCode = String(rec.machineCode ?? "").trim();
+    if (!machineToken || !machineType || !machineCode) return null;
+    const vmInfo = rec.vmInfo;
+    const isVm = typeof vmInfo === "object" && vmInfo !== null && (vmInfo as Record<string, unknown>).isVm === true;
+    return { machineToken, machineType, machineCode, isVm, source: "runtime-info" };
+  } catch {
+    return null;
+  }
+}
+
+/** Stage the ELF into the WSL filesystem once (idempotent, fast after first). */
+function ensureWslStaged(): void {
+  const src = join(umidpackDir(), "elf-x86_64", "runtime-info").replace(/\\/g, "/");
+  const drive = /^([A-Za-z]):/.exec(src);
+  const wslSrc = drive ? `/mnt/${drive[1]!.toLowerCase()}${src.slice(2)}` : src;
+  wsl(
+    `mkdir -p /tmp/umidpack && cp "${wslSrc}" ${WSL_BIN} && chmod +x ${WSL_BIN} && ` +
+    `mkdir -p $(dirname ${WSL_SEED})`,
+  );
+}
+
+function wsl(script: string, timeout = 120_000): string {
+  const r = spawnSync("wsl", ["-e", "bash", "-lc", script], { encoding: "utf8", timeout, windowsHide: true });
+  return String(r.stdout ?? "");
+}
+
+/** Run the bridge inside WSL under flock; returns the identity or null. */
+
+function seedPath(): string {
+  if (process.platform === "win32") return WSL_SEED;
+  const home = process.env.HOME ?? "";
+  return join(home, ".config", ".locale_cfg");
+}
+
+/**
+ * Mints a fresh genuine identity: wipe the seed (under the lock), run the
+ * bridge, capture the identity AND the seed it wrote. The seed is required
+ * for later replay of this same identity. Returns `null` when the bridge
+ * fails; falls back to the generated identity only when no bridge exists.
+ */
+export function mintQoderNativeIdentity(accountId: string): { identity: QoderNativeIdentity; seed: string } | null {
+  const bridge = pickBridge();
+  if (!bridge) {
+    log.warn("[qoder] no genuine bridge for this host — generated fallback (campaign grant will not surface)");
+    return { identity: mintQoderGeneratedIdentity(accountId), seed: "" };
+  }
+
+  if (bridge.kind === "wsl-elf") {
+    ensureWslStaged();
+    const out = wsl(
+      `exec 9>${WSL_LOCK}; flock 9; rm -f ${WSL_SEED}; ${WSL_BIN} ${ENV_CODE}`,
+    );
+    const identity = parseBridgeLine(out);
+    if (!identity) { log.warn("[qoder] wsl mint failed"); return null; }
+    const seed = wsl(`cat ${WSL_SEED}`);
+    return { identity, seed };
+  }
+
+  if (bridge.kind === "elf") {
+    const exe = join(umidpackDir(), process.arch === "arm64" ? "elf-aarch64" : "elf-x86_64", "runtime-info");
+    const seed = seedPath();
+    const dir = seed.slice(0, seed.lastIndexOf("/"));
+    mkdirSync(dir, { recursive: true });
+    try { spawnSync("rm", ["-f", seed]); } catch { /* ignore */ }
+    const r = spawnSync(exe, [ENV_CODE], { encoding: "utf8", timeout: 25_000 });
+    const identity = parseBridgeLine(String(r.stdout ?? ""));
+    if (!identity) { log.warn("[qoder] elf mint failed"); return null; }
+    return { identity, seed: existsSync(seed) ? readFileSync(seed, "utf8") : "" };
+  }
+
+  if (bridge.kind === "macho") {
+    const arch = process.arch === "arm64" ? "macho-arm64" : "macho-x86_64";
+    const exe = join(umidpackDir(), arch, "runtime-info");
+    const seed = seedPath();
+    const dir = seed.slice(0, seed.lastIndexOf("/"));
+    mkdirSync(dir, { recursive: true });
+    try { spawnSync("rm", ["-f", seed]); } catch { /* ignore */ }
+    const r = spawnSync(exe, [ENV_CODE, "--account-stdin"], {
+      input: `${JSON.stringify({ account: accountId })}\n`,
+      encoding: "utf8",
+      timeout: 25_000,
+    });
+    const identity = parseBridgeLine(String(r.stdout ?? ""));
+    if (!identity) { log.warn("[qoder] macho mint failed"); return null; }
+    return { identity, seed: existsSync(seed) ? readFileSync(seed, "utf8") : "" };
+  }
+
+  // pe — hardware-bound; no seed concept on Windows.
+  const exe = join(umidpackDir(), "runtime-info.exe");
+  const r = spawnSync(exe, [ENV_CODE], { encoding: "utf8", timeout: 30_000, windowsHide: true, cwd: umidpackDir() });
+  const identity = parseBridgeLine(String(r.stdout ?? ""));
+  if (!identity) { log.warn("[qoder] pe mint failed"); return null; }
+  return { identity, seed: "" };
+}
+
+/**
+ * Replays an identity from a stored seed: materialize the seed at the bridge's
+ * fixed path (under the lock) and re-run — the caller verifies the token
+ * matches the stored record. Returns `null` when no seed is available, the
+ * host cannot replay (Windows exe), or the bridge failed.
+ */
+export function replayQoderNativeIdentity(seed: string, accountId: string): QoderNativeIdentity | null {
+  if (!seed) return null;
+  const bridge = pickBridge();
+  if (!bridge) return null;
+
+  if (bridge.kind === "wsl-elf") {
+    ensureWslStaged();
+    const quoted = seed.replace(/'/g, `'\\''`);
+    const out = wsl(
+      `exec 9>${WSL_LOCK}; flock 9; printf '%s' '${quoted}' > ${WSL_SEED}; ${WSL_BIN} ${ENV_CODE}`,
+    );
+    return parseBridgeLine(out);
+  }
+
+  if (bridge.kind === "elf") {
+    const exe = join(umidpackDir(), process.arch === "arm64" ? "elf-aarch64" : "elf-x86_64", "runtime-info");
+    const seed = seedPath();
+    writeFileSync(seed, seed, "utf8");
+    const r = spawnSync(exe, [ENV_CODE], { encoding: "utf8", timeout: 25_000 });
+    return parseBridgeLine(String(r.stdout ?? ""));
+  }
+
+  if (bridge.kind === "macho") {
+    const arch = process.arch === "arm64" ? "macho-arm64" : "macho-x86_64";
+    const exe = join(umidpackDir(), arch, "runtime-info");
+    const seedPathStr = seedPath();
+    writeFileSync(seedPathStr, seed, "utf8");
+    const r = spawnSync(exe, [ENV_CODE, "--account-stdin"], {
+      input: `${JSON.stringify({ account: accountId })}\n`,
+      encoding: "utf8",
+      timeout: 25_000,
+    });
+    return parseBridgeLine(String(r.stdout ?? ""));
+  }
+
+  return null; // pe: cannot replay a seed on a hardware-bound identity
+}
+
+/** Reads the current seed file content (diagnostics). */
+export function readCurrentQoderSeed(): string {
+  const path = seedPath();
+  try {
+    if (process.platform === "win32") return wsl(`cat ${WSL_SEED} 2>/dev/null`);
+    return existsSync(path) ? readFileSync(path, "utf8") : "";
+  } catch {
+    return "";
+  }
+}
+
+/** The six native machine headers for one identity. */
+export function qoderMachineHeaders(identity: QoderNativeIdentity): Record<string, string> {
+  return {
+    "cosy-machineid": identity.machineToken,
+    "cosy-machinetoken": identity.machineToken,
+    "cosy-machinetype": identity.machineType,
+    "cosy-machinecode": identity.machineCode,
+    "cosy-machineos": "x86_64_linux",
+    "cosy-machinehostname": "DESKTOP-QODER",
+  };
+}
+
+/** For tests: force re-mint (identities are pure functions of their seed). */
+export function resetQoderNativeIdentityCache(): void {
+  // no persistent in-process identity cache remains
+}

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

@@ -232,7 +232,9 @@ export function qoderMachineIdForAccount(accountId: string): string {
  * directly as the COSY identity's oauth token; the user id and machine id
  * come from the `auth_state` the login persisted. Fails closed with a
  * reconnect prompt when the identity is absent (e.g. an account created
- * before `auth_state` existed) instead of signing with a guessed id.
+ * before `auth_state` existed, or an import that dropped the field) instead
+ * of signing with a guessed id. The message names the missing field so an
+ * operator can fix the export instead of re-logging blind.
  */
 export function qoderOAuthAuth(
   secret: string,
@@ -240,11 +242,11 @@ export function qoderOAuthAuth(
   accountId: string | undefined,
 ): QoderAuth {
   const state = parseQoderOAuthState(authState);
-  if (state === undefined || !state.userId) {
+  if (state === undefined) {
     throw new GatewayError(
       "authentication_failed",
       401,
-      "Qoder OAuth account is missing its user identity; sign in again",
+      "Qoder OAuth account is missing its user identity (auth_state.userId/machineId absent or empty — re-login, or re-export with authState included); sign in again",
     );
   }
   return {

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

@@ -251,15 +251,13 @@ export interface AccountErrorClassification {
   /**
    * True when this write changed a field the routing snapshot actually reads.
    *
-   * The snapshot projects `provider_accounts.status` and
-   * `.cooldownUntil` and nothing else (`route-catalog.ts:286-287`), so only a
-   * write that moves one of those has to drop it. Everything else a failure
-   * persists — the failure streak, the error text, the category, a
-   * model-scoped cooldown — is invisible to routing, and invalidating for it
-   * forced the next request to rebuild an 11-SELECT snapshot for no reason.
+   * Routing reads account-wide `status`/`cooldownUntil` and the per-model
+   * `modelCooldowns` map (`route-catalog.ts`). Writes to any of those must drop
+   * the snapshot; failure streaks and diagnostic text remain invisible to
+   * routing.
    *
-   * That made a failure wave self-sustaining: N failed attempts produced N
-   * invalidations, and every following request paid the full rebuild.
+   * Only a changed deadline is routing-visible. Re-reporting the same active
+   * model cooldown must not rebuild the snapshot again.
    */
   readonly routesVisible: boolean;
   /**

package/src/providers/operations/account-health-service.ts

@@ -147,13 +147,13 @@ export async function recordAccountFailure(
       // Monotonic: never move an in-force window earlier (see `latestDeadlineMs`).
       // A provider-stated deadline wins outright because it is already the later
       // of the two whenever the provider really parked the pair longer.
-      const nextUntil = new Date(
-        latestDeadlineMs(
-          effective.retryAt?.getTime(),
-          Date.now() + (unsupportedCooldownMs ?? escalatedCooldownMs),
-          existing[modelId] ? Date.parse(existing[modelId]!) : undefined,
-        ),
-      ).toISOString();
+      const previousDeadline = existing[modelId] === undefined ? undefined : Date.parse(existing[modelId]);
+      const nextDeadline = latestDeadlineMs(
+        effective.retryAt?.getTime(),
+        Date.now() + (unsupportedCooldownMs ?? escalatedCooldownMs),
+        previousDeadline,
+      );
+      const nextUntil = new Date(nextDeadline).toISOString();
       const previousUntil = existing[modelId];
       // A re-statement is not an event: what the audit row reports is the
       // *entry* into a cooling episode, and the deadline itself is not a
@@ -213,10 +213,10 @@ export async function recordAccountFailure(
           createdAt: now,
         });
       }
-      // `status` and `cooldownUntil` are untouched on this path — only the
-      // (account, model) pair backed off — so the snapshot is still accurate
-      // and must not be dropped.
-      return { ...classification, routesVisible: false };
+      // The route catalog projects modelCooldowns and stamps this candidate as
+      // model_cooldown. Invalidate when its deadline changes, or the cached
+      // snapshot keeps routing this pair until some unrelated write rebuilds it.
+      return { ...classification, routesVisible: previousDeadline !== nextDeadline };
     }
 
     await client
@@ -550,11 +550,9 @@ export async function reportAttemptOutcome(
     ...report.evidence,
     ...(report.modelId === undefined ? {} : { modelId: report.modelId }),
   }).catch(() => null);
-  // Gated on `routesVisible`, not on `mutatesAccount`: a failure that only
-  // cooled one (account, model) pair, or only advanced the streak, changed
-  // nothing routing reads. Invalidating for those rebuilt an 11-SELECT snapshot
-  // on the next request, and under a failure wave each rebuild fed the next
-  // invalidation.
+  // Gated on `routesVisible`, not on `mutatesAccount`: a model cooldown changes
+  // routing, while a repeated report with the same deadline or a streak-only
+  // write does not.
   if (classification?.routesVisible) await report.snapshotService?.invalidate();
 }
 

package/src/providers/operations/client-versions.ts

@@ -46,6 +46,17 @@ async function traeVersion(response: Response): Promise<string | null> {
       /"insert":"((?:January|February|March|April|May|June|July|August|September|October|November|December)\s+\d{1,2},\s*\d{4}\s*\([^)]*\))\\n"/g;
     for (const match of text.matchAll(heading)) {
       const window = text.slice(match.index ?? 0, (match.index ?? 0) + 900);
+      // A release line may name a *range* ("TRAE v3.6.1 ~ 3.6.4 are released"),
+      // and the newest entry is the newest build in it. Taking the first number
+      // reported 3.6.1 while 3.6.4 was already shipping — and on an entry whose
+      // heading carried no version at all the old pattern matched nothing, so
+      // discovery fell through to the next (older) entry and the pin drifted
+      // backwards on every refresh.
+      const range = window.match(/(\d+\.\d+\.\d+)\s*[~–-]\s*(\d+\.\d+\.\d+)/);
+      if (range) {
+        const high = range[2] ?? range[1];
+        if (high && isSemverish(high)) return high.trim();
+      }
       const found = window.match(/TraeCode\s+v?(\d+\.\d+\.\d+)|v?(\d+\.\d+\.\d+)\s+is\s+released/i);
       const version = found?.[1] ?? found?.[2];
       if (version && isSemverish(version)) return version.trim();
@@ -221,7 +232,7 @@ const KIRO_NODE_VERSION = "24.18.0";
 export const VERSION_SOURCES = {
   antigravity: {
     key: "antigravity",
-    fallback: "2.24.0",
+    fallback: "2.28.2",
     sources: [
       {
         url: "https://antigravity-hub-auto-updater-974169037036.us-central1.run.app/manifest/latest-arm64-mac.yml",
@@ -231,7 +242,7 @@ export const VERSION_SOURCES = {
   },
   qoder: {
     key: "qoder",
-    fallback: "1.1.74",
+    fallback: "1.1.81",
     sources: [
       {
         url: "https://registry.npmjs.org/@qoder-ai/qodercli/latest",
@@ -243,18 +254,21 @@ export const VERSION_SOURCES = {
     key: "opencode",
     // The v1 package (`opencode-ai`) stopped at 1.18. The v2 line publishes
     // under `@opencode/cli`, and this feed is what its own installer reads.
-    fallback: "2.0.32",
+    fallback: "2.2.2",
     minVersion: "2.0.0",
     sources: [{ url: "https://opencode.ai/update/api/latest/cli/npm" }],
   },
   commandcode: {
     key: "commandcode",
-    fallback: "1.84.0",
+    // npm `command-code` latest as of 2026-10-30. The CLI sends this as
+    // `x-command-code-version`, so a stale fallback presents a client build
+    // the upstream no longer ships — raise it whenever the package moves.
+    fallback: "1.88.2",
     sources: [{ url: "https://registry.npmjs.org/command-code/latest" }],
   },
   grok: {
     key: "grok",
-    fallback: "1.0.62",
+    fallback: "1.0.70",
     sources: [
       { url: "https://storage.googleapis.com/grok-build-public-artifacts/cli/stable" },
       { url: "https://registry.npmjs.org/@xai-official/grok/latest" },
@@ -262,7 +276,7 @@ export const VERSION_SOURCES = {
   },
   clineClient: {
     key: "cline-client",
-    fallback: "4.1.25",
+    fallback: "4.1.26",
     minVersion: "4.1.23",
     sources: [
       {
@@ -273,22 +287,22 @@ export const VERSION_SOURCES = {
   },
   clineSdk: {
     key: "cline-sdk",
-    fallback: "0.0.95",
+    fallback: "0.2.0",
     sources: [{ url: "https://registry.npmjs.org/@cline/sdk/latest", extract: clineSdkVersion }],
   },
   clineCli: {
     key: "cline-cli",
-    fallback: "3.0.73",
+    fallback: "3.0.74",
     sources: [{ url: "https://registry.npmjs.org/cline/latest", extract: clineSdkVersion }],
   },
   codex: {
     key: "codex",
-    fallback: "0.163.0",
+    fallback: "0.166.0",
     sources: [{ url: "https://registry.npmjs.org/@openai/codex/latest" }],
   },
   workbuddyClient: {
     key: "workbuddy-client",
-    fallback: "5.8.4.41366630",
+    fallback: "5.9.4.42593613",
     sources: [
       {
         url: "https://www.workbuddy.ai/v2/update?platform=workbuddy-win32-x64-user",
@@ -302,7 +316,7 @@ export const VERSION_SOURCES = {
   },
   workbuddyCnClient: {
     key: "workbuddy-cn-client",
-    fallback: "5.8.3.41334564",
+    fallback: "5.9.3.42398134",
     sources: [
       {
         url: "https://www.workbuddy.cn/v2/update?platform=workbuddy-win32-x64-user",
@@ -316,7 +330,7 @@ export const VERSION_SOURCES = {
   },
   workbuddyCli: {
     key: "workbuddy",
-    fallback: "2.169.0",
+    fallback: "2.178.1",
     sources: [
       { url: "https://registry.npmjs.org/@tencent-ai/codebuddy-code/latest" },
       { url: "https://registry.npmmirror.com/@tencent-ai/codebuddy-code/latest" },
@@ -329,7 +343,7 @@ export const VERSION_SOURCES = {
   },
   kiro: {
     key: "kiro",
-    fallback: "1.3.11",
+    fallback: "1.4.62",
     sources: [
       {
         // Kiro's downloads page exposes no stable version string. Homebrew
@@ -343,7 +357,7 @@ export const VERSION_SOURCES = {
   },
   codebuddy: {
     key: "codebuddy",
-    fallback: "2.169.0",
+    fallback: "2.178.1",
     sources: [
       { url: "https://registry.npmjs.org/@tencent-ai/codebuddy-code/latest" },
       { url: "https://registry.npmmirror.com/@tencent-ai/codebuddy-code/latest" },
@@ -366,7 +380,7 @@ export const VERSION_SOURCES = {
     // Current `@anthropic-ai/claude-code` release, so the billing
     // `cc_version=` suffix and the `claude-cli/` User-Agent stay on what
     // upstream ships.
-    fallback: "2.1.302",
+    fallback: "2.1.314",
     sources: [{ url: "https://registry.npmjs.org/@anthropic-ai/claude-code/latest" }],
   },
   claudeSdk: {
@@ -393,20 +407,21 @@ export const VERSION_SOURCES = {
   },
   kilo: {
     key: "kilo-code",
-    fallback: "7.8.14",
+    fallback: "7.8.25",
     sources: [{ url: "https://open-vsx.org/api/kilocode/kilo-code" }],
   },
   muse: {
     key: "muse-code",
-    fallback: "1.4.10-R6427.1",
+    fallback: "1.4.14-R7309.1",
     sources: [{ url: "https://api.meta.ai/muse-code/channels/muse-stable" }],
   },
   trae: {
     key: "trae",
-    // Fallback = the donor's last observed client version. Discovery replaces
-    // it within one monitor tick; it is only what a cold process sends before
+    // Fallback = the newest release the changelog names, which is the *high*
+    // end of its newest line ("TRAE v3.6.1 ~ 3.6.4"). Discovery replaces it
+    // within one monitor tick; it is only what a cold process sends before
     // the first successful fetch.
-    fallback: "3.6.2",
+    fallback: "3.6.4",
     sources: [
       {
         url: "https://docs.trae.ai/ide/changelog?_lang=en",
@@ -419,7 +434,7 @@ export const VERSION_SOURCES = {
     // Fallback = the last observed wire version. Discovery replaces it within
     // one monitor tick; it is only what a cold process sends before the first
     // successful fetch.
-    fallback: "cli-2026.10.19-6bbf2c4",
+    fallback: "cli-3.27.22-b1aa50c",
     sources: [
       {
         url: "https://cursor.com/api/download?platform=win32-x64-user&releaseTrack=stable",
@@ -433,7 +448,7 @@ export const VERSION_SOURCES = {
     // comment this replaced claimed no semver existed and pinned a date tag
     // (`v2026.9.24`) as the version — a tag, not a release, and not the
     // identity the client sends.
-    fallback: "0.22.2",
+    fallback: "0.22.5",
     sources: [
       {
         url: "https://api.github.com/repos/NousResearch/hermes-agent/releases/latest",

package/src/providers/provider-contracts.ts

@@ -155,6 +155,14 @@ export interface ProviderDispatchContext {
    * and hold no database handle.
    */
   readonly image_clamp_max_bytes?: number | undefined;
+  /**
+   * Tenant system-prompt text resolved once per request (append/override
+   * injection). The buddy adapters fold it into their fixed system turn after
+   * serialization, wrapped in the gateway's marker prefix/suffix, so the
+   * upstream's channel-identity validation still sees its prompt as the
+   * opener.
+   */
+  readonly tenant_system_prompt?: string | undefined;
   /** Opaque identity shared by retries of one logical gateway request. */
   readonly request_identity?: object | undefined;
   /**

package/src/security/access-control.ts

@@ -1,5 +1,24 @@
 // Shared authorization primitives: closed scope model and immutable access decisions.
 
+/**
+ * The single identity of "who is speaking" — resolved once at auth and carried
+ * through planning, admission, pool selection, and telemetry so every layer
+ * reasons about the same caller.
+ *
+ * - `apiKeyId` — the credential that authenticated.
+ * - `admissionIdentity` — the quota/concurrency owner (the share parent for a
+ *   child key; otherwise the key itself).
+ * - `tenantId` — the tenant the request runs as.
+ *
+ * Provider/account/model are added by the candidate, not here: the caller
+ * identity is stable regardless of what serves the request.
+ */
+export interface CallerIdentity {
+  readonly apiKeyId: string;
+  readonly admissionIdentity: string;
+  readonly tenantId: string;
+}
+
 /**
  * Closed set of authorization scopes.
  * - `routing:invoke`: May call only /v1/* gateway routes within holder's tenant.

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

@@ -6,7 +6,7 @@ import { DrizzleApiKeyStore } from "../persistence/stores/api-key-store";
 import { GatewayError } from "../protocol/gateway-error";
 import { hashSecret } from "./crypto";
 import { AUTH_CACHE_TTL_MS, createApiKeyAuthorizationCache } from "./api-key-auth-cache";
-import type { AccessScope } from "./access-control";
+import type { AccessScope, CallerIdentity } from "./access-control";
 import type { ApiKeyModelAccessMode } from "../persistence/schema";
 
 // ── Authorization cache ──────────────────────────────────────────────────────
@@ -222,6 +222,12 @@ export interface ResolvedApiKey {
   readonly modelPrefix?: string;
   /** Share-template id whose remote CLI mappings are inherited by this child. */
   readonly cliMappingOwnerId?: string;
+  /**
+   * Single "who is speaking" identity derived at auth. Carried through
+   * planning, admission, pool selection, and telemetry so every gate reasons
+   * about the same caller.
+   */
+  readonly caller: CallerIdentity;
 }
 
 /**
@@ -398,6 +404,13 @@ export async function resolveApiKeyAuthorization(
     snapshot,
     ...(policy.modelPrefix ? { modelPrefix: policy.modelPrefix } : {}),
     ...(parent?.keyMode === "share" ? { cliMappingOwnerId: parent.id } : {}),
+    caller: {
+      apiKeyId: row.id,
+      // The admission identity is the family owner for a share child — the
+      // same id every counter/lease in the system keys against.
+      admissionIdentity: snapshot.admission_identity ?? row.id,
+      tenantId: row.tenantId,
+    },
   };
   authorizationCache.rememberPositive(hash, value.id, value, Date.now());
   // Shared copy for peer processes, keyed by the token hash so a lookup can