dsh-workbuddy-connect 0.3.2 → 0.5.0

package/lib/index.js

@@ -1,12 +1,136 @@
-import { S as workbuddyOwnAuthPath, _ as WORKBUDDY_AUTH_FILE_ENV, a as readHostHeartbeat, b as defaultDesktopAuthPath, d as normalizeCredits, f as prepareChatBody, g as WORKBUDDY_AUTH_FILENAME, h as WorkBuddyCatalog, i as processStartTimeMs, l as WorkBuddyUpstreamClient, m as FALLBACK_WORKBUDDY_MODELS, 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 WorkBuddyCredentialStore, x as parseWorkBuddyAuth, y as defaultDesktopAuthCandidates } from "./host-heartbeat-BSsKUoB8.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 { randomBytes, timingSafeEqual } from "node:crypto";
 import { createServer } from "node:http";
 import { Readable } from "node:stream";
+//#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
@@ -107,29 +231,40 @@ function withCatalogDisplay(name, info) {
 * `thinkingLevelMap` (every level pinned to its wire spelling or `null` for
 * unsupported), mirroring `dsh-llm-pi-ai`'s own `resolveModelReasoning`.
 *
-* Declared sets only: a thinking control is offered exactly when the upstream
-* catalog declares a `supportedEfforts` list, and it offers exactly the
-* declared values. Rows without a list (the older `{effort, summary}` shape)
-* get no control at all — their selectable set is client-side knowledge the
-* catalog does not carry (the desktop app differs per model there: GLM-5.2
-* gets a thinking control while MiniMax-M3 and Kimi-K2.6 do not, though their
-* catalog rows are identical), and another implementation against the same
-* upstream (workbuddy2api) gates on the declared set and downgrades
-* out-of-set values rather than passing them through, so sending an
-* undeclared value risks a 400. Such models never carry `reasoning_effort`
-* on the wire; the upstream applies its own default.
-* `off` is offered only when the model explicitly reports thinking can be
-* disabled (`canDisableThinking === true`).
-*/
-function reasoningFields(info) {
+* Two sources, strictly ordered (`docs/reasoning-effort-probe-plan.md` §5):
+*
+* 1. **The declared set.** When the upstream declares a non-empty
+*    `supportedEfforts`, exactly those values are offered and nothing else.
+*    This always wins: an observation never widens or narrows a declared set.
+* 2. **A local observation.** Rows without a declared set (the older
+*    `{effort, summary}` shape) normally get no control at all — their
+*    selectable set is client-side knowledge the catalog does not carry, and
+*    the desktop app differs per model there. If the user authorized a probe
+*    and it established that the upstream *validates* the parameter, the
+*    verified spellings are offered.
+*
+* A `non-validating` observation deliberately yields no control: the upstream
+* accepts values that cannot exist (measured on `glm-5.2`), so every per-level
+* acceptance it produced would be a false positive.
+*
+* `off` is offered only when the upstream declares `canDisableThinking: true`.
+* It is never probed — disabling thinking is a separate capability, and the
+* per-model acceptance of `off` cannot be inferred from the row's shape.
+*
+* The offered set is described internally as "verified accepted", never as
+* "verified effective": acceptance proves the upstream did not reject the
+* spelling, not that it changes what the model does.
+*/
+function reasoningFields(info, observed) {
 	const reasoning = info.reasoning;
 	if (reasoning === void 0 || reasoning.supports !== true) return { reasoning: false };
-	const efforts = reasoning.supportedEfforts;
-	if (efforts === void 0 || efforts.length === 0) return { reasoning: false };
+	const declared = reasoning.supportedEfforts;
+	const efforts = declared !== void 0 && declared.length > 0 ? declared : observed?.validation === "validating" && observed.efforts.length > 0 ? observed.efforts : void 0;
+	if (efforts === void 0) return { reasoning: false };
 	return {
 		reasoning: true,
 		thinkingLevelMap: {
-			off: reasoning.canDisableThinking === true ? "off" : null,
+			off: reasoning.canDisableThinking === true && declared !== void 0 && declared.length > 0 ? "off" : null,
 			minimal: null,
 			low: efforts.includes("low") ? "low" : null,
 			medium: efforts.includes("medium") ? "medium" : null,
@@ -140,18 +275,19 @@ function reasoningFields(info) {
 	};
 }
 /** Build one pi-ai model descriptor pointing at the loopback shim. */
-function toPiModel(info, baseUrl) {
+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),
+		...reasoningFields(info, observed),
 		cost: NO_COST,
 		contextWindow: info.contextWindow,
-		maxTokens: info.maxTokens
+		maxTokens: info.maxTokens,
+		compat: { maxTokensField: "max_tokens" }
 	};
 }
 /**
@@ -167,15 +303,17 @@ function toPiModel(info, baseUrl) {
 * `modelErrors` since 0.1.5-alpha.2 (#12).
 */
 function createWorkBuddyAdapter(options) {
-	const { shim, store, catalog, resolveAttachments } = 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));
+		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 }) {
@@ -192,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(),
@@ -201,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,
@@ -210,7 +348,7 @@ function createWorkBuddyAdapter(options) {
 			...resolveAttachments === void 0 ? {} : { resolveAttachments }
 		}),
 		invalidate: () => {
-			profiles = /* @__PURE__ */ new Map([[WORKBUDDY_PROVIDER, profile]]);
+			profiles = /* @__PURE__ */ new Map([[providerId, profile]]);
 		}
 	};
 }
@@ -357,7 +495,7 @@ function writeOpenAIError(res, status, kind, message) {
 	} });
 }
 /** Read a request body with a size cap; over-limit bodies fail the request. */
-function readBody(req) {
+function readBody$1(req) {
 	return new Promise((resolve, reject) => {
 		const chunks = [];
 		let size = 0;
@@ -461,7 +599,7 @@ function createWorkBuddyShim(options) {
 			writeOpenAIError(res, 401, "not_signed_in", String(error));
 			return;
 		}
-		const raw = (await readBody(req)).toString("utf8");
+		const raw = (await readBody$1(req)).toString("utf8");
 		const prepared = prepareChatBody(raw);
 		const controller = new AbortController();
 		req.on("close", () => controller.abort());
@@ -499,17 +637,332 @@ function createWorkBuddyShim(options) {
 	};
 }
 //#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";
+//#region src/probe-store.ts
+/**
+* Local record of reasoning-effort probes.
+*
+* What this stores is an *observation*, never a claim about the upstream: a
+* model's row is only consulted when the catalog carries no explicit
+* `supportedEfforts` set, and it always loses to a declared set. The plan this
+* implements (`docs/reasoning-effort-probe-plan.md` §5) requires that a result
+* is invalidated whenever the model's catalog row changes, so every record
+* carries a fingerprint of the fields the probe depended on.
+*
+* The file lives beside the plugin's own credential copy under `$DSH_HOME`,
+* never in the desktop app's files, and carries no token, prompt, or response
+* body — only model ids, effort spellings, and timestamps.
+*
+* @module dsh-workbuddy-connect/probe-store
+*/
+/** Basename of the probe record inside the Harness home. */
+const WORKBUDDY_PROBE_FILENAME = ".workbuddy-probe.json";
+/** On-disk format this reader accepts; other versions are discarded. */
+const PROBE_FORMAT_VERSION = 1;
+/**
+* How long an observation stays usable. Conservative on purpose: the plan's
+* whole argument is that upstream metadata moves fast, so a result that has
+* outlived its fingerprint's usefulness should not quietly keep granting a
+* picker entry.
+*/
+const DEFAULT_TTL_MS = 12096e5;
+/**
+* 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.
+*
+* Deliberately excludes display-only fields (`name`, `billing`, `contextWindow`)
+* so a rename or a promo badge does not throw away a valid observation, and
+* deliberately includes the whole reasoning object so any change to the
+* declared shape re-probes.
+*/
+function fingerprintModel(info) {
+	const basis = JSON.stringify({
+		id: info.id,
+		reasoning: info.reasoning ?? null,
+		supportsImages: info.supportsImages ?? null
+	});
+	return createHash("sha256").update(basis).digest("hex").slice(0, 16);
+}
+/** Read-and-validate the documents on disk; anything malformed reads as empty. */
+function readDocument(path) {
+	if (!existsSync(path)) return void 0;
+	let parsed;
+	try {
+		parsed = JSON.parse(readFileSync(path, "utf8"));
+	} catch {
+		return;
+	}
+	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return void 0;
+	const wrapped = parsed;
+	if (wrapped["version"] !== PROBE_FORMAT_VERSION) return void 0;
+	const records = wrapped["records"];
+	if (typeof records !== "object" || records === null || Array.isArray(records)) return void 0;
+	return parsed;
+}
+/** One record's shape check; a bad row is dropped rather than trusted. */
+function isRecord(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	const wrapped = value;
+	const validation = wrapped["validation"];
+	if (validation !== "validating" && validation !== "non-validating" && validation !== "unknown") return false;
+	if (typeof wrapped["fingerprint"] !== "string") return false;
+	if (typeof wrapped["probedAtMs"] !== "number" || !Number.isFinite(wrapped["probedAtMs"])) return false;
+	if (typeof wrapped["pluginVersion"] !== "string") return false;
+	const efforts = wrapped["efforts"];
+	if (!Array.isArray(efforts) || efforts.some((effort) => typeof effort !== "string")) return false;
+	return true;
+}
+/**
+* The plugin's probe records: read once, written atomically, never trusted
+* across a fingerprint change or past the TTL.
+*/
+var WorkBuddyProbeStore = class {
+	path;
+	ttlMs;
+	pluginVersion;
+	now;
+	records;
+	constructor(options) {
+		const opts = typeof options === "string" ? {
+			path: options,
+			pluginVersion: "0.0.0"
+		} : options;
+		this.path = opts.path ?? workbuddyProbePath();
+		this.ttlMs = opts.ttlMs ?? DEFAULT_TTL_MS;
+		this.pluginVersion = opts.pluginVersion;
+		this.now = opts.now ?? (() => Date.now());
+	}
+	/** Resolved state-file path, for the CLI and tests. */
+	filePath() {
+		return this.path;
+	}
+	load() {
+		if (this.records === void 0) {
+			const document = readDocument(this.path);
+			const records = {};
+			for (const [id, record] of Object.entries(document?.records ?? {})) if (isRecord(record)) records[id] = record;
+			this.records = records;
+		}
+		return this.records;
+	}
+	/**
+	* The usable record for a model, or `undefined` when there is none, it is
+	* 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, 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;
+	}
+	/**
+	* Store one observation. Only a decisive answer (`validating` /
+	* `non-validating`) replaces an existing decisive record: a transient
+	* `unknown` must not erase knowledge the user already paid for.
+	*/
+	set(modelId, record) {
+		const records = this.load();
+		const existing = records[modelId];
+		if (record.validation === "unknown" && existing !== void 0 && existing.fingerprint === record.fingerprint && existing.validation !== "unknown") return;
+		records[modelId] = record;
+		this.persist();
+	}
+	/** Drop every record; used by the card's explicit "clear" action. */
+	clear() {
+		this.records = {};
+		this.persist();
+	}
+	/** Every record currently held, for status display. */
+	all() {
+		return { ...this.load() };
+	}
+	/** 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,
+			account
+		};
+	}
+	/**
+	* Write through a temporary file and rename, so a crash mid-write cannot
+	* leave a half-parsed document that reads as "no records" and silently drops
+	* every observation.
+	*/
+	persist() {
+		const directory = dirname(this.path);
+		try {
+			if (!existsSync(directory)) mkdirSync(directory, { recursive: true });
+			const document = {
+				version: PROBE_FORMAT_VERSION,
+				records: this.load()
+			};
+			const temporary = resolve(`${this.path}.tmp`);
+			writeFileSync(temporary, `${JSON.stringify(document, null, 2)}\n`, { mode: 384 });
+			renameSync(temporary, this.path);
+		} catch {}
+	}
+};
+/**
+* Order observations newest-first for display.
+*
+* The store keeps insertion order so the file reads chronologically, but the
+* card wants the most recent detection at the top: a sweep the user just ran
+* should not appear below every earlier one, which is what appending to an
+* insertion-ordered list does.
+*/
+function newestFirst(records) {
+	return [...records].sort((a, b) => b.probedAt - a.probedAt);
+}
+//#endregion
+//#region src/probe-service.ts
+/**
+* Serial probe runner. One instance is shared by the manual API and any
+* future automatic trigger, so the two can never overlap.
+*/
+var WorkBuddyProbeService = class {
+	options;
+	queue = Promise.resolve();
+	pending = /* @__PURE__ */ new Map();
+	running = false;
+	constructor(options) {
+		this.options = options;
+	}
+	/** Whether a sweep is in flight right now. */
+	isRunning() {
+		return this.running;
+	}
+	/**
+	* The record the adapter may use for this model, or `undefined`.
+	*
+	* Applies the plan's precedence (§5): a declared set always wins, so a model
+	* that declares `supportedEfforts` is never answered from an observation.
+	*/
+	recordFor(modelId) {
+		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;
+		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.
+	*
+	* The authenticated manual route supplies one-request consent after UI
+	* confirmation. Other callers must pass the configured consent gate.
+	* Manual consent never changes the automatic-probing configuration.
+	* Explicit requests bypass historical results, but share an ongoing run.
+	*/
+	async probe(modelId, manualConsent = false) {
+		if (!manualConsent && !this.options.consent()) return {
+			state: "unavailable",
+			reason: "probing is not authorized"
+		};
+		if (this.options.catalog.current().find((model) => model.id === modelId) === void 0) return {
+			state: "unavailable",
+			reason: `unknown model: ${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);
+			if (current === void 0) return {
+				state: "unavailable",
+				reason: `unknown model: ${modelId}`
+			};
+			if (!manualConsent && !this.options.consent()) return {
+				state: "unavailable",
+				reason: "probing is not authorized"
+			};
+			if (current.reasoning?.supports !== true || (current.reasoning.supportedEfforts?.length ?? 0) > 0) return {
+				state: "unavailable",
+				reason: "model does not need detection"
+			};
+			const cached = this.recordFor(modelId);
+			if (!manualConsent && cached !== void 0 && cached.validation !== "unknown") return {
+				state: "ok",
+				validation: cached.validation,
+				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",
+				reason: "no WorkBuddy credential"
+			};
+			const send = this.options.send === void 0 ? (effort, signal) => this.options.client.probeEffort(credential, modelId, effort, signal) : this.options.send(modelId);
+			this.running = true;
+			try {
+				const outcome = await probeModel({
+					send,
+					...this.options.sentinel === void 0 ? {} : { sentinel: this.options.sentinel }
+				});
+				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",
+					reason: outcome.reason
+				};
+				return {
+					state: "ok",
+					validation: outcome.validation,
+					efforts: record.efforts,
+					requests: outcome.requests
+				};
+			} finally {
+				this.running = false;
+			}
+		});
+		this.queue = run.catch(() => void 0);
+		this.pending.set(pendingKey, run);
+		try {
+			return await run;
+		} finally {
+			this.pending.delete(pendingKey);
+		}
+	}
+};
 //#endregion
 //#region src/web-status.ts
 /** Redact token-like content before it crosses to the browser. */
 function safeMessage(error) {
 	return (error instanceof Error ? error.message : String(error)).replace(/\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b/gu, "[redacted token]").replace(/(\b(?:code|token|refresh_token|access_token)=)[^&\s]+/giu, "$1[redacted]").slice(0, 500);
 }
-function json(res, status, body) {
+function json$1(res, status, body) {
 	const payload = JSON.stringify(body);
 	res.writeHead(status, {
 		"Content-Type": "application/json",
@@ -533,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 },
@@ -541,61 +997,78 @@ async function workBuddyWebStatus(deps) {
 		...authStatus.source === void 0 ? {} : { source: authStatus.source },
 		...authStatus.expiresAtMs === void 0 ? {} : { expiresAt: authStatus.expiresAtMs }
 	};
-	const modelsField = deps.models().filter((model) => model.billing?.free === true || (model.billing?.badges?.length ?? 0) > 0).map((model) => {
+	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 }
+			...rate === void 0 ? {} : { credits: rate },
+			...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(),
+		...deps.probeKey === void 0 ? {} : { probeKey: deps.probeKey }
+	};
 	try {
 		const credential = await deps.store.current();
 		if (credential !== void 0) {
 			const credits = await deps.client.fetchCredits(credential);
 			return {
-				...statusWithModels,
+				...probed,
 				credits
 			};
 		}
 	} catch (error) {
 		return {
-			...statusWithModels,
+			...probed,
 			creditsError: safeMessage(error)
 		};
 	}
-	return statusWithModels;
+	return probed;
 }
 /** The status route's request handler, extracted so tests can mount it on a bare server. */
 function workBuddyStatusHandler(deps) {
 	return async (req, res) => {
 		if (req.method !== "GET") {
-			json(res, 405, { error: "method not allowed" });
+			json$1(res, 405, { error: "method not allowed" });
 			return;
 		}
 		if (!loopbackRequest(req)) {
-			json(res, 403, { error: "request-not-trusted" });
+			json$1(res, 403, { error: "request-not-trusted" });
 			return;
 		}
 		try {
-			json(res, 200, await workBuddyWebStatus(deps));
+			json$1(res, 200, await workBuddyWebStatus(deps));
 		} catch (error) {
-			json(res, 500, { error: safeMessage(error) });
+			json$1(res, 500, { error: safeMessage(error) });
 		}
 	};
 }
 /** 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 () => {
@@ -604,13 +1077,153 @@ function registerWorkBuddyStatusRoute(ctx, deps) {
 	}, "dsh-workbuddy-connect: Web status route");
 }
 //#endregion
+//#region src/probe-route.ts
+/**
+* Probe control route: the only state-changing endpoint the plugin exposes.
+*
+* Two guards, because they stop different things (see `docs/reasoning-effort-probe-plan.md`
+* §6.4 and the v0.3.1 note in AGENTS.md about their exact scope):
+*
+* 1. **Loopback Host + Origin**, shared with the status route. This drops
+*    DNS-rebinding pages, whose requests arrive addressed to the attacker's
+*    domain.
+* 2. **An in-process random key**, minted per process and handed only to the
+*    same-origin card. Loopback alone is *not* authentication — any local
+*    process can write `Host: 127.0.0.1` — so a route that spends the user's
+*    credit must prove the caller was told the key.
+*
+* The route never accepts a prompt, a model id outside the live catalog, or a
+* sentinel from the browser: a probe request is assembled entirely host-side.
+*
+* @module dsh-workbuddy-connect/probe-route
+*/
+/** Largest control body accepted; these payloads are a few dozen bytes. */
+const MAX_BODY_BYTES = 4096;
+/** Mint the per-process control key. */
+function createProbeKey() {
+	return randomBytes(24).toString("hex");
+}
+/**
+* Constant-time key comparison; a length mismatch is a failure, not a crash.
+*/
+function keyMatches(expected, presented) {
+	if (presented === void 0 || presented.length !== expected.length) return false;
+	const a = Buffer.from(expected);
+	const b = Buffer.from(presented);
+	return a.length === b.length && timingSafeEqual(a, b);
+}
+function json(res, status, body) {
+	const payload = JSON.stringify(body);
+	res.writeHead(status, {
+		"Content-Type": "application/json",
+		"Content-Length": Buffer.byteLength(payload)
+	});
+	res.end(payload);
+}
+/** Read the request body with a hard ceiling. */
+async function readBody(req) {
+	const chunks = [];
+	let total = 0;
+	for await (const chunk of req) {
+		const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+		total += buffer.length;
+		if (total > MAX_BODY_BYTES) return void 0;
+		chunks.push(buffer);
+	}
+	return Buffer.concat(chunks).toString("utf8");
+}
+/** Parse and shape-check an action; unknown fields are ignored, not trusted. */
+function parseAction(text) {
+	let parsed;
+	try {
+		parsed = JSON.parse(text);
+	} catch {
+		return;
+	}
+	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return void 0;
+	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;
+		return {
+			action: "probe",
+			model: model.trim()
+		};
+	}
+}
+/**
+* The control route's handler, extracted so tests can mount it on a bare
+* server with a known key.
+*/
+function workBuddyProbeHandler(deps, key) {
+	return async (req, res) => {
+		if (req.method !== "POST") {
+			json(res, 405, { error: "method not allowed" });
+			return;
+		}
+		if (!hostIsLoopback(req.headers.host) || !originIsLoopback(req.headers.origin)) {
+			json(res, 403, { error: "request-not-trusted" });
+			return;
+		}
+		if (!keyMatches(key, req.headers["x-workbuddy-probe-key"])) {
+			json(res, 403, { error: "invalid-probe-key" });
+			return;
+		}
+		const body = await readBody(req);
+		if (body === void 0) {
+			json(res, 413, { error: "body too large" });
+			return;
+		}
+		const action = parseAction(body);
+		if (action === void 0) {
+			json(res, 400, { error: "invalid action" });
+			return;
+		}
+		try {
+			if (action.action === "clear") {
+				deps.clear();
+				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) });
+		}
+	};
+}
+/** 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,
+			handler: workBuddyProbeHandler(deps, key)
+		});
+		return () => {
+			dispose();
+		};
+	}, "dsh-workbuddy-connect: probe control route");
+}
+//#endregion
 //#region src/index.ts
 /** Stable Cordis plugin name. */
 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
@@ -622,106 +1235,563 @@ const inject = ["llm"];
 * their namespaces as plain string literals).
 */
 const WORKBUDDY_SETTINGS_NS = "workbuddy";
-const Config = z.object({ authFile: z.string().description("WorkBuddy desktop auth file (defaults to the app's own location)") });
 /**
-* 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.
+* 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.
 */
-function apply(ctx, config) {
+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: AUTH_FILE_FIELD,
+	authFileAI: AUTH_FILE_AI_FIELD,
+	probeConsent: PROBE_CONSENT_FIELD
+});
+/**
+* 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.
+*/
+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 shim = createWorkBuddyShim({
+	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,
-		logger: ctx.logger
+		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
+		}];
 	});
-	ctx.inject(["webServer"], (webCtx) => registerWorkBuddyStatusRoute(webCtx, {
+	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,
-		models: () => catalog.current()
-	}));
+		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;
+	/** Timers and in-flight work belonging to this plugin instance. */
+	let stopped = false;
+	const timers = [];
+	/**
+	* 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.
+	*
+	* 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 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();
+	};
+	ctx.inject(["webServer"], (webCtx) => {
+		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")
-			});
-			invalidate = workbuddy.invalidate;
-			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, WORKBUDDY_AUTH_FILENAME, WORKBUDDY_AUTH_FILE_ENV, WORKBUDDY_HOST_HEARTBEAT_FILENAME, WORKBUDDY_PROVIDER, WORKBUDDY_SETTINGS_NS, WORKBUDDY_STREAM_IDLE_TIMEOUT_MS, WorkBuddyCatalog, WorkBuddyCredentialStore, WorkBuddyUpstreamClient, apply, classifyUpstreamError, clearHostHeartbeat, createWorkBuddyAdapter, createWorkBuddyShim, defaultDesktopAuthCandidates, defaultDesktopAuthPath, inject, isHeartbeatProcessAlive, name, normalizeCredits, parseWorkBuddyAuth, prepareChatBody, processStartTimeMs, readHostHeartbeat, regionOf, workbuddyHostHeartbeatPath, workbuddyOwnAuthPath };
+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 };