dsh-connect-trae 4.4.4 → 4.4.6

package/lib/index.js

@@ -6,7 +6,7 @@ import { PiAiAdapter } from "@deepseek-ai/dsh-llm-pi-ai";
 import { existsSync, readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { copyFile, readFile, rm, stat } from "node:fs/promises";
+import { copyFile, readFile, rename, rm, stat } from "node:fs/promises";
 import { createCipheriv, createDecipheriv, createHash, randomBytes, randomUUID, sign, timingSafeEqual } from "node:crypto";
 import { withFileLock, writeFileAtomic } from "@deepseek-ai/dsh-atomic-write";
 import { resolveDshHome } from "@deepseek-ai/dsh-home-paths";
@@ -2223,21 +2223,55 @@ function credentialOfStored(stored) {
 * needed and an older install's file is never rejected. A malformed row is
 * dropped rather than failing the whole file — one bad imported account must
 * not hide the rest.
+*
+* Returns `undefined` — NOT an empty array — for a file this build cannot parse
+* at all: a torn JSON write, a hand-edited document, or a version nothing here
+* knows. The distinction is load-bearing (see {@link readOwnForMerge}): every
+* merge writer treats `[]` as the merge base but `undefined` as "do not build
+* on this", because an unparseable file may still HOLD every account, and
+* merging onto "empty" would erase them on the very next refresh.
 */
 function parseOwn(text) {
+	let document;
 	try {
-		const document = JSON.parse(text);
-		if (document.version === OWN_VERSION) {
-			if (!Array.isArray(document.credentials)) return [];
-			return document.credentials.map(credentialOfStored).filter((value) => value !== void 0);
-		}
-		if (document.version === OWN_VERSION_SINGLE) {
-			const single = credentialOfStored(document.credential);
-			return single === void 0 ? [] : [single];
-		}
-		return [];
+		const parsed = JSON.parse(text);
+		if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return void 0;
+		document = parsed;
 	} catch {
-		return [];
+		return;
+	}
+	if (document.version === OWN_VERSION) {
+		if (!Array.isArray(document.credentials)) return void 0;
+		return document.credentials.map(credentialOfStored).filter((value) => value !== void 0);
+	}
+	if (document.version === OWN_VERSION_SINGLE) {
+		const single = credentialOfStored(document.credential);
+		return single === void 0 ? void 0 : [single];
+	}
+}
+/**
+* Move a plugin-owned file this build can no longer parse out of the way, so
+* the next write starts from a clean file instead of building on — or being
+* refused by — the unreadable one.
+*
+* The rename is the data preservation: the bytes stay on disk beside the live
+* path (`.corrupt-<stamp>`), so a future build that understands the format (or
+* a user with a text editor) can still recover the accounts it carried. It is
+* best-effort on purpose: a quarantine that cannot happen must not fail the
+* user action that triggered it, and the merge writers refuse to overwrite a
+* file they could not quarantine (see {@link readOwnForMerge}).
+*
+* Must be called under the same lock the caller writes under: without the lock
+* the rename could interleave with a concurrent writer holding the pre-rename
+* content and write it right back.
+*/
+async function quarantineCorruptOwn(path) {
+	const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+	try {
+		await rename(path, `${path}.corrupt-${stamp}`);
+		return true;
+	} catch {
+		return false;
 	}
 }
 /**
@@ -2415,9 +2449,26 @@ var TraeCredentialStore = class {
 			return /* @__PURE__ */ new Set();
 		}
 	}
-	async writeTombstones(ids) {
+	/**
+	* Read, mutate, and write the tombstone list under ONE lock.
+	*
+	* The tombstone file is read-modify-write state shared by two flows that run
+	* concurrently: `mirrorLocalLogins` (drops tombstones whose logins are gone)
+	* and `deleteAccount` (adds the id just deleted). A read OUTSIDE the write's
+	* lock loses updates in both directions — a dropped-add resurrects a deleted
+	* account on the next mirror, a dropped-drop keeps a tombstone forever and
+	* hides every future sign-in of that account. The mutator therefore runs on
+	* the freshly-read set INSIDE the lock, and what it returns is what gets
+	* written, with no window in between.
+	*
+	* Fire-and-forget safe: a failed update only delays a tombstone change until
+	* the next mirror or delete, so errors are swallowed like the readers'.
+	*/
+	async updateTombstones(mutator) {
 		const path = this.deletedPath();
 		await withFileLock(path, async () => {
+			const ids = await this.readTombstones();
+			mutator(ids);
 			await writeFileAtomic(path, `${JSON.stringify({
 				version: 1,
 				ids: [...ids]
@@ -2425,7 +2476,31 @@ var TraeCredentialStore = class {
 				mode: 384,
 				dirMode: 448
 			});
-		});
+		}).catch(() => void 0);
+	}
+	/**
+	* Read the plugin-owned file as the merge base for a read-modify-write.
+	*
+	* This is the fail-safe that keeps one unreadable file from erasing every
+	* account: `parseOwn` now distinguishes a VALID empty file (`[]`) from one
+	* this build cannot parse (`undefined`), and only the former may serve as a
+	* merge base. For the latter the file is quarantined — renamed aside with
+	* its bytes intact — and the merge then starts from nothing, so the action
+	* the user pressed still succeeds and the lost entries are recoverable from
+	* the quarantine copy instead of being overwritten silently. A quarantine
+	* that fails (an exotic filesystem, a name collision) aborts the write
+	* instead: losing one refresh is recoverable by pressing it again, losing
+	* every account is not.
+	*
+	* Every caller must hold the {@link withFileLock} of `path` across BOTH the
+	* read and the subsequent write — this does not lock by itself.
+	*/
+	async readOwnForMerge(path) {
+		const text = await readFile(path, "utf8").catch(() => void 0);
+		if (text === void 0) return [];
+		const parsed = parseOwn(text);
+		if (parsed !== void 0) return parsed;
+		return await quarantineCorruptOwn(path) ? [] : void 0;
 	}
 	/**
 	* Copy every local Trae sign-in into this store's own file, once.
@@ -2447,20 +2522,17 @@ var TraeCredentialStore = class {
 		const { credentials: discovered } = await this.readDesktopAll();
 		const own = await this.readOwns();
 		const ownIds = new Set(own.map((credential) => traeAccountId(credential)));
-		const tombstones = await this.readTombstones();
 		const liveIds = new Set(discovered.map((credential) => traeAccountId(credential)));
-		let tombstonesChanged = false;
-		for (const id of [...tombstones]) {
-			if (liveIds.has(id)) continue;
-			tombstones.delete(id);
-			tombstonesChanged = true;
-		}
+		const tombstones = await this.readTombstones();
+		if ([...tombstones].some((id) => !liveIds.has(id))) await this.updateTombstones((ids) => {
+			for (const id of [...ids]) if (!liveIds.has(id)) ids.delete(id);
+		});
 		const missing = discovered.filter((credential) => this.matchesRegion(credential) && !ownIds.has(traeAccountId(credential)) && !tombstones.has(traeAccountId(credential)));
-		if (tombstonesChanged) await this.writeTombstones(tombstones);
 		if (missing.length === 0) return;
 		const ownPath = this.ownAuthPath();
 		await withFileLock(ownPath, async () => {
-			const existing = await readFile(ownPath, "utf8").then(parseOwn, () => []);
+			const existing = await this.readOwnForMerge(ownPath);
+			if (existing === void 0) return;
 			const byId = new Map(existing.map((credential) => [traeAccountId(credential), credential]));
 			for (const credential of missing) {
 				const id = traeAccountId(credential);
@@ -2748,7 +2820,8 @@ var TraeCredentialStore = class {
 		const ownPath = this.ownAuthPath();
 		const written = [];
 		await withFileLock(ownPath, async () => {
-			const existing = await readFile(ownPath, "utf8").then(parseOwn, () => []);
+			const existing = await this.readOwnForMerge(ownPath);
+			if (existing === void 0) return;
 			const byId = /* @__PURE__ */ new Map();
 			for (const item of existing) byId.set(traeAccountId(item), item);
 			for (const credential of credentials) {
@@ -2907,7 +2980,7 @@ var TraeCredentialStore = class {
 		let mutated = false;
 		for (const path of this.ownCandidates()) {
 			const dropped = await withFileLock(path, async () => {
-				const existing = await readFile(path, "utf8").then(parseOwn, () => null);
+				const existing = await readFile(path, "utf8").then((text) => parseOwn(text) ?? null, () => null);
 				if (existing === null || !existing.some((credential) => traeAccountId(credential) === accountId)) return false;
 				const next = existing.filter((credential) => traeAccountId(credential) !== accountId);
 				await writeOwn(path, next);
@@ -2915,11 +2988,9 @@ var TraeCredentialStore = class {
 			}).catch(() => false);
 			mutated = mutated || dropped;
 		}
-		const tombstones = await this.readTombstones();
-		if (!tombstones.has(accountId)) {
-			tombstones.add(accountId);
-			await this.writeTombstones(tombstones).catch(() => void 0);
-		}
+		await this.updateTombstones((ids) => {
+			ids.add(accountId);
+		});
 		if (this.accountId === accountId) {
 			this.accountId = void 0;
 			this.inflight = void 0;
@@ -3039,7 +3110,8 @@ var TraeCredentialStore = class {
 	async readOwns() {
 		const copies = [];
 		for (const path of this.ownCandidates()) try {
-			copies.push(...parseOwn(await readFile(path, "utf8")));
+			const parsed = parseOwn(await readFile(path, "utf8"));
+			if (parsed !== void 0) copies.push(...parsed);
 		} catch {}
 		return copies;
 	}
@@ -3061,7 +3133,8 @@ var TraeCredentialStore = class {
 			};
 			const ownPath = this.ownAuthPath();
 			await withFileLock(ownPath, async () => {
-				const existing = await readFile(ownPath, "utf8").then(parseOwn, () => []);
+				const existing = await this.readOwnForMerge(ownPath);
+				if (existing === void 0) return;
 				const refreshedId = traeAccountId(refreshed);
 				const entries = existing.filter((item) => traeAccountId(item) !== refreshedId);
 				entries.push(refreshed);
@@ -3513,6 +3586,182 @@ function identityHeaders(identity) {
 	};
 }
 //#endregion
+//#region src/model-order.ts
+/**
+* Wire name of the default SOLO chat function.
+*
+* Lives here rather than in `solo.ts` so this module stays importable from the
+* client; `solo.ts` re-exports it, so there is still exactly one definition.
+*/
+const TRAE_SOLO_FUNCTION = "solo_work_lite";
+/**
+* The chat functions of one region, in PRIORITY order.
+*
+* Two consumers read it, and both mean "priority", which is why they can share
+* one array: the wire asks these functions in order and the first to list a
+* config owns it (`solo.ts`), and the card draws the groups in the same order so
+* the row a user sees first is the one the resolver prefers.
+*/
+const TRAE_CHANNEL_PRIORITY = {
+	cn: [
+		"solo_work_remote",
+		TRAE_SOLO_FUNCTION,
+		"solo_agent_remote",
+		"chat_v3",
+		"solo_coder"
+	],
+	ai: [
+		"solo_work_remote",
+		TRAE_SOLO_FUNCTION,
+		"solo_agent_remote",
+		"chat_v3"
+	]
+};
+/**
+* Rank of one channel inside the region's priority list.
+*
+* Three cases, and the order between them is deliberate:
+*
+*  - a known chat channel: its index in the priority list;
+*  - an UNKNOWN channel name (a function the region does not call through —
+*    `withChatCallableFunctions` clears those, so this is a defensive branch):
+*    after every known channel, then alphabetically among themselves;
+*  - NO channel at all (a row demoted to the default chat function): last. Such
+*    a row is the one the resolver knows least about, so it must not push a
+*    properly attributed row down the list.
+*/
+function channelRank(channel, priority) {
+	if (channel === void 0 || channel === "") return priority.length + 1;
+	const known = priority.indexOf(channel);
+	return known === -1 ? priority.length : known;
+}
+/**
+* Compare two display names the way a person reading a model list expects:
+* case-insensitively, with embedded numbers compared as NUMBERS, so `GLM-5.10`
+* sorts after `GLM-5.9`. Plain text comparison puts `5.10` first, which reads as
+* a bug to anyone who sees the version numbers.
+*/
+function compareNames(left, right) {
+	const byName = left.trim().localeCompare(right.trim(), void 0, {
+		numeric: true,
+		sensitivity: "base"
+	});
+	return byName !== 0 ? byName : left.localeCompare(right);
+}
+/**
+* The catalog in display order: channel priority first, then name.
+*
+* Total and stable — ties fall through to `id`, so two rows with the same name
+* in the same channel still get one fixed order rather than the order they
+* arrived in.
+*/
+function orderTraeModels(rows, region = "cn") {
+	const priority = TRAE_CHANNEL_PRIORITY[region] ?? TRAE_CHANNEL_PRIORITY.cn;
+	return [...rows].sort((left, right) => {
+		const byRank = channelRank(left.wireFunction, priority) - channelRank(right.wireFunction, priority);
+		if (byRank !== 0) return byRank;
+		if (left.wireFunction !== right.wireFunction) return (left.wireFunction ?? "").localeCompare(right.wireFunction ?? "");
+		const byName = compareNames(left.name, right.name);
+		return byName !== 0 ? byName : left.id.localeCompare(right.id);
+	});
+}
+/**
+* Split rows into channel groups, in display order.
+*
+* Ordering is re-applied here rather than trusted from the caller: a group list
+* built from an unsorted input would put the groups in arrival order, which is
+* the exact instability this module exists to remove.
+*/
+function groupTraeModels(rows, region = "cn") {
+	const groups = [];
+	const byChannel = /* @__PURE__ */ new Map();
+	for (const row of orderTraeModels(rows, region)) {
+		const channel = row.wireFunction === "" ? void 0 : row.wireFunction;
+		const key = channel ?? "\0default";
+		const existing = byChannel.get(key);
+		if (existing !== void 0) {
+			existing.rows.push(row);
+			continue;
+		}
+		const group = {
+			channel,
+			rows: [row]
+		};
+		byChannel.set(key, group);
+		groups.push(group);
+	}
+	return groups;
+}
+/**
+* Does one row match a search query?
+*
+* Matches the display name, the display id and the WIRE config name — the last
+* one because a user debugging a `4001 config_name rejected` arrives with the
+* upstream name in hand, and the two differ exactly on the rows that carry a
+* suffix (`DeepSeek-V4-Flash` vs `DeepSeek-V4-Flash-Official`).
+*/
+function traeModelMatchesQuery(model, query) {
+	const needle = query.trim().toLowerCase();
+	if (needle === "") return true;
+	if (model.name.toLowerCase().includes(needle)) return true;
+	if (model.id.toLowerCase().includes(needle)) return true;
+	return (model.wireConfigName ?? "").toLowerCase().includes(needle);
+}
+/** Filter by {@link traeModelMatchesQuery}, preserving order. */
+function filterTraeModels(rows, query) {
+	if (query.trim() === "") return [...rows];
+	return rows.filter((row) => traeModelMatchesQuery(row, query));
+}
+/**
+* The channels a NORMAL Trae chat session actually runs on: the `solo_work_*`
+* family, i.e. the panel's own chat modes.
+*
+* Deliberately not "every channel we can call". After issue #52 P1 the catalog
+* is 34 rows and 10 of them are reachable only through a SPECIALIST channel:
+* `solo_coder` (7: `Doubao-Seed-2.0-Code`, `glm-5.1`, `glm-5v-turbo`,
+* `kimi-k2.5`, `minimax-m2.7`, `qwen-3.5`, `qwen-3.6-plus`), `chat_v3` (2:
+* `kimi-k2.8-preview`, `qwen3.8-flash`) and `solo_agent_remote` (1:
+* `Doubao-Seed-Code`). Measured 2026-10-23 on a live CN account. Those rows work
+* — that is why P1 kept them — but they are not what Trae's main chat offers,
+* and mixing them into the default view is exactly the "a code model answering a
+* solo request" shape issue #52 asked about.
+*/
+const TRAE_COMMON_FUNCTIONS = {
+	cn: ["solo_work_remote", TRAE_SOLO_FUNCTION],
+	ai: ["solo_work_remote", TRAE_SOLO_FUNCTION]
+};
+/**
+* The function a request for this row will NAME.
+*
+* A row with no `wireFunction` is not "unknown to the wire": the bridge sends
+* the region default (`TRAE_SOLO_FUNCTION`), so for every question about where
+* the turn goes, the default is the answer. The distinction still matters for
+* DISPLAY (`groupTraeModels` keeps these in their own group, because their
+* provenance — which directory group advertised them — really is unknown), but
+* not for scope: a `solo_work_lite` turn is a normal chat turn either way.
+*/
+function traeModelCallChannel(model) {
+	const channel = model.wireFunction;
+	return channel === void 0 || channel === "" ? TRAE_SOLO_FUNCTION : channel;
+}
+/**
+* Does this row belong to the view?
+*
+* Judged on {@link traeModelCallChannel}, never on `wireFunction` directly:
+* otherwise the one row without a function (`doubao_1_8`, measured 2026-10-23)
+* would fall OUT of the common view while being called through exactly the
+* common channel it belongs to.
+*/
+function traeModelInView(model, view, region = "cn") {
+	if (view === "all") return true;
+	return (TRAE_COMMON_FUNCTIONS[region] ?? TRAE_COMMON_FUNCTIONS.cn).includes(traeModelCallChannel(model));
+}
+/** Keep the rows a view asks for, preserving order. */
+function scopeTraeModels(rows, view, region = "cn") {
+	if (view === "all") return [...rows];
+	return rows.filter((row) => traeModelInView(row, view, region));
+}
+//#endregion
 //#region src/shim.ts
 const BODY_LIMIT = 67108864;
 const LOOPBACK_HOSTS = /* @__PURE__ */ new Set([
@@ -3772,6 +4021,48 @@ function createTraeShim(options) {
 	};
 }
 //#endregion
+//#region src/model-detail.ts
+const TRAE_MODEL_DETAIL_PATH = "/api/ide/v1/batch_get_detail_param";
+const TRAE_MODEL_DETAIL_FUNCTIONS = [
+	"ui_builder_v2",
+	"solo_coder",
+	"chat_v3",
+	"solo_builder",
+	"builder_v3",
+	"builder",
+	"chat",
+	"inline_chat",
+	"git_ai",
+	"custom_agent_generation",
+	"utils",
+	"code_reviewer",
+	"code_review_summary",
+	"solo_agent",
+	"solo_agent_remote",
+	"solo_work_remote",
+	"solo_agent_lite",
+	"solo_work_lite",
+	"solo_design_lite",
+	"solo_design_remote",
+	"multimodal",
+	"system_diagnosis"
+];
+/** Build the exact request shape observed in successful current Trae CN logs. */
+function buildTraeModelDetailRequest(configName = "", custom = false) {
+	return {
+		functions: [...TRAE_MODEL_DETAIL_FUNCTIONS],
+		agent_type: configName === "" ? "" : "solo_agent",
+		current_config_info: {
+			config_name: configName,
+			is_custom_model: custom
+		},
+		mode_type: 0,
+		access_type: 0,
+		ab_force_vids: "",
+		ab_autotest_advanced_mode: 0
+	};
+}
+//#endregion
 //#region src/protocol.ts
 const TRAE_CN_AGENT_TASK_PATH = "/api/agent/v3/create_agent_task";
 const TRAE_CN_TITLE_PATH = "/api/agent/v3/llm_utils_chat";
@@ -3875,6 +4166,231 @@ function traeEndpoint(baseUrl, path) {
 	return `${baseUrl.replace(/\/$/, "")}/${path.replace(/^\//, "")}`;
 }
 //#endregion
+//#region src/official-roster.ts
+const CHAT_USAGE = "chat_completion";
+/**
+* Parse a `batch_get_detail_param` answer into a per-(config, function) index.
+*
+* Tolerant on purpose: this document is 1.8 MB of upstream-owned shape
+* (`function_configs[] → config_info_list[] → model_detail_list[]`), and the
+* plugin must not lose the whole refresh because one nested field changed
+* spelling. Rows that cannot be read are skipped; a document with no
+* `function_configs` at all yields an empty roster, which the filter reads as
+* "nothing to say" rather than "hide everything".
+*
+* Duplicate pairs are collapsed first-wins, matching the rest of the catalog's
+* convention (`mergeTraeModelSources`). Two functions can both list a config,
+* and those are DIFFERENT pairs, so both are kept.
+*/
+function parseTraeOfficialRoster(payload) {
+	const channels = /* @__PURE__ */ new Map();
+	const seen = /* @__PURE__ */ new Set();
+	let pairs = 0;
+	const document = typeof payload === "object" && payload !== null ? payload : {};
+	const groups = Array.isArray(document["function_configs"]) ? document["function_configs"] : [];
+	for (const group of groups) {
+		if (typeof group !== "object" || group === null) continue;
+		const record = group;
+		const functionName = typeof record["function"] === "string" ? record["function"] : "";
+		if (functionName === "") continue;
+		const list = Array.isArray(record["config_info_list"]) ? record["config_info_list"] : [];
+		for (const item of list) {
+			if (typeof item !== "object" || item === null) continue;
+			const config = item;
+			const configName = typeof config["config_name"] === "string" ? config["config_name"].trim() : "";
+			if (configName === "") continue;
+			const key = `${functionName}\u0000${configName.toLowerCase()}`;
+			if (seen.has(key)) continue;
+			seen.add(key);
+			const channel = {
+				function: functionName,
+				usage: typeof config["usage"] === "string" ? config["usage"] : "",
+				enabled: config["config_switch"] !== false,
+				invisible: config["is_invisible_to_user"] === true
+			};
+			pairs += 1;
+			const bucket = channels.get(configName.toLowerCase());
+			if (bucket === void 0) channels.set(configName.toLowerCase(), [channel]);
+			else bucket.push(channel);
+		}
+	}
+	return {
+		channels,
+		size: {
+			configs: channels.size,
+			pairs
+		}
+	};
+}
+/** The `config_name` a catalog row would actually send (see `wireConfigName`). */
+function officialKeyOf(model) {
+	return (model.wireConfigName ?? model.id).trim().toLowerCase();
+}
+/**
+* Decide one row from the roster.
+*
+* `chatFunctions` is the region's own `TRAE_DIRECTORY_FUNCTIONS` list, in
+* priority order: only those functions can carry a VERDICT, because only those
+* are functions `llm_utils_chat` accepts. A config the vendor shows under
+* `code_review_summary` alone is not offered as a chat model at all — that is
+* exactly the `glm-4.7` case, and it is a "hide", not a "re-pin".
+*
+* The verdict is `keep` when the roster cannot speak: no entry for the config
+* (measured 2026-10-23: `kimi-k2.8-preview` and `qwen3.8-flash` exist only in
+* the Remote directory's `chat_v3` group), only tool rows (`usage: 'summary'`,
+* `fast_apply`, …), or no chat function at all. Silence is never a verdict.
+*/
+function officialVerdictOf(model, roster, chatFunctions) {
+	const entries = roster.channels.get(officialKeyOf(model));
+	if (entries === void 0 || entries.length === 0) return { kind: "keep" };
+	const callable = entries.filter((entry) => entry.usage === "" || entry.usage === CHAT_USAGE).filter((entry) => chatFunctions.includes(entry.function));
+	if (callable.length === 0) return { kind: "keep" };
+	const listedBy = callable.map((entry) => entry.function);
+	const shown = callable.filter((entry) => !entry.invisible);
+	if (shown.length === 0) return {
+		kind: "hide",
+		function: model.wireFunction,
+		listedBy
+	};
+	const own = model.wireFunction === void 0 ? void 0 : callable.find((entry) => entry.function === model.wireFunction);
+	if (own !== void 0 && !own.invisible) return { kind: "keep" };
+	const to = chatFunctions.find((fn) => shown.some((entry) => entry.function === fn));
+	if (to === void 0) return { kind: "keep" };
+	return {
+		kind: "repin",
+		from: model.wireFunction,
+		to,
+		listedBy
+	};
+}
+/**
+* Apply the roster: retire what no chat function offers any more, and re-pin
+* what the vendor offers under a different channel.
+*
+* FAIL-OPEN BY CONSTRUCTION, which is the whole safety argument for applying
+* this by default:
+*
+*  - `undefined` roster (transport failure, restricted network, a credential
+*    that cannot read the IDE document) keeps EVERY row. A refresh must never
+*    lose models because a second, optional endpoint was unreachable.
+*  - `keep` covers every ambiguity — no entry, tool-only entries, a channel the
+*    roster does not name. Only an explicit "the vendor shows this nowhere we
+*    can call it" removes a row.
+*  - `config_switch === false` alone does NOT remove a row: the flag is
+*    recorded on {@link TraeOfficialChannel} but not used as a verdict, because
+*    its semantics are unmeasured and "disabled" there may describe a function
+*    override rather than the model itself.
+*
+* This is deliberately NOT "match the Trae client": the client renders one
+* function, the plugin serves the union, and issue #46's reporter wants the
+* dated snapshots the union carries. What changes here is only the class where
+* the union is provably wrong — twelve retired configs that made up the reported
+* "tail of old models", plus rows pinned to a channel their own vendor hides
+* them on (the "code model on a solo channel" risk of issue #52).
+*/
+function applyOfficialRoster(rows, roster, chatFunctions) {
+	if (roster === void 0) return {
+		rows: [...rows],
+		hidden: [],
+		repinned: []
+	};
+	const kept = [];
+	const hidden = [];
+	const repinned = [];
+	for (const row of rows) {
+		const verdict = officialVerdictOf(row, roster, chatFunctions);
+		if (verdict.kind === "hide") {
+			hidden.push({
+				id: row.id,
+				function: verdict.function
+			});
+			continue;
+		}
+		if (verdict.kind === "repin") {
+			repinned.push({
+				id: row.id,
+				from: verdict.from,
+				to: verdict.to
+			});
+			kept.push({
+				...row,
+				wireFunction: verdict.to
+			});
+			continue;
+		}
+		kept.push(row);
+	}
+	return {
+		rows: kept,
+		hidden,
+		repinned
+	};
+}
+/** How long one successful roster read stays usable, in milliseconds. */
+const ROSTER_CACHE_MS = 6e5;
+/** Timeout for the roster read. It is an OPTIONAL signal; it must not stall a refresh. */
+const ROSTER_TIMEOUT_MS = 2e4;
+/**
+* Reads the IDE's roster once per cache window and never throws.
+*
+* `undefined` is a first-class answer: it is what a caller sees when the
+* document could not be read, and {@link applyOfficialRoster} treats it as "no
+* opinion". Silence on failure is intentional — this is a refinement of a
+* refresh that already succeeded, so a strict error would turn a usable catalog
+* into a failed refresh.
+*/
+var TraeOfficialRosterClient = class {
+	options;
+	fetchImpl;
+	now;
+	cached;
+	/** The last failure, so a repeatedly-broken endpoint is not re-probed on every refresh. */
+	failedAt;
+	constructor(options) {
+		this.options = options;
+		this.fetchImpl = options.fetchImpl ?? fetch;
+		this.now = options.now ?? Date.now;
+	}
+	/** Cached roster, without any network I/O. */
+	cachedRoster() {
+		return this.cached === void 0 ? void 0 : this.cached.roster;
+	}
+	async fetch(signal) {
+		const now = this.now();
+		if (this.cached !== void 0 && now - this.cached.at < ROSTER_CACHE_MS) return this.cached.roster;
+		if (this.failedAt !== void 0 && now - this.failedAt < ROSTER_CACHE_MS) return void 0;
+		try {
+			const [credential, identity] = await Promise.all([this.options.credential(), this.options.identity()]);
+			const region = regionOfCredential(credential);
+			const base = this.options.baseUrl ?? (this.options.route === "enterprise" ? "https://console.enterprise.trae.cn" : REGION_GATEWAYS[region].chat);
+			const response = await this.fetchImpl(traeEndpoint(base, TRAE_MODEL_DETAIL_PATH), {
+				method: "POST",
+				headers: buildTraeCnHeaders(credential, identity, { profile: "model-detail" }),
+				body: JSON.stringify({
+					...buildTraeModelDetailRequest(""),
+					show_custom_model: true
+				}),
+				signal: signal ?? AbortSignal.timeout(ROSTER_TIMEOUT_MS)
+			});
+			if (!response.ok) throw new Error(`HTTP ${response.status}`);
+			const roster = parseTraeOfficialRoster(await response.json());
+			if (roster.size.configs === 0) throw new Error("roster document carried no config_name");
+			this.cached = {
+				at: now,
+				roster
+			};
+			this.failedAt = void 0;
+			return roster;
+		} catch (error) {
+			this.failedAt = now;
+			this.options.log?.("dsh-connect-trae: IDE model roster unavailable, keeping every discovered row", { reason: error instanceof Error ? error.message : String(error) });
+			return;
+		}
+	}
+};
+/** Where the client asks for the roster; re-exported so diagnostics do not hard-code it. */
+const TRAE_OFFICIAL_ROSTER_PATH = TRAE_MODEL_DETAIL_PATH;
+//#endregion
 //#region src/raw-chat.ts
 const TRAE_RAW_CHAT_V2_PATH = "/api/ide/v2/llm_raw_chat";
 const TRAE_RAW_CHAT_V1_PATH = "/api/ide/v1/llm_raw_chat";
@@ -4138,7 +4654,6 @@ function applyReasoningEffort(body, effort, capability) {
 }
 //#endregion
 //#region src/solo.ts
-const TRAE_SOLO_FUNCTION = "solo_work_lite";
 /**
 * `llm_utils_chat` functions to union per region, in priority order.
 *
@@ -4202,22 +4717,12 @@ const TRAE_SOLO_FUNCTION = "solo_work_lite";
 * A model in NO chat function's roster is still left to the merge: it ships
 * with no wire target and its call fails with a readable upstream message
 * rather than being hidden (see mergeTraeModelSources).
+*
+* The list itself lives in {@link TRAE_CHANNEL_PRIORITY} (`model-order.ts`) and
+* is aliased here, not copied: the card groups its rows by these same names in
+* this same order.
 */
-const TRAE_DIRECTORY_FUNCTIONS = {
-	cn: [
-		"solo_work_remote",
-		TRAE_SOLO_FUNCTION,
-		"solo_agent_remote",
-		"chat_v3",
-		"solo_coder"
-	],
-	ai: [
-		"solo_work_remote",
-		TRAE_SOLO_FUNCTION,
-		"solo_agent_remote",
-		"chat_v3"
-	]
-};
+const TRAE_DIRECTORY_FUNCTIONS = TRAE_CHANNEL_PRIORITY;
 const TRAE_SOLO_CHAT_PATH = "/api/agent/v3/llm_utils_chat";
 const TRAE_SOLO_MODELS_PATH = "/api/ide/v1/get_detail_param";
 function classify(status) {
@@ -8822,24 +9327,28 @@ async function writeTraePoolProbes(panel, updates) {
 * member, and leaving it in the file would resurrect a stale `rate-limited` row if
 * the account were added back later. Written through the same lock/atomic path so a
 * removal cannot interleave with a batch.
+*
+* The READ also sits inside the lock, like {@link writeTraePoolProbes}'s: a
+* delete is a read-modify-write, and a read taken outside the lock snapshots a
+* moment that a concurrent batch's write can then be older than — the delete
+* would write that stale snapshot back and silently discard the measurements
+* the batch had just learned.
 */
 async function dropTraePoolProbe(panel, accountId) {
-	const existing = await readTraePoolProbes(panel);
-	if (existing[accountId] === void 0) return;
 	const path = traePoolStorePath(panel);
-	const probes = {};
-	for (const [id, probe] of Object.entries(existing)) if (id !== accountId) probes[id] = probe;
-	try {
-		await withFileLock(path, async () => {
-			await writeFileAtomic(path, `${JSON.stringify({
-				version: STORE_FORMAT_VERSION,
-				probes
-			}, null, 2)}\n`, {
-				mode: 384,
-				dirMode: 448
-			});
+	await withFileLock(path, async () => {
+		const existing = await readTraePoolProbes(panel);
+		if (existing[accountId] === void 0) return;
+		const probes = {};
+		for (const [id, probe] of Object.entries(existing)) if (id !== accountId) probes[id] = probe;
+		await writeFileAtomic(path, `${JSON.stringify({
+			version: STORE_FORMAT_VERSION,
+			probes
+		}, null, 2)}\n`, {
+			mode: 384,
+			dirMode: 448
 		});
-	} catch {}
+	}).catch(() => {});
 }
 //#endregion
 //#region src/model-config.ts
@@ -8898,48 +9407,6 @@ function parseTraeModelExtraConfigLogLine(line) {
 	}
 }
 //#endregion
-//#region src/model-detail.ts
-const TRAE_MODEL_DETAIL_PATH = "/api/ide/v1/batch_get_detail_param";
-const TRAE_MODEL_DETAIL_FUNCTIONS = [
-	"ui_builder_v2",
-	"solo_coder",
-	"chat_v3",
-	"solo_builder",
-	"builder_v3",
-	"builder",
-	"chat",
-	"inline_chat",
-	"git_ai",
-	"custom_agent_generation",
-	"utils",
-	"code_reviewer",
-	"code_review_summary",
-	"solo_agent",
-	"solo_agent_remote",
-	"solo_work_remote",
-	"solo_agent_lite",
-	"solo_work_lite",
-	"solo_design_lite",
-	"solo_design_remote",
-	"multimodal",
-	"system_diagnosis"
-];
-/** Build the exact request shape observed in successful current Trae CN logs. */
-function buildTraeModelDetailRequest(configName = "", custom = false) {
-	return {
-		functions: [...TRAE_MODEL_DETAIL_FUNCTIONS],
-		agent_type: configName === "" ? "" : "solo_agent",
-		current_config_info: {
-			config_name: configName,
-			is_custom_model: custom
-		},
-		mode_type: 0,
-		access_type: 0,
-		ab_force_vids: "",
-		ab_autotest_advanced_mode: 0
-	};
-}
-//#endregion
 //#region src/redact.ts
 /**
 * Redaction helpers for diagnostics that a user may paste into a public issue.
@@ -9421,6 +9888,24 @@ function apply(ctx, config) {
 			credential: () => store.resolve(),
 			log: (message, detail) => ctx.logger.warn(message, detail)
 		});
+		/**
+		* The IDE's own roster: which models the vendor's picker shows, per
+		* function (issue #52).
+		*
+		* It is a REFINEMENT of a successful discovery, never a dependency: every
+		* failure path in {@link TraeOfficialRosterClient.fetch} collapses to
+		* `undefined`, and `applyOfficialRoster` then keeps every row. That is why
+		* this can be wired in without a setting — it only acts where every chat
+		* function hides a config (retire it) or where the vendor shows it on a
+		* DIFFERENT chat function than the one we guessed (re-pin). Both are the
+		* upstream's own answers, and both leave anything ambiguous alone.
+		*/
+		const officialRoster = new TraeOfficialRosterClient({
+			credential: () => store.resolve(),
+			identity,
+			...panel === "enterprise" ? { route: "enterprise" } : {},
+			log: (message, detail) => ctx.logger.warn(message, detail)
+		});
 		const wireResolver = (displayId) => wire.byId.get(displayId) ?? wire.byName.get(displayId.trim().toLowerCase());
 		/**
 		* One client + bridge per provider id.
@@ -9572,25 +10057,52 @@ function apply(ctx, config) {
 				};
 			},
 			discoverModels: async (signal) => {
-				const merged = mergeTraeModelSources(await withDirectoryRetry(() => remoteCatalog.fetchModels(signal)), await solo.fetchModels(signal));
+				const remote = await withDirectoryRetry(() => remoteCatalog.fetchModels(signal));
+				const [wireModels, roster] = await Promise.all([solo.fetchModels(signal), officialRoster.fetch(signal)]);
+				const merged = mergeTraeModelSources(remote, wireModels);
 				const callable = withChatCallableFunctions(merged, TRAE_DIRECTORY_FUNCTIONS[region]);
 				const chatFunctions = TRAE_DIRECTORY_FUNCTIONS[region];
 				for (const model of merged) {
 					if (model.wireFunction === void 0 || chatFunctions.includes(model.wireFunction)) continue;
 					ctx.logger.warn(`model directory row is pinned to a non-chat function and will be called through the default chat function instead: ${model.id} (pinned to function ${model.wireFunction})`);
 				}
+				/**
+				* Retire what no chat function offers any more, and re-pin what the
+				* vendor offers under a DIFFERENT channel (issue #52).
+				*
+				* Runs AFTER `withChatCallableFunctions` on purpose: that step decides
+				* the `wireFunction` this filter judges the row on. Rows the IDE roster
+				* does not mention, and every row when the roster could not be read at
+				* all, survive untouched — see `applyOfficialRoster`.
+				*/
+				const official = applyOfficialRoster(callable, roster, chatFunctions);
+				/**
+				* Fix the ORDER once, here, so it is a property of the catalog rather
+				* than of the screen that happens to draw it (issue #52, P0).
+				*
+				* The merge walks twelve directory groups and `solo-remote.ts` records
+				* that the group order varies between calls, so the same account could
+				* get two different lists from two refreshes. Sorting by (channel
+				* priority, name) makes the saved `lastCatalog` — and therefore the DSH
+				* model picker, which renders in catalog order — identical across
+				* refreshes. The card re-applies the same function for catalogs saved
+				* before this existed.
+				*/
+				const visible = orderTraeModels(official.rows, region);
+				if (official.hidden.length > 0) ctx.logger.warn(`hiding ${official.hidden.length} model(s) no chat function offers any more (issue #52)`, official.hidden);
+				if (official.repinned.length > 0) ctx.logger.warn(`re-pinning ${official.repinned.length} model(s) to the function their vendor shows them on (issue #52)`, official.repinned);
 				wire.callableKeys.clear();
-				for (const model of callable) {
+				for (const model of visible) {
 					wire.callableKeys.add(model.id.trim().toLowerCase());
 					wire.callableKeys.add(model.name.trim().toLowerCase());
 				}
-				wire.resolved = callable.length > 0;
-				const wireTargets = wireTargetsOf(callable);
+				wire.resolved = visible.length > 0;
+				const wireTargets = wireTargetsOf(visible);
 				wire.byId = wireTargets.byId;
 				wire.byName = wireTargets.byName;
 				latestDiscovery.length = 0;
-				latestDiscovery.push(...callable);
-				return callable;
+				latestDiscovery.push(...visible);
+				return visible;
 			},
 			/**
 			* One-click availability test. The ids come from the card, so each one is
@@ -10294,4 +10806,4 @@ function apply(ctx, config) {
 	});
 }
 //#endregion
-export { Config, FALLBACK_TRAE_MODELS, FALLBACK_TRAE_MODELS_AI, MAX_PROBE_INPUT_TOKENS, REGION_GATEWAYS, SseDecoder, TRAE_ACCOUNT_STATUS_PATH, TRAE_AI_PROVIDER, TRAE_CHECKIN_PATH, TRAE_CN_AGENT_TASK_PATH, TRAE_CN_TITLE_PATH, TRAE_ENTERPRISE_PROVIDER, TRAE_MODELS_TEST_PATH, TRAE_MODEL_DETAIL_FUNCTIONS, TRAE_MODEL_DETAIL_PATH, TRAE_PANELS, TRAE_PAY_BASE, TRAE_PROBE_TIMEOUT_MS, TRAE_PROVIDER, TRAE_PROVIDERS, TRAE_PROVIDER_DISPLAY_NAMES, TRAE_PROVIDER_IDS, TRAE_PROVIDER_ID_DISPLAY_NAMES, TRAE_PROVIDER_ROUTES, TRAE_RAW_CHAT_V1_PATH, TRAE_RAW_CHAT_V2_PATH, TRAE_REASONING_EFFORTS, TRAE_REGIONS, TRAE_REGION_PARAM, TRAE_SETTINGS_NS, TRAE_SOLO_CHAT_PATH, TRAE_SOLO_FUNCTION, TRAE_SOLO_MODELS_PATH, TRAE_SOLO_REMOTE_BASE, TRAE_STATE_DB_FILENAME, TRAE_STREAM_IDLE_TIMEOUT_MS, TRAE_USAGE_PATH, TRAE_VERSION_CODE_FALLBACK, TraeCatalog, TraeCredentialStore, TraeDelegatingUpstreamClient, TraeFallbackUpstreamClient, TraeGatedUpstreamClient, TraeRawCapabilityController, TraeRawCapabilityState, TraeRawChatUpstreamClient, TraeSoloBridge, TraeSoloRemoteCatalogClient, TraeSoloUpstreamClient, TraeUsageClient, UnconfiguredTraeUpstreamClient, adaptLegacyPiAiContext, adaptModernPiAiContext, apply, applyContextBudgets, applyImageSelection, applyReasoningEffort, asVolatile, bridgeTraeSoloStream, buildTraeAgentTaskBody, buildTraeCnHeaders, buildTraeFusionRawChatEnvelope, buildTraeModelDetailRequest, buildTraeRawChatDraft, buildTraeRawChatRuntimeConfig, classifyProbeError, classifyProbeResult, classifyTraeRawChatFailure, configuredAccountsOf, createTraeAdapter, createTraeRawGateway, createTraeShim, creditPosition, decidePiAiGeneration, decodeRawChatChunk, decodeTraeEvent, decryptTraeStorageValue, deriveCatalog, describeIdShape, describeNameShape, describeTraeFailure, discoveredCatalog, displayNameOfTraeProvider, fallbackModelsFor, generationOf, hashTraeRawChatArg, identityHeaders, inject, isEnterpriseAccount, isPromotableWireModel, legacyTraeOwnAuthPath, maskUserPath, mergeTraeModelSources, name, nextRegionCreditPosition, nextRegionEnabled, nextRegionSlots, normalizeTraeCredential, normalizeTraeToolSchema, normalizeTraeToolSchemas, normalizeTraeVersionCode, panelOfKey, panelOfProvider, parseObservedModelConfig, parseReasoningCapability, parseTraeAuthValue, parseTraeCachedModel, parseTraeModelExtraConfigLogLine, parseTraeRawChatBehaviorConfig, parseTraeRemoteModel, parseTraeStorageDocument, piAiRuntimeInfo, pickTraeStorageIdentity, prepareSoloBody, probeBody, probeModelsSequentially, probeOneModel, probeTraeRawChatCapability, providerOfPanel, rawCapabilityDiagnostic, rawCapabilityFingerprint, readTraeCachedModel, readTraeCliIdentity, readTraeIdentity, refreshTraeCredential, regionCreditPositionOf, regionEnabled, regionEnabledOf, regionOfCredential, regionOfEdition, regionOfHost, regionOfPanel, regionOfTraeProvider, regionOfTraeStatusUrl, regionOfUserRegion, regionStateOf, registerTraeUsageRoute, resolveTraeIdentity, resolveTraeRawRuntime, routeOfTraeProvider, sanitizeCatalog, settingsNamespaceOf, traeEndpoint, traeInputModalities, traeModelDisplayName, traeOwnAuthPath, traeRawChatExtraInfo, traeStateDatabaseCandidates, traeStorageCandidates, traeWebUsage, traeWindowsAppNames, unwrapVolatile, unwrapVolatileDeep, wireTargetsOf, withContextAdaptation, withTraeRegion };
+export { Config, FALLBACK_TRAE_MODELS, FALLBACK_TRAE_MODELS_AI, MAX_PROBE_INPUT_TOKENS, REGION_GATEWAYS, SseDecoder, TRAE_ACCOUNT_STATUS_PATH, TRAE_AI_PROVIDER, TRAE_CHANNEL_PRIORITY, TRAE_CHECKIN_PATH, TRAE_CN_AGENT_TASK_PATH, TRAE_CN_TITLE_PATH, TRAE_COMMON_FUNCTIONS, TRAE_ENTERPRISE_PROVIDER, TRAE_MODELS_TEST_PATH, TRAE_MODEL_DETAIL_FUNCTIONS, TRAE_MODEL_DETAIL_PATH, TRAE_OFFICIAL_ROSTER_PATH, TRAE_PANELS, TRAE_PAY_BASE, TRAE_PROBE_TIMEOUT_MS, TRAE_PROVIDER, TRAE_PROVIDERS, TRAE_PROVIDER_DISPLAY_NAMES, TRAE_PROVIDER_IDS, TRAE_PROVIDER_ID_DISPLAY_NAMES, TRAE_PROVIDER_ROUTES, TRAE_RAW_CHAT_V1_PATH, TRAE_RAW_CHAT_V2_PATH, TRAE_REASONING_EFFORTS, TRAE_REGIONS, TRAE_REGION_PARAM, TRAE_SETTINGS_NS, TRAE_SOLO_CHAT_PATH, TRAE_SOLO_FUNCTION, TRAE_SOLO_MODELS_PATH, TRAE_SOLO_REMOTE_BASE, TRAE_STATE_DB_FILENAME, TRAE_STREAM_IDLE_TIMEOUT_MS, TRAE_USAGE_PATH, TRAE_VERSION_CODE_FALLBACK, TraeCatalog, TraeCredentialStore, TraeDelegatingUpstreamClient, TraeFallbackUpstreamClient, TraeGatedUpstreamClient, TraeOfficialRosterClient, TraeRawCapabilityController, TraeRawCapabilityState, TraeRawChatUpstreamClient, TraeSoloBridge, TraeSoloRemoteCatalogClient, TraeSoloUpstreamClient, TraeUsageClient, UnconfiguredTraeUpstreamClient, adaptLegacyPiAiContext, adaptModernPiAiContext, apply, applyContextBudgets, applyImageSelection, applyOfficialRoster, applyReasoningEffort, asVolatile, bridgeTraeSoloStream, buildTraeAgentTaskBody, buildTraeCnHeaders, buildTraeFusionRawChatEnvelope, buildTraeModelDetailRequest, buildTraeRawChatDraft, buildTraeRawChatRuntimeConfig, classifyProbeError, classifyProbeResult, classifyTraeRawChatFailure, configuredAccountsOf, createTraeAdapter, createTraeRawGateway, createTraeShim, creditPosition, decidePiAiGeneration, decodeRawChatChunk, decodeTraeEvent, decryptTraeStorageValue, deriveCatalog, describeIdShape, describeNameShape, describeTraeFailure, discoveredCatalog, displayNameOfTraeProvider, fallbackModelsFor, filterTraeModels, generationOf, groupTraeModels, hashTraeRawChatArg, identityHeaders, inject, isEnterpriseAccount, isPromotableWireModel, legacyTraeOwnAuthPath, maskUserPath, mergeTraeModelSources, name, nextRegionCreditPosition, nextRegionEnabled, nextRegionSlots, normalizeTraeCredential, normalizeTraeToolSchema, normalizeTraeToolSchemas, normalizeTraeVersionCode, officialVerdictOf, orderTraeModels, panelOfKey, panelOfProvider, parseObservedModelConfig, parseReasoningCapability, parseTraeAuthValue, parseTraeCachedModel, parseTraeModelExtraConfigLogLine, parseTraeOfficialRoster, parseTraeRawChatBehaviorConfig, parseTraeRemoteModel, parseTraeStorageDocument, piAiRuntimeInfo, pickTraeStorageIdentity, prepareSoloBody, probeBody, probeModelsSequentially, probeOneModel, probeTraeRawChatCapability, providerOfPanel, rawCapabilityDiagnostic, rawCapabilityFingerprint, readTraeCachedModel, readTraeCliIdentity, readTraeIdentity, refreshTraeCredential, regionCreditPositionOf, regionEnabled, regionEnabledOf, regionOfCredential, regionOfEdition, regionOfHost, regionOfPanel, regionOfTraeProvider, regionOfTraeStatusUrl, regionOfUserRegion, regionStateOf, registerTraeUsageRoute, resolveTraeIdentity, resolveTraeRawRuntime, routeOfTraeProvider, sanitizeCatalog, scopeTraeModels, settingsNamespaceOf, traeEndpoint, traeInputModalities, traeModelCallChannel, traeModelDisplayName, traeModelInView, traeModelMatchesQuery, traeOwnAuthPath, traeRawChatExtraInfo, traeStateDatabaseCandidates, traeStorageCandidates, traeWebUsage, traeWindowsAppNames, unwrapVolatile, unwrapVolatileDeep, wireTargetsOf, withChatCallableFunctions, withContextAdaptation, withTraeRegion };