dsh-workbuddy-connect 0.4.0 → 0.5.0

package/lib/index.js

@@ -1,15 +1,136 @@
-import { C as defaultDesktopAuthPath, S as defaultDesktopAuthCandidates, T as workbuddyOwnAuthPath, _ as FALLBACK_WORKBUDDY_MODELS, a as readHostHeartbeat, b as WORKBUDDY_AUTH_FILE_ENV, c as WORKBUDDY_CONNECT_VERSION, d as normalizeCredits, f as prepareChatBody, g as randomSentinel, h as probeModel, i as processStartTimeMs, l as WorkBuddyUpstreamClient, m as PROBE_EFFORT_CANDIDATES, n as clearHostHeartbeat, o as workbuddyHostHeartbeatPath, p as regionOf, r as isHeartbeatProcessAlive, s as writeHostHeartbeat, t as WORKBUDDY_HOST_HEARTBEAT_FILENAME, u as classifyUpstreamError, v as WorkBuddyCatalog, w as parseWorkBuddyAuth, x as WorkBuddyCredentialStore, y as WORKBUDDY_AUTH_FILENAME } from "./host-heartbeat-0UAWqWac.js";
+import { A as parseModelCatalog, B as readBundleVersion, C as desktopAuthCandidatesFor, D as classifyUpstreamError, E as WorkBuddyUpstreamClient, F as probeModel, H as validAppVersion, I as randomSentinel, L as WORKBUDDY_APP_VERSION_FILENAME, M as prepareInternationalChatBody, N as regionOf, O as modelWithCurrentPromotion, P as PROBE_EFFORT_CANDIDATES, R as appUserAgent, S as defaultDesktopAuthPath, T as workbuddyOwnAuthPath, V as resolveAppVersion, _ as WorkBuddyCatalog, a as WORKBUDDY_HOST_HEARTBEAT_FILENAME, b as WorkBuddyCredentialStore, c as processStartTimeMs, d as writeHostHeartbeat, f as WORKBUDDY_CONNECT_VERSION, g as FALLBACK_WORKBUDDY_MODELS, h as FALLBACK_WORKBUDDY_AI_MODELS, i as variantFor, j as prepareChatBody, k as normalizeCredits, l as readHostHeartbeat, n as CN_VARIANT, o as clearHostHeartbeat, r as WORKBUDDY_VARIANTS, s as isHeartbeatProcessAlive, t as AI_VARIANT, u as workbuddyHostHeartbeatPath, v as WORKBUDDY_AUTH_FILENAME, w as parseWorkBuddyAuth, x as defaultDesktopAuthCandidates, y as WORKBUDDY_AUTH_FILE_ENV, z as installedAppVersion } from "./variants-GgLTJgZs.js";
 import z from "@deepseek-ai/schemastery";
 import { dirname, join, resolve } from "node:path";
 import { resolveDshHome } from "@deepseek-ai/dsh-home-paths";
+import { createHash, randomBytes, timingSafeEqual } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { createProvider } from "@earendil-works/pi-ai";
 import { openAICompletionsApi } from "@earendil-works/pi-ai/api/openai-completions.lazy";
 import { resolveRetryPolicy } from "@deepseek-ai/dsh-llm";
 import { PiAiAdapter } from "@deepseek-ai/dsh-llm-pi-ai";
-import { createHash, randomBytes, timingSafeEqual } from "node:crypto";
 import { createServer } from "node:http";
 import { Readable } from "node:stream";
-import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+//#region src/catalog-store.ts
+/**
+* The last catalog that actually loaded, kept per variant and per account.
+*
+* Both the plan (§4 "降级顺序为同版同来源的最近成功目录 → 本版内置保守目录")
+* and the README promise this fallback, and without it a restart always drops
+* the user to the built-in roster even when a good catalog was fetched minutes
+* earlier. The built-in roster is a snapshot taken once; a fetched catalog is
+* what the upstream actually serves to this account.
+*
+* What it deliberately is *not*:
+*
+* - not a cache with a freshness policy — it never prevents a fetch, it only
+*   answers when a fetch cannot;
+* - not shared across accounts (a different account can see a different roster
+*   and different promotions), nor across variants (the CN and international
+*   endpoints disagree about rates and windows for the same model id);
+* - not a place for secrets: model metadata only, never a token. The account
+*   key is a `uid:enterpriseId` identity already visible in the status document.
+*
+* @module dsh-workbuddy-connect/catalog-store
+*/
+/** On-disk format this reader accepts; other versions are discarded. */
+const CATALOG_FORMAT_VERSION = 1;
+/** Basename of the CN variant's saved catalog inside the Harness home. */
+const WORKBUDDY_CATALOG_FILENAME = ".workbuddy-catalog.json";
+/** Plugin-owned saved-catalog path inside the Harness home. */
+function workbuddyCatalogPath(filename = WORKBUDDY_CATALOG_FILENAME) {
+	return join(resolveDshHome(), filename);
+}
+/** Whether a parsed value is a model row worth keeping. */
+function isModel(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	const row = value;
+	return typeof row["id"] === "string" && row["id"] !== "" && typeof row["name"] === "string" && typeof row["contextWindow"] === "number" && Number.isFinite(row["contextWindow"]) && typeof row["maxTokens"] === "number" && Number.isFinite(row["maxTokens"]) && typeof row["supportsImages"] === "boolean";
+}
+/** Whether a parsed value is a saved catalog this reader can trust. */
+function isSaved(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	const entry = value;
+	if (typeof entry["account"] !== "string" || entry["account"] === "") return false;
+	if (typeof entry["source"] !== "string" || entry["source"] === "") return false;
+	if (typeof entry["fetchedAtMs"] !== "number" || !Number.isFinite(entry["fetchedAtMs"])) return false;
+	const models = entry["models"];
+	if (!Array.isArray(models) || models.length === 0) return false;
+	return models.every(isModel);
+}
+/**
+* The last successful catalog per account, read once and written atomically.
+*
+* Malformed content reads as "nothing saved" rather than throwing: this file
+* is an optimization for the offline and first-seconds cases, and a corrupt one
+* must never be able to stop the plugin from serving models.
+*/
+var WorkBuddyCatalogStore = class {
+	path;
+	entries;
+	constructor(options = {}) {
+		this.path = typeof options === "string" ? options : options.path ?? workbuddyCatalogPath();
+	}
+	/** Resolved state-file path, for the CLI and tests. */
+	filePath() {
+		return this.path;
+	}
+	load() {
+		if (this.entries !== void 0) return this.entries;
+		const entries = {};
+		if (existsSync(this.path)) try {
+			const parsed = JSON.parse(readFileSync(this.path, "utf8"));
+			if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+				const document = parsed;
+				const raw = document["version"] === CATALOG_FORMAT_VERSION ? document["entries"] : void 0;
+				if (typeof raw === "object" && raw !== null && !Array.isArray(raw)) {
+					for (const [key, value] of Object.entries(raw)) if (isSaved(value)) entries[key] = value;
+				}
+			}
+		} catch {}
+		this.entries = entries;
+		return entries;
+	}
+	/** The saved catalog for one account, or `undefined` when there is none. */
+	get(account) {
+		const entry = this.load()[account];
+		return entry === void 0 ? void 0 : entry;
+	}
+	/**
+	* Remember a catalog for an account, replacing whatever was saved before.
+	*
+	* A failed write is swallowed: the plugin has already served these models,
+	* and losing the *memory* of them is not worth surfacing.
+	*/
+	set(account, catalog) {
+		const entries = this.load();
+		entries[account] = {
+			account,
+			...catalog
+		};
+		this.persist();
+	}
+	/** Forget one account's catalog — used when that account signs out. */
+	delete(account) {
+		const entries = this.load();
+		if (!(account in entries)) return;
+		delete entries[account];
+		this.persist();
+	}
+	persist() {
+		const directory = dirname(this.path);
+		try {
+			if (!existsSync(directory)) mkdirSync(directory, { recursive: true });
+			const document = {
+				version: CATALOG_FORMAT_VERSION,
+				entries: this.load()
+			};
+			const temporary = resolve(`${this.path}.tmp`);
+			writeFileSync(temporary, `${JSON.stringify(document, null, 2)}\n`, { mode: 384 });
+			renameSync(temporary, this.path);
+		} catch {}
+	}
+};
+//#endregion
 //#region src/adapter.ts
 /**
 * The `workbuddy` pi-ai provider: one loopback-backed adapter registered
@@ -154,18 +275,19 @@ function reasoningFields(info, observed) {
 	};
 }
 /** Build one pi-ai model descriptor pointing at the loopback shim. */
-function toPiModel(info, baseUrl, observed) {
+function toPiModel(info, baseUrl, observed, providerId = WORKBUDDY_PROVIDER) {
 	return {
 		id: info.id,
 		name: info.name,
 		api: "openai-completions",
-		provider: WORKBUDDY_PROVIDER,
+		provider: providerId,
 		baseUrl,
 		input: info.supportsImages === true ? ["text", "image"] : ["text"],
 		...reasoningFields(info, observed),
 		cost: NO_COST,
 		contextWindow: info.contextWindow,
-		maxTokens: info.maxTokens
+		maxTokens: info.maxTokens,
+		compat: { maxTokensField: "max_tokens" }
 	};
 }
 /**
@@ -182,14 +304,16 @@ function toPiModel(info, baseUrl, observed) {
 */
 function createWorkBuddyAdapter(options) {
 	const { shim, store, catalog, resolveAttachments, observe } = options;
+	const providerId = options.providerId ?? "workbuddy";
+	const displayName = options.displayName ?? "WorkBuddy";
 	const buildModels = () => {
 		const baseUrl = `${shim.baseUrl()}/v1`;
-		return catalog.current().map((info) => toPiModel(info, baseUrl, observe?.(info.id)));
+		return catalog.current().map((info) => toPiModel(info, baseUrl, observe?.(info.id), providerId));
 	};
 	const provider = {
 		...createProvider({
-			id: WORKBUDDY_PROVIDER,
-			name: "WorkBuddy",
+			id: providerId,
+			name: displayName,
 			auth: { apiKey: {
 				name: "WorkBuddy OAuth bearer token",
 				async resolve({ credential }) {
@@ -206,8 +330,8 @@ function createWorkBuddyAdapter(options) {
 		getModels: () => buildModels()
 	};
 	const profile = {
-		provider: WORKBUDDY_PROVIDER,
-		displayName: "WorkBuddy",
+		provider: providerId,
+		displayName,
 		streamIdleTimeoutMs: WORKBUDDY_STREAM_IDLE_TIMEOUT_MS,
 		retryPolicy: resolveRetryPolicy(void 0, "dsh-workbuddy-connect retryPolicy"),
 		configuredMaxTokens: /* @__PURE__ */ new Map(),
@@ -215,7 +339,7 @@ function createWorkBuddyAdapter(options) {
 		...REQUEST_IMAGE_BUDGETS,
 		piProvider: provider
 	};
-	let profiles = /* @__PURE__ */ new Map([[WORKBUDDY_PROVIDER, profile]]);
+	let profiles = /* @__PURE__ */ new Map([[providerId, profile]]);
 	return {
 		adapter: new WorkBuddyPiAiAdapter(catalog, {
 			profiles: () => profiles,
@@ -224,7 +348,7 @@ function createWorkBuddyAdapter(options) {
 			...resolveAttachments === void 0 ? {} : { resolveAttachments }
 		}),
 		invalidate: () => {
-			profiles = /* @__PURE__ */ new Map([[WORKBUDDY_PROVIDER, profile]]);
+			profiles = /* @__PURE__ */ new Map([[providerId, profile]]);
 		}
 	};
 }
@@ -541,9 +665,17 @@ const PROBE_FORMAT_VERSION = 1;
 * picker entry.
 */
 const DEFAULT_TTL_MS = 12096e5;
-/** Plugin-owned probe record path inside the Harness home. */
-function workbuddyProbePath() {
-	return join(resolveDshHome(), WORKBUDDY_PROBE_FILENAME);
+/**
+* Plugin-owned probe record path inside the Harness home.
+*
+* One file per variant. Same-named models exist on both endpoints (the
+* international catalog repeats `glm-5.3`, `glm-5.2`, `hy3`, `kimi-k2.6`), and
+* {@link fingerprintModel} covers only `id`/`reasoning`/`supportsImages` —
+* never the provider — so a single shared file would let one variant's
+* observation answer for the other. The paths differ; the format does not.
+*/
+function workbuddyProbePath(filename = WORKBUDDY_PROBE_FILENAME) {
+	return join(resolveDshHome(), filename);
 }
 /**
 * Fingerprint the catalog fields a probe depends on.
@@ -625,12 +757,17 @@ var WorkBuddyProbeStore = class {
 	}
 	/**
 	* The usable record for a model, or `undefined` when there is none, it is
-	* expired, or it was taken against a different catalog row.
+	* expired, it was taken against a different catalog row, or it belongs to a
+	* different account.
+	*
+	* @param account - the account in effect, as `uid:enterpriseId`. Records are
+	*   only returned for the account that produced them.
 	*/
-	get(modelId, fingerprint) {
+	get(modelId, fingerprint, account) {
 		const record = this.load()[modelId];
 		if (record === void 0) return void 0;
 		if (record.fingerprint !== fingerprint) return void 0;
+		if (record.account !== account) return void 0;
 		if (this.now() - record.probedAtMs > this.ttlMs) return void 0;
 		return record;
 	}
@@ -655,14 +792,15 @@ var WorkBuddyProbeStore = class {
 	all() {
 		return { ...this.load() };
 	}
-	/** Build a record stamped with this store's clock and version. */
-	record(fingerprint, validation, efforts) {
+	/** Build a record stamped with this store's clock, version, and account. */
+	record(fingerprint, validation, efforts, account) {
 		return {
 			fingerprint,
 			validation,
 			efforts: validation === "validating" ? [...efforts] : [],
 			probedAtMs: this.now(),
-			pluginVersion: this.pluginVersion
+			pluginVersion: this.pluginVersion,
+			account
 		};
 	}
 	/**
@@ -723,7 +861,9 @@ var WorkBuddyProbeService = class {
 		const info = this.options.catalog.current().find((model) => model.id === modelId);
 		if (info === void 0) return void 0;
 		if (info.reasoning?.supportedEfforts !== void 0 && info.reasoning.supportedEfforts.length > 0) return;
-		return this.options.store.get(modelId, fingerprintModel(info));
+		const account = this.options.account();
+		if (account === void 0) return void 0;
+		return this.options.store.get(modelId, fingerprintModel(info), account);
 	}
 	/**
 	* Probe one model, serially.
@@ -742,7 +882,13 @@ var WorkBuddyProbeService = class {
 			state: "unavailable",
 			reason: `unknown model: ${modelId}`
 		};
-		const pending = this.pending.get(modelId);
+		const account = this.options.account();
+		if (account === void 0) return {
+			state: "unavailable",
+			reason: "no WorkBuddy credential"
+		};
+		const pendingKey = JSON.stringify([account, modelId]);
+		const pending = this.pending.get(pendingKey);
 		if (pending !== void 0) return pending;
 		const run = this.queue.then(async () => {
 			const current = this.options.catalog.current().find((model) => model.id === modelId);
@@ -765,6 +911,10 @@ var WorkBuddyProbeService = class {
 				efforts: cached.efforts,
 				requests: 0
 			};
+			if (this.options.account() !== account) return {
+				state: "unavailable",
+				reason: "account changed before detection"
+			};
 			const credential = await this.options.credentials.current();
 			if (credential === void 0) return {
 				state: "unavailable",
@@ -777,7 +927,11 @@ var WorkBuddyProbeService = class {
 					send,
 					...this.options.sentinel === void 0 ? {} : { sentinel: this.options.sentinel }
 				});
-				const record = this.options.store.record(fingerprintModel(current), outcome.validation, outcome.efforts);
+				if (this.options.account() !== account) return {
+					state: "unavailable",
+					reason: "account changed during detection"
+				};
+				const record = this.options.store.record(fingerprintModel(current), outcome.validation, outcome.efforts, account);
 				this.options.store.set(modelId, record);
 				if (outcome.validation === "unknown") return {
 					state: "unavailable",
@@ -794,30 +948,15 @@ var WorkBuddyProbeService = class {
 			}
 		});
 		this.queue = run.catch(() => void 0);
-		this.pending.set(modelId, run);
+		this.pending.set(pendingKey, run);
 		try {
 			return await run;
 		} finally {
-			this.pending.delete(modelId);
+			this.pending.delete(pendingKey);
 		}
 	}
 };
 //#endregion
-//#region src/status-paths.ts
-/** Node-free constants and types shared by the Host and browser halves. */
-/** Plugin-owned status endpoint consumed by its browser half. */
-const WORKBUDDY_STATUS_PATH = "/plugins/dsh-workbuddy-connect/status";
-/**
-* Plugin-owned probe control endpoint.
-*
-* Separate from the status route because it accepts writes: the status route's
-* loopback Host/Origin guard protects against a DNS-rebinding *page*, which is
-* not the same as authorizing a state-changing action. This route therefore
-* also requires the in-process key the browser half receives with the status
-* document.
-*/
-const WORKBUDDY_PROBE_PATH = "/plugins/dsh-workbuddy-connect/probe";
-//#endregion
 //#region src/web-status.ts
 /** Redact token-like content before it crosses to the browser. */
 function safeMessage(error) {
@@ -847,7 +986,10 @@ function loopbackRequest(req) {
 */
 async function workBuddyWebStatus(deps) {
 	const authStatus = await deps.store.status();
-	if (authStatus.state !== "signed-in") return { status: "signed-out" };
+	if (authStatus.state !== "signed-in") return {
+		status: "signed-out",
+		...authStatus.reason === void 0 ? {} : { reason: authStatus.reason }
+	};
 	const status = {
 		status: "signed-in",
 		...authStatus.nickname === void 0 ? {} : { nickname: authStatus.nickname },
@@ -857,19 +999,29 @@ async function workBuddyWebStatus(deps) {
 	};
 	const modelsField = deps.models().map((model) => {
 		const rate = normalizeCredits(model.billing?.credits);
+		const supported = model.supportedContextWindows ?? [];
+		const maxContextWindow = supported.length > 0 ? Math.max(...supported) : void 0;
 		return {
 			id: model.id,
 			name: model.name,
 			...model.billing?.free === true ? { free: true } : {},
 			...model.billing?.badges !== void 0 && model.billing.badges.length > 0 ? { badges: model.billing.badges } : {},
 			...rate === void 0 ? {} : { credits: rate },
-			...typeof model.contextWindow === "number" && model.contextWindow > 0 ? { contextWindow: model.contextWindow } : {}
+			...model.billing?.rateUnknown === true ? { rateUnknown: true } : {},
+			...typeof model.contextWindow === "number" && model.contextWindow > 0 ? { contextWindow: model.contextWindow } : {},
+			...maxContextWindow === void 0 || maxContextWindow === model.contextWindow ? {} : { maxContextWindow },
+			...typeof model.maxInputTokens === "number" && model.maxInputTokens > 0 ? { maxInputTokens: model.maxInputTokens } : {}
 		};
 	});
-	const statusWithModels = modelsField.length > 0 ? {
+	const catalog = deps.catalog?.();
+	const withCatalog = catalog === void 0 ? status : {
 		...status,
+		catalog
+	};
+	const statusWithModels = modelsField.length > 0 ? {
+		...withCatalog,
 		models: modelsField
-	} : status;
+	} : withCatalog;
 	const probed = deps.probe === void 0 ? statusWithModels : {
 		...statusWithModels,
 		probe: deps.probe(),
@@ -912,10 +1064,11 @@ function workBuddyStatusHandler(deps) {
 }
 /** Mount the GET status route on an optional webServer context. */
 function registerWorkBuddyStatusRoute(ctx, deps) {
+	const path = deps.path ?? "/plugins/dsh-workbuddy-connect/status";
 	ctx.effect(() => {
 		const dispose = ctx.webServer.register({
 			kind: "exact",
-			path: WORKBUDDY_STATUS_PATH,
+			path,
 			handler: workBuddyStatusHandler(deps)
 		});
 		return () => {
@@ -991,6 +1144,7 @@ function parseAction(text) {
 	const wrapped = parsed;
 	const action = wrapped["action"];
 	if (action === "clear") return { action: "clear" };
+	if (action === "refresh") return { action: "refresh" };
 	if (action === "probe") {
 		const model = wrapped["model"];
 		if (typeof model !== "string" || model.trim() === "") return void 0;
@@ -1034,6 +1188,14 @@ function workBuddyProbeHandler(deps, key) {
 				json(res, 200, { state: "cleared" });
 				return;
 			}
+			if (action.action === "refresh") {
+				if (deps.refresh === void 0) {
+					json(res, 404, { error: "refresh-not-supported" });
+					return;
+				}
+				json(res, 200, await deps.refresh());
+				return;
+			}
 			json(res, 200, await deps.probe(action.model));
 		} catch (error) {
 			json(res, 500, { error: error instanceof Error ? error.message : String(error) });
@@ -1042,10 +1204,11 @@ function workBuddyProbeHandler(deps, key) {
 }
 /** Mount the POST probe-control route on an optional webServer context. */
 function registerWorkBuddyProbeRoute(ctx, deps, key) {
+	const path = deps.path ?? "/plugins/dsh-workbuddy-connect/probe";
 	ctx.effect(() => {
 		const dispose = ctx.webServer.register({
 			kind: "exact",
-			path: WORKBUDDY_PROBE_PATH,
+			path,
 			handler: workBuddyProbeHandler(deps, key)
 		});
 		return () => {
@@ -1060,7 +1223,7 @@ const name = "llm-workbuddy";
 /** The model registry required before the provider can register. */
 const inject = ["llm"];
 /**
-* Settings namespace owning the configuration card.
+* Settings namespace owning the CN card's section.
 *
 * DSH 0.1.2 dropped the `settingsNamespace()` branding function: a namespace is
 * now a nominal string, validated by the type system where it is used rather
@@ -1072,176 +1235,563 @@ const inject = ["llm"];
 * their namespaces as plain string literals).
 */
 const WORKBUDDY_SETTINGS_NS = "workbuddy";
+/**
+* Settings namespace owning the international card's section.
+*
+* One namespace per card, not one shared: the settings Plugins tab dispatches a
+* card by rendering `settings.plugin.item` with `entryKey = ns` for each
+* namespace the Host serves, and skips an entry whose key names no served
+* namespace. With a single installed section, the international card registers
+* into the slot but is never rendered — the card list is built from the Host's
+* sections, not from the slot's entries. Each card therefore needs its own
+* installed section whose namespace equals the card's slot key.
+*/
+const WORKBUDDY_AI_SETTINGS_NS = "workbuddy-ai";
+/**
+* How often the credential files are re-checked, in milliseconds.
+*
+* A startup-only catalog fetch cannot notice a sign-in that happens while DSH
+* is already running, so the model group would not appear until a restart. This
+* poll is a cheap existence/parse read of at most a few local files: it never
+* contacts the network and never runs a reasoning probe.
+*
+* `DSH_WORKBUDDY_POLL_MS` overrides it. That exists so the sweep can be
+* exercised end to end in tests and shortened while diagnosing a slow sign-in
+* on a real machine; it is not a product setting and no UI exposes it. The
+* value is clamped to a sane range so a mistaken override cannot turn the poll
+* into a busy loop.
+*/
+const CREDENTIAL_POLL_MS = 3e4;
+/** Floor and ceiling for the overridable poll interval. */
+const MIN_POLL_MS = 100;
+const MAX_POLL_MS = 864e5;
+/** Resolve the sweep interval, honoring the override when it is usable. */
+function credentialPollMs() {
+	const override = Number(process.env["DSH_WORKBUDDY_POLL_MS"]);
+	if (!Number.isFinite(override) || override < MIN_POLL_MS) return CREDENTIAL_POLL_MS;
+	return Math.min(override, MAX_POLL_MS);
+}
+/**
+* How long to wait before retrying a catalog fetch that failed.
+*
+* The credential sweep deliberately does not re-fetch a catalog it already has
+* (a same-identity token rotation carries no new model information). But a
+* *failed* fetch must not be treated the same way: without a retry, one
+* transient network blip at startup would leave the group on the built-in
+* fallback roster until the user noticed and pressed refresh. This bound keeps
+* that recovery automatic while still honoring the "not every round" rule — at
+* most one attempt per interval, and none at all once a live catalog lands.
+*
+* Expressed as a multiple of the sweep rather than a fixed duration so the two
+* stay in proportion under the `DSH_WORKBUDDY_POLL_MS` override.
+*/
+const CATALOG_RETRY_SWEEPS = 10;
+/** Explicit CN desktop auth-file path (shared by the plugin schema and its section). */
+const AUTH_FILE_FIELD = z.string().description("WorkBuddy desktop auth file (defaults to the app's own location)");
+/** Explicit international desktop auth-file path (shared by the plugin schema and its section). */
+const AUTH_FILE_AI_FIELD = z.string().description("WorkBuddy AI desktop auth file (defaults to the app's own location)");
+/** Probe authorization (shared by the plugin schema and the CN section). */
+const PROBE_CONSENT_FIELD = z.boolean().default(false).description("Authorize reasoning-effort probes (each probe sends real requests that may consume credit)");
 const Config = z.object({
-	authFile: z.string().description("WorkBuddy desktop auth file (defaults to the app's own location)"),
-	probeConsent: z.boolean().default(false).description("Authorize reasoning-effort probes (each probe sends real requests that may consume credit)")
+	authFile: AUTH_FILE_FIELD,
+	authFileAI: AUTH_FILE_AI_FIELD,
+	probeConsent: PROBE_CONSENT_FIELD
 });
 /**
-* Start the loopback endpoint, register the `workbuddy` provider, and
-* refresh the model catalog from the upstream once credentials allow it.
-* The static fallback catalog serves from the first moment, so an offline
-* upstream never leaves the provider empty.
+* The CN card's settings section: only the fields that card edits.
+*
+* A section is what makes its namespace "served", which is what the Plugins
+* tab dispatches a card by — so the schema and the card must stay split the
+* same way. `probeConsent` lives here because it predates the second variant;
+* it gates no current code path (only manual, per-click-confirmed probes run),
+* so it is left where existing users set it rather than moved and re-asked.
 */
-function apply(ctx, config) {
+const CN_SECTION = z.object({
+	authFile: AUTH_FILE_FIELD,
+	probeConsent: PROBE_CONSENT_FIELD
+});
+/** The international card's settings section: only its own auth-file path. */
+const AI_SECTION = z.object({ authFileAI: AUTH_FILE_AI_FIELD });
+/** Stable identity key used by credentials, probe records, and catalog entries. */
+function credentialIdentity(credential) {
+	return `${credential.uid}:${credential.enterpriseId ?? ""}`;
+}
+/** Read the configured explicit auth-file path for one variant. */
+function configuredAuthFile(config, variant) {
+	return variant.id === CN_VARIANT.id ? config.authFile : config.authFileAI;
+}
+/** The settings namespace a variant's card and provider directory entry use. */
+function settingsNamespaceFor(variant) {
+	return variant.id === CN_VARIANT.id ? WORKBUDDY_SETTINGS_NS : WORKBUDDY_AI_SETTINGS_NS;
+}
+/**
+* The static catalog a variant serves before its first successful fetch.
+*
+* Each variant has its own roster: the two endpoints share several model ids
+* but not their billing, context windows, or reasoning sets, so one shared
+* fallback would misdescribe whichever variant it was not captured from.
+*/
+function fallbackFor(variant) {
+	return variant.id === CN_VARIANT.id ? FALLBACK_WORKBUDDY_MODELS : FALLBACK_WORKBUDDY_AI_MODELS;
+}
+/** Build one variant's stores and probe state. */
+function createVariantRuntime(config, variant, current, identityOf) {
 	const client = new WorkBuddyUpstreamClient();
+	const configured = configuredAuthFile(config, variant);
 	const store = new WorkBuddyCredentialStore({
-		...config.authFile === void 0 ? {} : { desktopPath: config.authFile },
+		variant,
+		...configured === void 0 ? {} : { desktopPath: configured },
 		refresh: (credential) => client.refreshToken(credential)
 	});
-	const catalog = new WorkBuddyCatalog();
+	const fallback = fallbackFor(variant);
+	const catalog = new WorkBuddyCatalog(fallback);
+	catalog.setVisible(false);
+	const probeStore = new WorkBuddyProbeStore({
+		pluginVersion: WORKBUDDY_CONNECT_VERSION,
+		path: workbuddyProbePath(variant.probeFilename)
+	});
+	const savedCatalogs = new WorkBuddyCatalogStore(workbuddyCatalogPath(variant.catalogFilename));
+	return {
+		variant,
+		store,
+		client,
+		catalog,
+		probeStore,
+		probeService: new WorkBuddyProbeService({
+			store: probeStore,
+			catalog,
+			credentials: store,
+			client,
+			consent: () => current().probeConsent === true,
+			account: () => identityOf(variant.id)
+		}),
+		savedCatalogs,
+		fallback,
+		catalogSource: "fallback",
+		catalogFetchedAtMs: void 0,
+		catalogError: void 0,
+		lastFetchAtMs: 0,
+		catalogGeneration: 0,
+		inflightFetch: void 0,
+		invalidate: () => {},
+		registered: false
+	};
+}
+/** The catalog provenance the card displays. */
+function catalogSection(runtime) {
+	const fetch = runtime.client.lastCatalog;
+	return {
+		source: runtime.catalogSource,
+		...runtime.catalogFetchedAtMs === void 0 ? {} : { fetchedAt: runtime.catalogFetchedAtMs },
+		...fetch?.appVersion === void 0 ? {} : { appVersion: fetch.appVersion.version },
+		...runtime.catalogError === void 0 ? {} : { error: runtime.catalogError }
+	};
+}
+/**
+* Whether a model can be probed by hand: it reasons and the upstream declares
+* no effort set for it.
+*
+* Deliberately *not* filtered by whether a result already exists. Dropping a
+* model once it has been detected made the list shrink with use, so
+* re-detecting one model — after an upstream change, say — meant clearing every
+* other result first. The list stays stable and the card marks which entries
+* already have an answer.
+*/
+function isProbeCandidate(info) {
+	if (info.reasoning?.supports !== true) return false;
+	return (info.reasoning.supportedEfforts?.length ?? 0) === 0;
+}
+/** Compact probe state for one card: consent, candidates, observations. */
+function probeSection(runtime, consent) {
+	const models = runtime.catalog.current();
+	const results = models.flatMap((info) => {
+		const record = runtime.probeService.recordFor(info.id);
+		if (record === void 0) return [];
+		return [{
+			id: info.id,
+			name: info.name,
+			validation: record.validation,
+			efforts: record.efforts,
+			probedAt: record.probedAtMs
+		}];
+	});
+	return {
+		consent,
+		running: runtime.probeService.isRunning(),
+		candidates: models.filter(isProbeCandidate).map((info) => info.id),
+		results: newestFirst(results)
+	};
+}
+/**
+* Start one variant: its loopback endpoint, provider registration, and
+* configuration-card wiring.
+*
+* Registration waits for the shim to hold a port, because the provider's
+* models read the shim origin at construction time. A failure here is
+* contained to this variant: the caller logs it and the other keeps working.
+*
+* @returns whether the provider registered.
+*/
+async function startVariant(ctx, runtime) {
+	const { variant, store, client, catalog, probeService } = runtime;
 	const shim = createWorkBuddyShim({
 		store,
 		client,
 		catalog,
 		logger: ctx.logger
 	});
+	try {
+		await shim.ready;
+	} catch (error) {
+		ctx.logger.error(`dsh-workbuddy-connect: ${variant.displayName} loopback endpoint failed to start`, error);
+		return false;
+	}
+	try {
+		const workbuddy = createWorkBuddyAdapter({
+			providerId: variant.id,
+			displayName: variant.displayName,
+			shim,
+			store,
+			catalog,
+			resolveAttachments: () => ctx.get("attachments"),
+			observe: (modelId) => probeService.recordFor(modelId)
+		});
+		workbuddy.invalidate;
+		runtime.invalidate = () => {
+			workbuddy.invalidate();
+			ctx.emit("llm/adapters-updated");
+		};
+		let releaseAdapter;
+		let releaseDirectory;
+		try {
+			releaseAdapter = ctx.llm.registerAdapter([variant.id], workbuddy.adapter);
+			releaseDirectory = ctx.llm.registerConfigurableProviders([{
+				provider: variant.id,
+				displayName: variant.displayName,
+				settingsNs: settingsNamespaceFor(variant),
+				settingsPath: [],
+				declared: false
+			}]);
+		} finally {
+			if (releaseAdapter === void 0 || releaseDirectory === void 0) {
+				releaseAdapter?.();
+				releaseDirectory?.();
+			}
+		}
+		try {
+			ctx.effect(() => () => {
+				releaseAdapter?.();
+				releaseDirectory?.();
+				shim.close();
+			});
+		} catch {
+			releaseAdapter?.();
+			releaseDirectory?.();
+			shim.close();
+		}
+		runtime.registered = true;
+		return true;
+	} catch (error) {
+		ctx.logger.error(`dsh-workbuddy-connect: ${variant.displayName} provider registration failed`, error);
+		shim.close();
+		return false;
+	}
+}
+/**
+* Start both variants: their loopback endpoints, the `workbuddy` and
+* `workbuddy-ai` providers, their configuration cards, and their
+* credential-driven catalog lifecycles.
+*
+* Each variant registers unconditionally; what varies is whether its catalog is
+* *visible*. An empty catalog is how DSH hides a model group (the host filters
+* out groups with no models), which keeps a sign-in that happens after startup
+* working without re-registering the provider.
+*/
+function apply(ctx, config) {
 	let current = () => config;
-	const probeStore = new WorkBuddyProbeStore({ pluginVersion: WORKBUDDY_CONNECT_VERSION });
-	const probeService = new WorkBuddyProbeService({
-		store: probeStore,
-		catalog,
-		credentials: store,
-		client,
-		consent: () => current().probeConsent === true
-	});
+	/** Timers and in-flight work belonging to this plugin instance. */
+	let stopped = false;
+	const timers = [];
 	/**
-	* Whether a model can be probed by hand: it reasons and the upstream declares
-	* no effort set for it.
+	* The account identity each variant last published a catalog for. Keeps a
+	* same-identity token rotation from re-fetching, and lets a late response
+	* from a previous identity be discarded instead of overwriting a newer one.
+	*/
+	const lastIdentities = /* @__PURE__ */ new Map();
+	const runtimes = WORKBUDDY_VARIANTS.map((variant) => createVariantRuntime(config, variant, () => current(), (id) => lastIdentities.get(id)));
+	const probeKey = createProbeKey();
+	/**
+	* Point a variant at an account identity, invalidating whatever the previous
+	* one left behind.
+	*
+	* One helper for all four transitions (sweep sign-in, sweep sign-out, manual
+	* refresh, manual refresh sign-out) because each of them used to do its own
+	* partial version, and the manual path forgot pieces the sweep did. Every
+	* transition bumps {@link VariantRuntime.catalogGeneration}, which is what
+	* makes an in-flight request from before the change refuse to write back.
 	*
-	* Deliberately *not* filtered by whether a result already exists. Dropping a
-	* model once it has been detected made the list shrink with use, so
-	* re-detecting one model — after an upstream change, say — meant clearing
-	* every other result first. The list stays stable and the card marks which
-	* entries already have an answer.
+	* Probe observations are dropped whenever the account actually changes —
+	* including sign-out, and including the "signed out, then in as someone else"
+	* sequence that used to look like a first sighting and let the new account
+	* inherit the old one's detected levels. They are deliberately NOT cleared on
+	* a first sign-in: no previous account's data could leak there, and clearing
+	* would delete records this very account owns (written before a restart, or
+	* seeded while all of this is running).
+	*
+	* @param identity - the account now in effect, or `undefined` when signed out.
 	*/
-	const isProbeCandidate = (info) => {
-		if (info.reasoning?.supports !== true) return false;
-		return (info.reasoning.supportedEfforts?.length ?? 0) === 0;
-	};
-	/** Compact probe state for the card: consent, candidates, observations. */
-	const probeSection = () => {
-		const config = current();
-		const models = catalog.current();
-		const results = models.flatMap((info) => {
-			const record = probeService.recordFor(info.id);
-			if (record === void 0) return [];
-			return [{
-				id: info.id,
-				name: info.name,
-				validation: record.validation,
-				efforts: record.efforts,
-				probedAt: record.probedAtMs
-			}];
-		});
-		return {
-			consent: config.probeConsent === true,
-			running: probeService.isRunning(),
-			candidates: models.filter(isProbeCandidate).map((info) => info.id),
-			results: newestFirst(results)
-		};
+	const adoptIdentity = (runtime, identity) => {
+		const id = runtime.variant.id;
+		const known = lastIdentities.get(id);
+		if (known === identity) return;
+		const hadCredential = known !== void 0;
+		if (identity === void 0) lastIdentities.delete(id);
+		else lastIdentities.set(id, identity);
+		runtime.catalogGeneration += 1;
+		runtime.inflightFetch?.controller.abort();
+		runtime.inflightFetch = void 0;
+		if (hadCredential && known !== identity) {
+			runtime.probeStore.clear();
+			runtime.invalidate();
+		}
+		if (identity === void 0) {
+			if (known !== void 0) runtime.savedCatalogs.delete(known);
+			runtime.catalog.set(runtime.fallback);
+			runtime.catalogSource = "fallback";
+			runtime.catalogFetchedAtMs = void 0;
+			runtime.catalogError = void 0;
+			if (runtime.catalog.setVisible(false)) runtime.invalidate();
+			return;
+		}
+		const saved = runtime.savedCatalogs.get(identity);
+		if (saved !== void 0) {
+			runtime.catalog.set([...saved.models]);
+			runtime.catalogSource = "saved";
+			runtime.catalogFetchedAtMs = saved.fetchedAtMs;
+		} else {
+			runtime.catalog.set(runtime.fallback);
+			runtime.catalogSource = "fallback";
+			runtime.catalogFetchedAtMs = void 0;
+		}
+		runtime.catalogError = void 0;
+		runtime.catalog.setVisible(true);
+		runtime.invalidate();
 	};
-	const probeKey = createProbeKey();
-	let refreshProbeModels = () => {};
 	ctx.inject(["webServer"], (webCtx) => {
-		registerWorkBuddyStatusRoute(webCtx, {
-			store,
-			client,
-			models: () => catalog.current(),
-			probe: () => probeSection(),
-			probeKey
-		});
-		registerWorkBuddyProbeRoute(webCtx, {
-			probe: async (modelId) => {
-				const result = await probeService.probe(modelId, true);
-				if (result.state === "ok") refreshProbeModels();
-				return result;
-			},
-			clear: () => {
-				probeStore.clear();
-				refreshProbeModels();
-			}
-		}, probeKey);
+		for (const runtime of runtimes) {
+			registerWorkBuddyStatusRoute(webCtx, {
+				path: runtime.variant.statusPath,
+				store: runtime.store,
+				client: runtime.client,
+				models: () => runtime.catalog.current(),
+				catalog: () => catalogSection(runtime),
+				probe: () => probeSection(runtime, current().probeConsent === true),
+				probeKey
+			});
+			registerWorkBuddyProbeRoute(webCtx, {
+				path: runtime.variant.probePath,
+				probe: async (modelId) => {
+					const result = await runtime.probeService.probe(modelId, true);
+					if (result.state === "ok") runtime.invalidate();
+					return result;
+				},
+				clear: () => {
+					runtime.probeStore.clear();
+					runtime.invalidate();
+				},
+				refresh: async () => {
+					if (stopped) return {
+						state: "failed",
+						reason: "plugin is stopping"
+					};
+					let credential;
+					try {
+						credential = await runtime.store.current();
+					} catch (error) {
+						return {
+							state: "failed",
+							reason: error instanceof Error ? error.message.slice(0, 300) : String(error)
+						};
+					}
+					if (credential === void 0) {
+						adoptIdentity(runtime, void 0);
+						return { state: "signed-out" };
+					}
+					const identity = credentialIdentity(credential);
+					adoptIdentity(runtime, identity);
+					await fetchCatalog(runtime, identity);
+					return runtime.catalogError === void 0 ? {
+						state: "refreshed",
+						reason: `${runtime.catalog.current().length} models`
+					} : {
+						state: "failed",
+						reason: runtime.catalogError
+					};
+				}
+			}, probeKey);
+		}
 	});
 	ctx.inject(["settings"], (settingsCtx) => {
-		settingsCtx.settings.installSection(ctx, WORKBUDDY_SETTINGS_NS, Config, config, {
+		/** Section sources; each falls back to its own slice when its side unloads. */
+		const sources = {
+			cn: () => config,
+			ai: () => config
+		};
+		/** Merge both sections into the whole config the rest of the plugin reads. */
+		const merged = () => ({
+			...sources.cn().authFile === void 0 ? {} : { authFile: sources.cn().authFile },
+			...sources.cn().probeConsent === void 0 ? {} : { probeConsent: sources.cn().probeConsent },
+			...sources.ai().authFileAI === void 0 ? {} : { authFileAI: sources.ai().authFileAI }
+		});
+		const repointStores = () => {
+			const next = merged();
+			for (const runtime of runtimes) runtime.store.setDesktopPath(configuredAuthFile(next, runtime.variant));
+		};
+		settingsCtx.settings.installSection(ctx, WORKBUDDY_SETTINGS_NS, CN_SECTION, config, {
 			setSource(source) {
-				current = source;
+				sources.cn = source;
+				current = merged;
 			},
-			onChange() {
-				const next = current().authFile;
-				store.setDesktopPath(next);
-			}
+			onChange: repointStores
+		});
+		settingsCtx.settings.installSection(ctx, WORKBUDDY_AI_SETTINGS_NS, AI_SECTION, config, {
+			setSource(source) {
+				sources.ai = source;
+				current = merged;
+			},
+			onChange: repointStores
 		});
 	});
-	let stopped = false;
 	ctx.effect(() => () => {
 		stopped = true;
-		shim.close();
+		for (const timer of timers) clearInterval(timer);
+		timers.length = 0;
 		clearHostHeartbeat();
 	});
-	shim.ready.then(() => {
-		if (stopped) return;
-		let invalidate;
-		try {
-			const workbuddy = createWorkBuddyAdapter({
-				shim,
-				store,
-				catalog,
-				resolveAttachments: () => ctx.get("attachments"),
-				observe: (modelId) => probeService.recordFor(modelId)
-			});
-			invalidate = workbuddy.invalidate;
-			refreshProbeModels = () => {
-				if (stopped) return;
-				workbuddy.invalidate();
-				ctx.emit("llm/adapters-updated");
-			};
-			let releaseAdapter;
-			let releaseDirectory;
+	/**
+	* Fetch one variant's catalog for the current credential.
+	*
+	* Shared by the credential sweep and the card's manual refresh, and written
+	* so that concurrent callers cost one request and cannot interleave badly:
+	*
+	* - **One request at a time.** A second caller joins the in-flight fetch
+	*   instead of starting its own (spec §5: one catalog request per variant at
+	*   a time).
+	* - **Generation-checked write-back.** The request records the generation it
+	*   started under and writes nothing if the generation moved on — which is
+	*   what a slow answer from a superseded account must not do. Checking only
+	*   the *identity* was not enough: two refreshes for the same account can
+	*   still finish out of order, and the older one would win.
+	* - **`resolve()`, not `current()`.** Only `resolve()` performs the locked,
+	*   single-flight token renewal. Reading `current()` meant an expired token
+	*   made every catalog request fail until something else happened to refresh
+	*   it, leaving the group on the fallback roster.
+	*/
+	const fetchCatalog = async (runtime, identity) => {
+		const inflight = runtime.inflightFetch;
+		const generation = runtime.catalogGeneration;
+		if (inflight !== void 0 && inflight.identity === identity && inflight.generation === generation) return inflight.promise;
+		inflight?.controller.abort();
+		const controller = new AbortController();
+		let run;
+		run = (async () => {
+			let models;
 			try {
-				releaseAdapter = ctx.llm.registerAdapter([WORKBUDDY_PROVIDER], workbuddy.adapter);
-				releaseDirectory = ctx.llm.registerConfigurableProviders([{
-					provider: WORKBUDDY_PROVIDER,
-					displayName: "WorkBuddy",
-					settingsNs: WORKBUDDY_SETTINGS_NS,
-					settingsPath: [],
-					declared: false
-				}]);
-			} finally {
-				if (releaseAdapter === void 0 || releaseDirectory === void 0) {
-					releaseAdapter?.();
-					releaseDirectory?.();
+				const credential = await runtime.store.resolve();
+				const resolvedIdentity = credentialIdentity(credential);
+				if (resolvedIdentity !== identity) {
+					adoptIdentity(runtime, resolvedIdentity);
+					await fetchCatalog(runtime, resolvedIdentity);
+					return;
 				}
+				models = await runtime.client.fetchModels(credential, controller.signal);
+				const latest = await runtime.store.current();
+				const latestIdentity = latest === void 0 ? void 0 : credentialIdentity(latest);
+				if (latestIdentity !== identity) {
+					adoptIdentity(runtime, latestIdentity);
+					if (latestIdentity !== void 0) await fetchCatalog(runtime, latestIdentity);
+					return;
+				}
+			} catch (error) {
+				if (stopped || runtime.catalogGeneration !== generation) return;
+				runtime.lastFetchAtMs = Date.now();
+				runtime.catalogError = error instanceof Error ? error.message.slice(0, 300) : String(error);
+				ctx.logger.warn(`dsh-workbuddy-connect: ${runtime.variant.displayName} catalog unavailable; serving the fallback list`, error);
+				runtime.invalidate();
+				return;
 			}
-			try {
-				ctx.effect(() => () => {
-					releaseAdapter?.();
-					releaseDirectory?.();
-				});
-			} catch {
-				releaseAdapter?.();
-				releaseDirectory?.();
-			}
-			writeHostHeartbeat();
-		} catch (error) {
-			ctx.logger.error("dsh-workbuddy-connect: provider registration failed", error);
+			if (stopped || runtime.catalogGeneration !== generation) return;
+			runtime.lastFetchAtMs = Date.now();
+			runtime.catalog.set([...models]);
+			runtime.catalogSource = "live";
+			runtime.catalogFetchedAtMs = runtime.client.lastCatalog?.fetchedAtMs ?? Date.now();
+			runtime.catalogError = void 0;
+			if (lastIdentities.get(runtime.variant.id) === identity) runtime.savedCatalogs.set(identity, {
+				source: runtime.client.lastCatalog?.source ?? "unknown",
+				fetchedAtMs: runtime.client.lastCatalog?.fetchedAtMs ?? Date.now(),
+				models: [...models],
+				...runtime.client.lastCatalog?.appVersion === void 0 ? {} : { appVersion: runtime.client.lastCatalog.appVersion.version }
+			});
+			runtime.invalidate();
+		})().finally(() => {
+			if (runtime.inflightFetch?.promise === run) runtime.inflightFetch = void 0;
+		});
+		runtime.inflightFetch = {
+			identity,
+			generation,
+			controller,
+			promise: run
+		};
+		return run;
+	};
+	/**
+	* Reconcile one variant with its credentials.
+	*
+	* Four transitions matter, and each is a different action:
+	*
+	* - **none → some** (first sighting): reveal the group and fetch a catalog.
+	* - **none → some, identity changed**: additionally drop the previous
+	*   account's observations, so another user's probe answers cannot be read as
+	*   the new account's.
+	* - **some → none**: hide the group and stop serving its models.
+	* - **same identity**: nothing to do — the store refreshes tokens on demand,
+	*   and re-fetching on every rotation would hit the catalog endpoint for no
+	*   new information.
+	*/
+	const syncVariant = async (runtime) => {
+		if (stopped || !runtime.registered) return;
+		const credential = await runtime.store.current().catch((error) => {
+			ctx.logger.warn(`dsh-workbuddy-connect: ${runtime.variant.displayName} credential read failed`, error);
+		});
+		if (stopped) return;
+		if (credential === void 0) {
+			adoptIdentity(runtime, void 0);
 			return;
 		}
-		(async () => {
-			try {
-				const credential = await store.current();
-				if (credential === void 0 || stopped) return;
-				const models = await client.fetchModels(credential);
-				if (stopped) return;
-				catalog.set([...models]);
-				invalidate?.();
-			} catch (error) {
-				ctx.logger.warn("dsh-workbuddy-connect: dynamic model catalog unavailable; serving the static fallback list", error);
-			}
-		})();
-	}).catch((error) => {
-		ctx.logger.error("dsh-workbuddy-connect: loopback endpoint failed to start; provider not registered", error);
+		const identity = credentialIdentity(credential);
+		if (lastIdentities.get(runtime.variant.id) === identity && runtime.catalog.isVisible()) {
+			const stale = runtime.catalogSource !== "live";
+			const due = Date.now() - runtime.lastFetchAtMs >= credentialPollMs() * CATALOG_RETRY_SWEEPS;
+			if (stale && due) await fetchCatalog(runtime, identity);
+			return;
+		}
+		adoptIdentity(runtime, identity);
+		await fetchCatalog(runtime, identity);
+	};
+	/** Run one reconcile sweep across both variants. */
+	const syncAll = async () => {
+		for (const runtime of runtimes) await syncVariant(runtime);
+	};
+	Promise.all(runtimes.map(async (runtime) => startVariant(ctx, runtime))).then(() => {
+		if (stopped) return;
+		if (runtimes.some((runtime) => runtime.registered)) writeHostHeartbeat();
+		syncAll();
+		const timer = setInterval(() => {
+			syncAll();
+		}, credentialPollMs());
+		timer.unref?.();
+		timers.push(timer);
 	});
 }
 //#endregion
-export { Config, FALLBACK_WORKBUDDY_MODELS, PROBE_EFFORT_CANDIDATES, WORKBUDDY_AUTH_FILENAME, WORKBUDDY_AUTH_FILE_ENV, WORKBUDDY_HOST_HEARTBEAT_FILENAME, WORKBUDDY_PROBE_FILENAME, WORKBUDDY_PROVIDER, WORKBUDDY_SETTINGS_NS, WORKBUDDY_STREAM_IDLE_TIMEOUT_MS, WorkBuddyCatalog, WorkBuddyCredentialStore, WorkBuddyProbeService, WorkBuddyProbeStore, WorkBuddyUpstreamClient, apply, classifyUpstreamError, clearHostHeartbeat, createWorkBuddyAdapter, createWorkBuddyShim, defaultDesktopAuthCandidates, defaultDesktopAuthPath, fingerprintModel, inject, isHeartbeatProcessAlive, name, normalizeCredits, parseWorkBuddyAuth, prepareChatBody, probeModel, processStartTimeMs, randomSentinel, readHostHeartbeat, regionOf, workbuddyHostHeartbeatPath, workbuddyOwnAuthPath, workbuddyProbePath };
+export { AI_VARIANT, CN_VARIANT, Config, FALLBACK_WORKBUDDY_AI_MODELS, FALLBACK_WORKBUDDY_MODELS, PROBE_EFFORT_CANDIDATES, WORKBUDDY_AI_SETTINGS_NS, WORKBUDDY_APP_VERSION_FILENAME, WORKBUDDY_AUTH_FILENAME, WORKBUDDY_AUTH_FILE_ENV, WORKBUDDY_CATALOG_FILENAME, WORKBUDDY_HOST_HEARTBEAT_FILENAME, WORKBUDDY_PROBE_FILENAME, WORKBUDDY_PROVIDER, WORKBUDDY_SETTINGS_NS, WORKBUDDY_STREAM_IDLE_TIMEOUT_MS, WORKBUDDY_VARIANTS, WorkBuddyCatalog, WorkBuddyCatalogStore, WorkBuddyCredentialStore, WorkBuddyProbeService, WorkBuddyProbeStore, WorkBuddyUpstreamClient, appUserAgent, apply, classifyUpstreamError, clearHostHeartbeat, createWorkBuddyAdapter, createWorkBuddyShim, defaultDesktopAuthCandidates, defaultDesktopAuthPath, desktopAuthCandidatesFor, fingerprintModel, inject, installedAppVersion, isHeartbeatProcessAlive, modelWithCurrentPromotion, name, normalizeCredits, parseModelCatalog, parseWorkBuddyAuth, prepareChatBody, prepareInternationalChatBody, probeModel, processStartTimeMs, randomSentinel, readBundleVersion, readHostHeartbeat, regionOf, resolveAppVersion, validAppVersion, variantFor, workbuddyCatalogPath, workbuddyHostHeartbeatPath, workbuddyOwnAuthPath, workbuddyProbePath };