dsh-qoder-connect 0.2.6 → 0.2.8

package/lib/{variants-COxX6r1j.js → variants-Dl1AbWre.js}

@@ -215,24 +215,46 @@ function qoderMachineIdPath() {
 //#endregion
 //#region src/auth.ts
 /**
-* Qoder credential storage — one Personal Access Token per variant.
+* Qoder credential storage — a list of Personal Access Tokens per variant,
+* one of which is active.
 *
 * Every credential the plugin holds is a PAT the human pasted into the
-* variant's card (or exported into the environment, or saved by the CLI).
+* variant's card (or saved by the CLI, or exported into the environment).
 * There is no device flow, no token refresh, and no expiry: a PAT is valid
 * until the user revokes it, so this store only reads, writes, and deletes a
 * small JSON document.
 *
+* WHAT IS PER-ACCOUNT AND WHAT IS NOT
+*
+* Only the *credential* is per-account. Every setting the cards expose —
+* disabled models, the maximum-context preference, per-model window
+* overrides, probe consent, sidebar quota, check-in toggles — lives in the
+* plugin's own settings file and is shared by every saved PAT. Switching
+* accounts therefore never changes configuration; it only changes which
+* token signs the next request.
+*
+* FILE
+*
 * One file per variant inside the plugin's data directory
 * (`<.dsh-qoder-connect>/`). The on-disk schema is
-* `{version: 2, pat, region, savedAt}` — deliberately narrower than the
-* WorkBuddy-era document it replaces: anything this file does not name is
-* not a fact the plugin knows.
+*
+*   {version: 3, activeId, credentials: [{id, pat, region, savedAt, label?}]}
+*
+* `id` is a one-way hash prefix of the token, so re-pasting the same token
+* updates its own entry instead of piling up duplicates, and the id can be
+* shown (in a select, a log line, or a test) without leaking the secret.
+* `label` is optional display copy stored at save time; it never reaches the
+* upstream.
+*
+* A version-2 document (`{version: 2, pat, region, savedAt}`) is read as a
+* one-entry list and rewritten as v3 on the next mutation. A WorkBuddy-era
+* document (it carries `accessToken` and no `pat`) is not a credential this
+* plugin can use in any form — it is reported, never migrated.
 *
 * @module dsh-qoder-connect/auth
 */
 /** The on-disk document version this writer produces. */
-const AUTH_SCHEMA_VERSION = 2;
+const AUTH_SCHEMA_VERSION = 3;
 /** Environment fallback for the global arm when no file exists. */
 const QODER_PAT_ENV_GLOBAL = "QODER_PERSONAL_ACCESS_TOKEN";
 /** Environment fallback for the China arm when no file exists. */
@@ -245,22 +267,56 @@ function patTail(pat) {
 	return trimmed.length >= 4 ? trimmed.slice(-4) : void 0;
 }
 /**
+* Stable local id for one token.
+*
+* A PAT is a bearer secret, so the id is a one-way hash prefix rather than
+* any suffix of it: surfaces that show the id (the select, status documents,
+* logs) leak nothing usable, while two saves of the same token still resolve
+* to the same entry.
+*/
+function qoderCredentialId(pat) {
+	return createHash("sha256").update(pat).digest("hex").slice(0, 12);
+}
+/**
 * Stable identity key for a credential, used by probe records and saved
 * catalogs.
 *
-* A PAT is a bearer secret, so the key is its one-way hash rather than any
-* suffix of it: surfaces that show the key (cards, JSON diagnostics) leak
-* nothing usable, while two reads of the same token still correlate locally.
+* Deliberately wider than the local id: these keys address stored data, not
+* UI, and 16 hex characters keep two tokens from ever sharing a bucket.
 */
 function qoderCredentialIdentity(credential) {
 	return `pat:${createHash("sha256").update(credential.pat).digest("hex").slice(0, 16)}`;
 }
-function isRecord$1(value) {
+function isRecord$2(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isRegion(value) {
 	return value === "global" || value === "china";
 }
+/** Trim a label and cap it at a length a card row can render. */
+function normalizeLabel(value) {
+	if (typeof value !== "string") return void 0;
+	const trimmed = value.trim();
+	return trimmed === "" ? void 0 : trimmed.slice(0, 48);
+}
+/** Parse one stored entry, dropping anything this store cannot use. */
+function normalizeEntry(value) {
+	if (!isRecord$2(value)) return void 0;
+	const pat = typeof value["pat"] === "string" ? value["pat"].trim() : "";
+	if (pat === "") return void 0;
+	const region = value["region"];
+	if (!isRegion(region)) return void 0;
+	const rawId = typeof value["id"] === "string" ? value["id"].trim() : "";
+	const label = normalizeLabel(value["label"]);
+	const savedAt = typeof value["savedAt"] === "number" && Number.isFinite(value["savedAt"]) ? value["savedAt"] : void 0;
+	return {
+		id: rawId === "" ? qoderCredentialId(pat) : rawId,
+		pat,
+		region,
+		...savedAt === void 0 ? {} : { savedAtMs: savedAt },
+		...label === void 0 ? {} : { label }
+	};
+}
 var QoderCredentialStore = class {
 	variant;
 	ownPath;
@@ -279,14 +335,25 @@ var QoderCredentialStore = class {
 	/**
 	* The credential currently in effect, or `undefined` when there is none.
 	*
-	* Resolution order: the plugin-owned file, then the arm's environment
-	* variable (only when no file exists — a saved token always wins over a
-	* stray env), then nothing. There is no refresh and no expiry check: a PAT
-	* lives until revoked.
+	* Resolution order: the active saved entry (or the first one when the
+	* pointer is stale), then the arm's environment variable (only when no
+	* saved entry exists — a saved token always wins over a stray env), then
+	* nothing. There is no refresh and no expiry check: a PAT lives until
+	* revoked.
 	*/
 	async current() {
 		const stored = await this.readOwn();
-		if (stored !== void 0) return stored;
+		if (stored !== void 0 && stored.entries.length > 0) {
+			const entry = stored.entries.find((candidate) => candidate.id === stored.activeId) ?? stored.entries[0];
+			return {
+				id: entry.id,
+				pat: entry.pat,
+				region: entry.region,
+				...entry.savedAtMs === void 0 ? {} : { savedAtMs: entry.savedAtMs },
+				...entry.label === void 0 ? {} : { label: entry.label },
+				source: "card"
+			};
+		}
 		return this.fromEnvironment();
 	}
 	/**
@@ -305,23 +372,94 @@ var QoderCredentialStore = class {
 	async patPromise() {
 		return (await this.resolve()).pat;
 	}
+	/** Every saved entry (tokens included; host-side callers only). */
+	async entries() {
+		return (await this.readOwn())?.entries ?? [];
+	}
 	/**
-	* Persist a token for this variant. The caller is responsible for having
-	* validated it against the region first (`validateApiKey` upstream).
+	* Add a token and make it active.
+	*
+	* Re-saving an existing token updates that entry (its saved time, and its
+	* label when one is supplied) instead of appending a duplicate — the id is
+	* derived from the token, so "same PAT" is the same entry by construction.
+	* The caller is responsible for having validated the token against the
+	* region first (`validateApiKey` upstream).
+	*
+	* @param pat - the token to store.
+	* @param label - optional display label for the select row.
+	* @returns the stored entry.
 	*/
-	async save(pat, source = "card") {
+	async add(pat, label) {
 		const trimmed = pat.trim();
 		if (trimmed === "") throw new Error("qoder: cannot save an empty Personal Access Token");
-		const credential = {
+		const entries = (await this.readOwn())?.entries ?? [];
+		const id = qoderCredentialId(trimmed);
+		const index = entries.findIndex((entry) => entry.id === id);
+		const existing = index === -1 ? void 0 : entries[index];
+		const nextLabel = normalizeLabel(label) ?? existing?.label;
+		const next = {
+			id,
 			pat: trimmed,
 			region: this.variant.region,
 			savedAtMs: Date.now(),
+			...nextLabel === void 0 ? {} : { label: nextLabel }
+		};
+		if (index === -1) entries.push(next);
+		else entries[index] = next;
+		await this.writeDocument(entries, id);
+		return next;
+	}
+	/**
+	* Make one saved entry active.
+	*
+	* @param id - the entry id.
+	* @returns the activated entry, or `undefined` when no entry has that id.
+	*/
+	async activate(id) {
+		const stored = await this.readOwn();
+		if (stored === void 0) return void 0;
+		const entry = stored.entries.find((candidate) => candidate.id === id);
+		if (entry === void 0) return void 0;
+		await this.writeDocument(stored.entries, id);
+		return entry;
+	}
+	/**
+	* Remove one saved entry.
+	*
+	* The active pointer moves to the first remaining entry; removing the last
+	* entry deletes the file, exactly like {@link clear} — a saved token is the
+	* only thing that shadows the environment fallback.
+	*
+	* @param id - the entry id.
+	* @returns the removed entry, or `undefined` when no entry has that id.
+	*/
+	async remove(id) {
+		const stored = await this.readOwn();
+		if (stored === void 0) return void 0;
+		const index = stored.entries.findIndex((entry) => entry.id === id);
+		if (index === -1) return void 0;
+		const [removed] = stored.entries.splice(index, 1);
+		const activeId = stored.activeId === id ? stored.entries[0]?.id : stored.activeId;
+		await this.writeDocument(stored.entries, activeId);
+		return removed;
+	}
+	/**
+	* Persist a token for this variant and make it active.
+	*
+	* Kept for the CLI and older call sites: it is {@link add} behind the
+	* runtime-credential shape they expect.
+	*/
+	async save(pat, source = "card") {
+		const entry = await this.add(pat);
+		return {
+			id: entry.id,
+			pat: entry.pat,
+			region: entry.region,
+			...entry.savedAtMs === void 0 ? {} : { savedAtMs: entry.savedAtMs },
 			source
 		};
-		await this.writeOwn(credential);
-		return credential;
 	}
-	/** Remove the stored credential. A missing file is not an error. */
+	/** Remove every stored credential. A missing file is not an error. */
 	async clear() {
 		try {
 			await rm(this.ownPath, { force: true });
@@ -337,7 +475,35 @@ var QoderCredentialStore = class {
 			filePath: this.ownPath,
 			region: this.variant.region
 		};
-		const credential = await this.current();
+		const stored = await this.readOwn();
+		const entries = stored?.entries ?? [];
+		if (entries.length > 0) {
+			const active = entries.find((entry) => entry.id === stored?.activeId) ?? entries[0];
+			const tail = patTail(active.pat);
+			const profiles = [...entries].sort(newestFirst$1).map((entry) => {
+				const entryTail = patTail(entry.pat);
+				return {
+					id: entry.id,
+					...entry.label === void 0 ? {} : { label: entry.label },
+					...entryTail === void 0 ? {} : { patTail: entryTail },
+					...entry.savedAtMs === void 0 ? {} : { savedAtMs: entry.savedAtMs }
+				};
+			});
+			return {
+				state: "configured",
+				...base,
+				pat: {
+					id: active.id,
+					...active.label === void 0 ? {} : { label: active.label },
+					source: "card",
+					...active.savedAtMs === void 0 ? {} : { savedAtMs: active.savedAtMs },
+					...tail === void 0 ? {} : { patTail: tail }
+				},
+				activeId: active.id,
+				profiles
+			};
+		}
+		const credential = await this.fromEnvironment();
 		if (credential === void 0) return {
 			state: "missing",
 			...base,
@@ -349,7 +515,6 @@ var QoderCredentialStore = class {
 			...base,
 			pat: {
 				source: credential.source,
-				...credential.savedAtMs === void 0 ? {} : { savedAtMs: credential.savedAtMs },
 				...tail === void 0 ? {} : { patTail: tail }
 			}
 		};
@@ -370,7 +535,7 @@ var QoderCredentialStore = class {
 		let text;
 		try {
 			text = await readFile(this.ownPath, "utf8");
-		} catch (error) {
+		} catch {
 			this.pendingLegacyReason = void 0;
 			return;
 		}
@@ -381,11 +546,11 @@ var QoderCredentialStore = class {
 			this.pendingLegacyReason = void 0;
 			return;
 		}
-		if (!isRecord$1(parsed)) {
+		if (!isRecord$2(parsed)) {
 			this.pendingLegacyReason = void 0;
 			return;
 		}
-		if (typeof parsed["accessToken"] === "string" && parsed["pat"] === void 0) {
+		if (typeof parsed["accessToken"] === "string" && parsed["pat"] === void 0 && parsed["credentials"] === void 0) {
 			this.pendingLegacyReason = "stale WorkBuddy credential file; save a Qoder Personal Access Token instead";
 			if (!this.legacyWarned) {
 				this.legacyWarned = true;
@@ -394,23 +559,49 @@ var QoderCredentialStore = class {
 			return;
 		}
 		this.pendingLegacyReason = void 0;
+		if (Array.isArray(parsed["credentials"])) {
+			const byId = /* @__PURE__ */ new Map();
+			for (const raw of parsed["credentials"]) {
+				const entry = normalizeEntry(raw);
+				if (entry !== void 0) byId.set(entry.id, entry);
+			}
+			const entries = [...byId.values()];
+			const requested = typeof parsed["activeId"] === "string" ? parsed["activeId"] : void 0;
+			return {
+				entries,
+				activeId: requested !== void 0 && entries.some((entry) => entry.id === requested) ? requested : entries[0]?.id
+			};
+		}
 		const pat = typeof parsed["pat"] === "string" ? parsed["pat"].trim() : "";
 		if (pat === "") return void 0;
 		const region = isRegion(parsed["region"]) ? parsed["region"] : this.variant.region;
 		const savedAt = typeof parsed["savedAt"] === "number" && Number.isFinite(parsed["savedAt"]) ? parsed["savedAt"] : void 0;
-		return {
+		const entry = {
+			id: qoderCredentialId(pat),
 			pat,
 			region,
-			...savedAt === void 0 ? {} : { savedAtMs: savedAt },
-			source: "card"
+			...savedAt === void 0 ? {} : { savedAtMs: savedAt }
+		};
+		return {
+			entries: [entry],
+			activeId: entry.id
 		};
 	}
-	async writeOwn(credential) {
+	async writeDocument(entries, activeId) {
+		if (entries.length === 0) {
+			await this.clear();
+			return;
+		}
 		const document = {
 			version: AUTH_SCHEMA_VERSION,
-			pat: credential.pat,
-			region: credential.region,
-			savedAt: credential.savedAtMs ?? Date.now()
+			activeId: activeId !== void 0 && entries.some((entry) => entry.id === activeId) ? activeId : entries[0].id,
+			credentials: entries.map((entry) => ({
+				id: entry.id,
+				pat: entry.pat,
+				region: entry.region,
+				savedAt: entry.savedAtMs ?? Date.now(),
+				...entry.label === void 0 ? {} : { label: entry.label }
+			}))
 		};
 		const directory = dirname(this.ownPath);
 		try {
@@ -426,6 +617,10 @@ var QoderCredentialStore = class {
 		this.pendingLegacyReason = void 0;
 	}
 };
+/** Newest first, with a stable tie-break so the select order never jitters. */
+function newestFirst$1(a, b) {
+	return (b.savedAtMs ?? 0) - (a.savedAtMs ?? 0) || a.id.localeCompare(b.id);
+}
 /**
 * The plugin-owned credential path for one variant's default filename.
 * Kept as a free function for the CLI, which builds no store per display line.
@@ -4105,7 +4300,7 @@ const IMAGE_MEDIA_TYPES = [
 	"image/webp",
 	"image/gif"
 ];
-function isRecord(value) {
+function isRecord$1(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function requiredString(value, what) {
@@ -4146,7 +4341,7 @@ async function openAiContentBlocks(content, role, imagesAs) {
 		throw new UpstreamRequestError(`${role} message content must be a string or a parts array`);
 	})();
 	for (const raw of parts) {
-		if (!isRecord(raw) || typeof raw["type"] !== "string") throw new UpstreamRequestError(`${role} message content part is malformed`);
+		if (!isRecord$1(raw) || typeof raw["type"] !== "string") throw new UpstreamRequestError(`${role} message content part is malformed`);
 		switch (raw["type"]) {
 			case "text":
 				blocks.push({
@@ -4157,7 +4352,7 @@ async function openAiContentBlocks(content, role, imagesAs) {
 			case "image_url": {
 				if (role !== "user") throw new UpstreamRequestError("image parts are valid only in user messages");
 				const imageUrl = raw["image_url"];
-				const url = isRecord(imageUrl) && typeof imageUrl["url"] === "string" ? imageUrl["url"] : "";
+				const url = isRecord$1(imageUrl) && typeof imageUrl["url"] === "string" ? imageUrl["url"] : "";
 				if (!url.toLowerCase().startsWith("data:")) throw new UpstreamRequestError("image_url must be an inline data: URL; remote image URLs are not fetched");
 				if (imagesAs === void 0) throw new UpstreamRequestError("image input requires the DSH attachment service");
 				const decoded = decodeDataImage(url);
@@ -4186,14 +4381,14 @@ async function toGenerateOptions(bodyJson, context) {
 	} catch {
 		throw new UpstreamRequestError("request body is not valid JSON");
 	}
-	if (!isRecord(parsed)) throw new UpstreamRequestError("request body must be a JSON object");
+	if (!isRecord$1(parsed)) throw new UpstreamRequestError("request body must be a JSON object");
 	const model = requiredString(parsed["model"], "model");
 	const rawMessages = parsed["messages"];
 	if (!Array.isArray(rawMessages) || rawMessages.length === 0) throw new UpstreamRequestError("messages must be a non-empty array");
 	const systemParts = [];
 	const messages = [];
 	for (const raw of rawMessages) {
-		if (!isRecord(raw)) throw new UpstreamRequestError("each message must be an object");
+		if (!isRecord$1(raw)) throw new UpstreamRequestError("each message must be an object");
 		const role = raw["role"];
 		switch (role) {
 			case "system":
@@ -4219,8 +4414,8 @@ async function toGenerateOptions(bodyJson, context) {
 				const content = await openAiContentBlocks(raw["content"], "assistant", void 0);
 				const rawCalls = raw["tool_calls"];
 				if (Array.isArray(rawCalls)) for (const rawCall of rawCalls) {
-					if (!isRecord(rawCall)) throw new UpstreamRequestError("each tool call must be an object");
-					const fn = isRecord(rawCall["function"]) ? rawCall["function"] : rawCall;
+					if (!isRecord$1(rawCall)) throw new UpstreamRequestError("each tool call must be an object");
+					const fn = isRecord$1(rawCall["function"]) ? rawCall["function"] : rawCall;
 					content.push({
 						type: "tool-call",
 						id: ToolCallId(requiredString(rawCall["id"], "tool call id")),
@@ -4244,8 +4439,8 @@ async function toGenerateOptions(bodyJson, context) {
 				let text;
 				if (typeof content === "string") text = content;
 				else if (Array.isArray(content)) {
-					text = content.filter((part) => isRecord(part) && part["type"] === "text").map((part) => typeof part["text"] === "string" ? part["text"] : "").join("");
-					if (content.some((part) => isRecord(part) && part["type"] !== "text")) throw new UpstreamRequestError("tool result content is limited to text");
+					text = content.filter((part) => isRecord$1(part) && part["type"] === "text").map((part) => typeof part["text"] === "string" ? part["text"] : "").join("");
+					if (content.some((part) => isRecord$1(part) && part["type"] !== "text")) throw new UpstreamRequestError("tool result content is limited to text");
 				} else throw new UpstreamRequestError("tool message content must be a string or a text-parts array");
 				messages.push(createToolResultMessage({
 					callId: ToolCallId(callId),
@@ -4262,13 +4457,13 @@ async function toGenerateOptions(bodyJson, context) {
 	}
 	if (messages.length === 0) throw new UpstreamRequestError("the request carries no model-facing message");
 	const tools = Array.isArray(parsed["tools"]) ? parsed["tools"].map((raw) => {
-		if (!isRecord(raw)) throw new UpstreamRequestError("each tool must be an object");
-		const fn = isRecord(raw["function"]) ? raw["function"] : raw;
-		if (!isRecord(fn)) throw new UpstreamRequestError("each tool must carry a function object");
+		if (!isRecord$1(raw)) throw new UpstreamRequestError("each tool must be an object");
+		const fn = isRecord$1(raw["function"]) ? raw["function"] : raw;
+		if (!isRecord$1(fn)) throw new UpstreamRequestError("each tool must carry a function object");
 		return {
 			name: requiredString(fn["name"], "tool name"),
 			description: typeof fn["description"] === "string" ? fn["description"] : "",
-			parameters: isRecord(fn["parameters"]) ? fn["parameters"] : {}
+			parameters: isRecord$1(fn["parameters"]) ? fn["parameters"] : {}
 		};
 	}) : void 0;
 	const effort = parsed["reasoning_effort"];
@@ -4430,6 +4625,17 @@ var ChunkEncoder = class {
 		} }), SSE_DONE];
 	}
 };
+/**
+* Normalize a provider retry hint for {@link QoderChatResult}.
+*
+* Only a positive finite number is a hint: the truncation keeps the shim's
+* `Retry-After` header an integer number of seconds, and `undefined` keeps the
+* optional field off the result entirely (no `retryAfterMs: undefined` noise in
+* the shim's error body).
+*/
+function retryHintOf(value) {
+	return typeof value === "number" && Number.isFinite(value) && value > 0 ? { retryAfterMs: Math.floor(value) } : {};
+}
 /** Turn any thrown failure into the shim's classified pre-stream result. */
 function failureResult(error) {
 	if (error instanceof UpstreamRequestError) return {
@@ -4444,7 +4650,8 @@ function failureResult(error) {
 			ok: false,
 			status: typeof error.failure.status === "number" && error.failure.status >= 100 && error.failure.status <= 599 ? error.failure.status : KIND_STATUS[kind],
 			kind,
-			message: error.failure.message
+			message: error.failure.message,
+			...retryHintOf(error.failure.providerRetryAfterMs)
 		};
 	}
 	return {
@@ -4624,7 +4831,8 @@ var QoderUpstreamClient = class {
 						ok: false,
 						status: earlyFailure.status ?? KIND_STATUS[kind],
 						kind,
-						message: earlyFailure.message
+						message: earlyFailure.message,
+						...retryHintOf(earlyFailure.providerRetryAfterMs)
 					};
 				}
 			}
@@ -4823,8 +5031,223 @@ const DEFAULT_MAX_TOKENS = 32768;
 /** A conservative input budget for rows that declare none. */
 const DEFAULT_CONTEXT_WINDOW = 18e4;
 //#endregion
+//#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 in the plugin's own state directory, never beside the
+* product's files, and carries no token, prompt, or response body — only
+* model ids, effort spellings, and timestamps.
+*
+* @module dsh-qoder-connect/probe-store
+*/
+/** Basename of the China variant's probe record inside the plugin's state dir. */
+const QODER_PROBE_FILENAME = ".qoder-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 plugin's state directory.
+*
+* One file per variant. The two regions serve overlapping model ids with
+* different entitlements, 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 qoderProbePath(filename = QODER_PROBE_FILENAME) {
+	return join(qoderStateDir(), filename);
+}
+/**
+* Fingerprint the catalog fields a probe depends on.
+*
+* Deliberately excludes display-only fields (`name`, `billing`, `contextWindow`)
+* so a rename or a rate relabel 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 QoderProbeStore = class {
+	path;
+	ttlMs;
+	pluginVersion;
+	now;
+	records;
+	constructor(options) {
+		const opts = typeof options === "string" ? {
+			path: options,
+			pluginVersion: "0.0.0"
+		} : options;
+		this.path = opts.path ?? qoderProbePath();
+		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();
+	}
+	/**
+	* Drop every record that belongs to one account, leaving the other saved
+	* accounts' observations intact.
+	*
+	* Used when a saved token is removed: its detected effort levels are that
+	* account's data, and no other account can use them. A plain {@link clear}
+	* here would erase the observations of every account the user still has.
+	*/
+	clearFor(account) {
+		const records = this.load();
+		let removed = false;
+		for (const [modelId, record] of Object.entries(records)) {
+			if (record.account !== account) continue;
+			delete records[modelId];
+			removed = true;
+		}
+		if (removed) 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/version.ts
-const QODER_CONNECT_VERSION = "0.2.6";
+const QODER_CONNECT_VERSION = "0.2.8";
 //#endregion
 //#region src/host-heartbeat.ts
 /**
@@ -5021,4 +5444,4 @@ function variantFor(id) {
 	return QODER_VARIANTS.find((variant) => variant.id === id);
 }
 //#endregion
-export { QoderCatalog as A, QODER_PAT_ENV_GLOBAL as B, getMachineId as C, QoderCatalogStore as D, randomSentinel as E, QODER_PROBE_PATH as F, QODER_DATA_DIR_ENV as G, patTail as H, QODER_SETTINGS_FACE_PATH as I, qoderMachineIdPath as J, QODER_DATA_DIR_NAME as K, QODER_STATUS_PATH as L, QODER_GLOBAL_AUTH_PATH as M, QODER_GLOBAL_PROBE_PATH as N, qoderCatalogPath as O, QODER_GLOBAL_STATUS_PATH as P, QODER_AUTH_FILENAME as R, utc8WallClock as S, probeModel as T, qoderCredentialIdentity as U, QoderCredentialStore as V, qoderOwnAuthPath as W, qoderStateDir as X, qoderPluginDataDir as Y, modelInfoOf as _, QODER_HOST_HEARTBEAT_FILENAME as a, createQoderTransport as b, processStartTimeMs as c, writeHostHeartbeat as d, QODER_CONNECT_VERSION as f, kindFromQoderFailure as g, classifyUpstreamError as h, variantFor as i, QODER_AUTH_PATH as j, FALLBACK_QODER_MODELS as k, qoderHostHeartbeatPath as l, QoderUpstreamClient as m, GLOBAL_VARIANT as n, clearHostHeartbeat as o, KIND_STATUS as p, configurePluginPaths as q, QODER_VARIANTS as r, isHeartbeatProcessAlive as s, CHINA_VARIANT as t, readHostHeartbeat as u, normalizeCredits as v, PROBE_EFFORT_CANDIDATES as w, formatUtc8Date as x, validateApiKey as y, QODER_PAT_ENV_CN as z };
+export { configurePluginPaths as $, probeModel as A, QODER_PROBE_PATH as B, normalizeCredits as C, utc8WallClock as D, formatUtc8Date as E, QoderCatalog as F, QODER_PAT_ENV_GLOBAL as G, QODER_STATUS_PATH as H, QODER_AUTH_PATH as I, qoderCredentialId as J, QoderCredentialStore as K, QODER_GLOBAL_AUTH_PATH as L, QoderCatalogStore as M, qoderCatalogPath as N, getMachineId as O, FALLBACK_QODER_MODELS as P, QODER_DATA_DIR_NAME as Q, QODER_GLOBAL_PROBE_PATH as R, modelInfoOf as S, createQoderTransport as T, QODER_AUTH_FILENAME as U, QODER_SETTINGS_FACE_PATH as V, QODER_PAT_ENV_CN as W, qoderOwnAuthPath as X, qoderCredentialIdentity as Y, QODER_DATA_DIR_ENV as Z, qoderProbePath as _, QODER_HOST_HEARTBEAT_FILENAME as a, classifyUpstreamError as b, processStartTimeMs as c, writeHostHeartbeat as d, qoderMachineIdPath as et, QODER_CONNECT_VERSION as f, newestFirst as g, fingerprintModel as h, variantFor as i, randomSentinel as j, PROBE_EFFORT_CANDIDATES as k, qoderHostHeartbeatPath as l, QoderProbeStore as m, GLOBAL_VARIANT as n, clearHostHeartbeat as o, QODER_PROBE_FILENAME as p, patTail as q, QODER_VARIANTS as r, isHeartbeatProcessAlive as s, CHINA_VARIANT as t, qoderPluginDataDir as tt, readHostHeartbeat as u, KIND_STATUS as v, validateApiKey as w, kindFromQoderFailure as x, QoderUpstreamClient as y, QODER_GLOBAL_STATUS_PATH as z };