@armadra/agent 0.5.1 → 0.6.1

package/dist/cli/subcommands/models-cache-probe.js

@@ -14,6 +14,7 @@ import { priceTokens } from "../../ai/cost.js";
 import { UsageError } from "../args.js";
 import { confirmContinue } from "../choice-prompt.js";
 import { ExitCode } from "../exit-codes.js";
+import { msg } from "../../i18n/index.js";
 export const PROBE_DEFAULT_TOKENS = 2048;
 export const PROBE_DEFAULT_GAP_MS = 3000;
 export const PROBE_REQUEST_TIMEOUT_MS = 60_000;
@@ -56,17 +57,16 @@ export function judgeProbe(first, second) {
     return any === 0 ? "silent" : "inconclusive";
 }
 export function probeAdvice(verdict, model, samples = []) {
+    const t = msg().subcommands.cacheProbe;
     if (verdict === "silent") {
         // 实测：同一中转的 Kimi 间隔 3 s 两次都是 0、间隔更久才命中——字段存在时提示写入延迟的可能
-        const present = samples.some((s) => s.cacheReported === true)
-            ? "（响应里有缓存字段但恒为 0；也可能是缓存写入有延迟，可加大 --gap-ms 再测一次）"
-            : "";
-        return `可在 config 里设 providers.${model.provider}.compat.cacheReporting: "silent"，状态栏将显示未报告${present}`;
+        const present = samples.some((s) => s.cacheReported === true);
+        return t.adviceSilent(model.provider, present);
     }
     if (verdict === "inconclusive")
-        return "第二次只读到少量缓存或只有写入：可能是缓存粒度或 TTL 问题，可加大 --tokens 或缩短 --gap-ms 重试";
+        return t.adviceInconclusive;
     if (model.promptCache === undefined)
-        return `可自填 promptCache.short 以启用保温（providers.${model.provider}.modelOverrides: [{ "id": "${model.id}", "promptCache": { "short": 300 } }]）`;
+        return t.advicePromptCache(model.provider, model.id);
     return undefined;
 }
 function intOption(ctx, name, fallback, min) {
@@ -75,12 +75,13 @@ function intOption(ctx, name, fallback, min) {
         return fallback;
     const value = Number(raw);
     if (!Number.isInteger(value) || value < min)
-        throw new UsageError(`--${name} 应为不小于 ${min} 的整数`);
+        throw new UsageError(msg().subcommands.cacheProbe.intAtLeast(name, min));
     return value;
 }
 function sampleLine(index, s) {
-    const field = s.cacheReported === undefined ? "?" : s.cacheReported ? "有" : "无";
-    return `#${index}  input ${s.input} · cacheRead ${s.cacheRead} · cacheWrite ${s.cacheWrite} · 缓存字段 ${field}`;
+    const t = msg().subcommands.cacheProbe;
+    const field = s.cacheReported === undefined ? "?" : s.cacheReported ? t.yes : t.no;
+    return t.sample(index, s.input, s.cacheRead, s.cacheWrite, field);
 }
 async function run(ctx) {
     const { io, registry } = ctx;
@@ -90,31 +91,33 @@ async function run(ctx) {
     const json = ctx.flags.has("json");
     const found = registry.findModel(ref);
     if (!found.ok) {
-        io.stderr(`ama: 模型不存在：${ref}\n`);
+        io.stderr(msg().subcommands.common.modelNotFound(ref));
         return ExitCode.NoModel;
     }
     const { model, provider } = found;
     const key = await registry.resolveApiKey(provider.id, model.channel);
     if (key.apiKey === undefined && provider.requiresApiKey) {
-        io.stderr(`ama: ${provider.id} 没有 API key（ama auth set ${provider.id}）\n`);
+        io.stderr(msg().subcommands.common.noApiKey(provider.id));
         return ExitCode.NoModel;
     }
     const api = registry.getApi(model.api);
     if (api === undefined) {
-        io.stderr(`ama: 协议 ${model.api} 尚未实现\n`);
+        io.stderr(msg().subcommands.common.apiNotImplemented(model.api));
         return ExitCode.RuntimeError;
     }
     const estimate = priceTokens(model, { input: tokens * 2, output: 32 });
     const name = `${provider.id}/${model.id}`;
-    const head = `cache-probe ${name}（${model.api}）· 前缀约 ${tokens} token · 间隔 ${gapMs} ms\n预估花费：${estimate === undefined ? "$?" : `$${estimate.toFixed(4)}`}（两次 × ${tokens} token × 目录价）\n`;
+    const t = msg().subcommands.cacheProbe;
+    const cost = estimate === undefined ? "$?" : `$${estimate.toFixed(4)}`;
+    const head = t.head(name, model.api, tokens, gapMs, cost);
     (json ? io.stderr : io.stdout)(head);
     if (!ctx.flags.has("yes")) {
         if (!io.stdinIsTTY) {
-            io.stderr("ama: cache-probe 会发两次计费请求，非交互环境需加 --yes\n");
+            io.stderr(t.needsYes);
             return ExitCode.Usage;
         }
         if (!(await confirmContinue({ env: io.env }))) {
-            io.stderr("ama: 已取消\n");
+            io.stderr(msg().subcommands.common.cancelled);
             return ExitCode.Ok;
         }
     }
@@ -136,7 +139,7 @@ async function run(ctx) {
         })
             .result();
         if (message.stopReason === "error" || message.stopReason === "aborted") {
-            io.stderr(`ama: 第 ${i + 1} 次请求失败：${message.errorMessage ?? message.stopReason}\n`);
+            io.stderr(t.requestFailed(i + 1, message.errorMessage ?? message.stopReason));
             return ExitCode.RuntimeError;
         }
         samples.push(sampleOf(message.usage));
@@ -161,14 +164,14 @@ async function run(ctx) {
         return ExitCode.Ok;
     }
     const share = first.promptTokens > 0
-        ? `（第二次读到前缀的 ${Math.round((second.cacheRead / first.promptTokens) * 100)}%）`
+        ? t.share(Math.round((second.cacheRead / first.promptTokens) * 100))
         : "";
     io.stdout([
         sampleLine(1, first),
         sampleLine(2, second),
-        ...(fields.length > 0 ? [`usage 字段（${model.api} 读取）：${fields.join(" / ")}`] : []),
-        `判定：${verdict}${share}`,
-        ...(advice !== undefined ? [`建议：${advice}`] : []),
+        ...(fields.length > 0 ? [t.usageFields(model.api, fields)] : []),
+        t.verdict(verdict, share),
+        ...(advice !== undefined ? [t.advice(advice)] : []),
     ].join("\n") + "\n");
     return ExitCode.Ok;
 }

package/dist/cli/subcommands/models-discover.d.ts

@@ -16,6 +16,10 @@
  *
  * models.dev：列表之后按需刷新缓存（24 小时内不重拉），每个模型标出上下文、输出、图片、工具调用与
  * 匹配结果；`--write` 跳过 models.dev 标明不支持工具调用的模型。元数据不写进配置——运行时从缓存补。
+ *
+ * [W6-O] `chatgpt`：按登录的 flavor 调对应后端的模型列表（SIWC `GET /v1/models` 筛 `visibility: list`；codex
+ * `GET /models?client_version=…`），只取 slug 与显示名；`--probe` 不适用（订阅后端只有一种协议）。结果另写进
+ * 发现缓存 `<dataDir>/models/discovered/chatgpt.json`（discovered-cache.ts），`/model` 选择器由此列出。
  */
 import type { Api, Model, ProviderData, ProviderRegistryApi } from "../../ai/types.js";
 import type { ModelsAction } from "./models.js";

package/dist/cli/subcommands/models-discover.js

@@ -16,9 +16,17 @@
  *
  * models.dev：列表之后按需刷新缓存（24 小时内不重拉），每个模型标出上下文、输出、图片、工具调用与
  * 匹配结果；`--write` 跳过 models.dev 标明不支持工具调用的模型。元数据不写进配置——运行时从缓存补。
+ *
+ * [W6-O] `chatgpt`：按登录的 flavor 调对应后端的模型列表（SIWC `GET /v1/models` 筛 `visibility: list`；codex
+ * `GET /models?client_version=…`），只取 slug 与显示名；`--probe` 不适用（订阅后端只有一种协议）。结果另写进
+ * 发现缓存 `<dataDir>/models/discovered/chatgpt.json`（discovered-cache.ts），`/model` 选择器由此列出。
  */
 import { authHeaders, mergeHeaders } from "../../ai/http.js";
+import { listChatGptModels } from "../../auth/chatgpt/backend-client.js";
+import { CHATGPT_PROVIDER_ID } from "../../auth/chatgpt/presets.js";
+import { liveToken } from "../../auth/oauth/live.js";
 import { discoverLocalModels, materializeModel } from "../../ai/providers/registry.js";
+import { writeDiscoveredCache } from "../../ai/providers/discovered-cache.js";
 import { withCustomDefaults } from "../../ai/providers/catalog.js";
 import { describeModelsDev, loadModelsDevIndex } from "../../ai/providers/models-dev-cache.js";
 import { matchLabel, modelsDevFields } from "../../ai/providers/models-dev.js";
@@ -26,6 +34,7 @@ import { existsSync } from "node:fs";
 import { loadConfigFile } from "../../config/load.js";
 import { writeConfigFile } from "../../config/write.js";
 import { UsageError } from "../args.js";
+import { msg } from "../../i18n/index.js";
 import { ExitCode } from "../exit-codes.js";
 import { compactTokens } from "./model-meta.js";
 import { describeProbePlan, parseProbeTuning, ProbeProgress, ProbeScheduler, } from "./probe-runner.js";
@@ -47,6 +56,23 @@ export function modelsUrl(provider) {
 }
 export async function discoverModels(provider, apiKey, options = {}) {
     const timeoutMs = options.timeoutMs ?? DISCOVER_TIMEOUT_MS;
+    if (provider.id === CHATGPT_PROVIDER_ID && apiKey !== undefined) {
+        const live = liveToken(apiKey);
+        const flavor = live?.flavor ?? (provider.defaultChannel === "codex" ? "codex" : "siwc");
+        const channel = provider.channels?.find((c) => c.name === flavor);
+        const models = await listChatGptModels(fetch, channel?.baseUrl ?? provider.baseUrl, {
+            flavor,
+            accessToken: apiKey,
+            accountId: live?.accountId,
+            originator: channel?.headers?.["originator"],
+        });
+        return models.map((m) => {
+            const model = withCustomDefaults({ id: m.id }, provider.id, provider.api);
+            if (m.name !== undefined)
+                model.name = m.name;
+            return model;
+        });
+    }
     if (!provider.requiresApiKey && apiKey === undefined)
         return discoverLocalModels(provider, { timeoutMs });
     const anthropic = provider.api === "anthropic-messages";
@@ -114,17 +140,18 @@ function parseLimit(raw) {
         return DEFAULT_PROBE_LIMIT;
     const n = Number(raw);
     if (!Number.isInteger(n) || n < 1)
-        throw new UsageError(`--limit 需要正整数：${raw}`);
+        throw new UsageError(msg().subcommands.discover.limitPositive(raw));
     return n;
 }
 /** 把新条目合并进用户级 config.json；返回写入条数。 */
 function writeEntries(ctx, provider, entries, notes) {
     const { io } = ctx;
+    const m = msg().subcommands.discover;
     const path = ctx.level.userConfigPath;
     const config = structuredClone(loadConfigFile("config", path)?.value ?? { version: 1 });
     const providers = (config.providers ??= {});
     if (providers[provider.id] === undefined && !provider.builtin) {
-        io.stderr(`ama: ${provider.id} 不在用户级配置（${path}）里，未写入\n`);
+        io.stderr(m.notInUserConfig(provider.id, path));
         return 0;
     }
     const target = (providers[provider.id] ??= {});
@@ -133,34 +160,33 @@ function writeEntries(ctx, provider, entries, notes) {
     const added = entries.filter((entry) => !existing.has(entry.id));
     const kept = entries.length - added.length;
     if (added.length === 0) {
-        io.stdout(`\n没有新模型要写入${kept > 0 ? `（${kept} 个已存在，未覆盖）` : ""}\n`);
+        io.stdout(m.nothingToWrite(kept));
         return 0;
     }
     models.push(...added);
     const backup = existsSync(path);
     writeConfigFile(path, config, { backup: true });
-    io.stdout(`\n已写入 ${path}：${provider.id} 新增 ${added.length} 个模型` +
-        `${kept > 0 ? `，${kept} 个已存在未覆盖` : ""}${backup ? `（原文件备份为 ${path}.bak）` : ""}\n`);
+    io.stdout(m.written(path, provider.id, added.length, kept, backup));
     if (notes.noTools.size > 0)
-        io.stdout(`跳过不支持工具调用的模型（models.dev）：${[...notes.noTools].join(", ")}\n`);
+        io.stdout(m.skippedNoTools([...notes.noTools].join(", ")));
     const blind = added.filter((entry) => notes.unmatched.has(entry.id)).map((entry) => entry.id);
     if (blind.length > 0)
-        io.stderr(`ama: 警告：${blind.join(", ")} 在 models.dev 未匹配，没有 contextWindow，自动压缩关闭；` +
-            `需要时在 config.json 里补上或写 modelsDev\n`);
+        io.stderr(m.unmatchedWarning(blind.join(", ")));
     return added.length;
 }
 async function run(ctx) {
     const { io, registry } = ctx;
+    const m = msg().subcommands.discover;
     const id = ctx.args[0] ?? "";
     const limit = parseLimit(ctx.values.get("limit"));
     const provider = registry.get(id);
     if (provider === undefined) {
-        io.stderr(`ama: 供应商不存在：${id}\n`);
+        io.stderr(msg().subcommands.common.providerNotFound(id));
         return ExitCode.NoModel;
     }
     const key = await registry.resolveApiKey(provider.id);
     if (key.apiKey === undefined && provider.requiresApiKey) {
-        io.stderr(`ama: ${provider.id} 没有 API key（ama auth set ${provider.id}）\n`);
+        io.stderr(msg().subcommands.common.noApiKey(provider.id));
         return ExitCode.NoModel;
     }
     let found;
@@ -168,11 +194,13 @@ async function run(ctx) {
         found = await discoverModels(provider, key.apiKey);
     }
     catch (error) {
-        io.stderr(`ama: ${provider.id} 模型列表获取失败：${error.message}\n`);
+        io.stderr(m.listFailed(provider.id, error.message));
         return ExitCode.RuntimeError;
     }
     const configured = new Map(provider.models.map((m) => [m.id, m]));
-    io.stdout(`${provider.id}：发现 ${found.length} 个模型（${modelsUrl(provider)}）\n`);
+    io.stdout(m.found(provider.id, found.length, modelsUrl(provider)));
+    if (provider.id === CHATGPT_PROVIDER_ID)
+        cacheChatGpt(ctx, found, key.apiKey);
     // models.dev 只读本地（快照 ⊕ `ama models refresh` 的覆盖），不联网。
     const mdIndex = loadModelsDevIndex(ctx.level.dataDir);
     io.stdout(`${describeModelsDev(ctx.level.dataDir)}\n`);
@@ -187,14 +215,14 @@ async function run(ctx) {
         if (match === undefined)
             unmatched.add(model.id);
         const meta = fields === undefined
-            ? "  models.dev 未匹配"
+            ? m.unmatched
             : `  ctx ${compactTokens(fields.contextWindow)} · out ${compactTokens(fields.maxTokens)}` +
-                `${fields.input?.includes("image") ? " · 图片" : ""}${fields.reasoning ? " · 思考" : ""}` +
-                `${fields.toolCall === false ? " · 不支持工具调用" : ""} · ${matchLabel(match)}`;
-        io.stdout(`  ${model.id}${known !== undefined ? `  已配置（${known.api}）` : ""}${meta}\n`);
+                `${fields.input?.includes("image") ? m.image : ""}${fields.reasoning ? m.reasoning : ""}` +
+                `${fields.toolCall === false ? m.noTools : ""} · ${matchLabel(match)}`;
+        io.stdout(`  ${model.id}${known !== undefined ? m.configured(known.api) : ""}${meta}\n`);
     }
     const write = ctx.flags.has("write");
-    if (!ctx.flags.has("probe")) {
+    if (!ctx.flags.has("probe") || provider.id === CHATGPT_PROVIDER_ID) {
         if (write)
             writeEntries(ctx, provider, found.filter((m) => !noTools.has(m.id)).map((m) => ({ id: m.id })), { noTools, unmatched });
         return ExitCode.Ok;
@@ -203,15 +231,14 @@ async function run(ctx) {
     const count = Math.min(limit, ids.length);
     const order = probeOrder(provider);
     const tuning = parseProbeTuning(ctx.values);
-    io.stdout(`\n探测协议：${count} 个模型（${order.join(" → ")}），最多 ${count * order.length} 次请求` +
-        `${ids.length > count ? `；另有 ${ids.length - count} 个超出 --limit ${limit}，未探测` : ""}\n` +
+    io.stdout(m.probeHeader(count, order.join(" → "), count * order.length, ids.length - count, limit) +
         `${describeProbePlan(count * order.length, tuning.concurrency, tuning.timeoutMs)}\n`);
     let stopped;
     const progress = new ProbeProgress(io.stdout, io.stdoutIsTTY, count);
     const probed = await probeModelApis(registry, provider, ids, limit, {
         ...tuning,
         onSettled: () => progress.tick(),
-        onResult: (modelId, api) => progress.line(`  ${modelId}  ${api ?? "不可用（三种协议均失败）"}\n`),
+        onResult: (modelId, api) => progress.line(`  ${modelId}  ${api ?? m.unavailable}\n`),
         onStop: (reason) => (stopped = reason),
     });
     progress.finish();
@@ -224,11 +251,23 @@ async function run(ctx) {
         writeEntries(ctx, provider, entries, { noTools, unmatched });
     }
     if (stopped !== undefined) {
-        io.stderr(`ama: 探测提前停止（${stopped}）\n`);
+        io.stderr(m.probeStopped(stopped));
         return ExitCode.RuntimeError;
     }
     return ExitCode.Ok;
 }
+/** chatgpt 的发现结果写进发现缓存（选择器与注册表读它）；写失败不影响列表输出。 */
+function cacheChatGpt(ctx, found, apiKey) {
+    try {
+        const flavor = liveToken(apiKey)?.flavor;
+        const models = found.map((m) => ({ id: m.id, ...(m.name !== m.id ? { name: m.name } : {}) }));
+        const path = writeDiscoveredCache(ctx.level.dataDir, CHATGPT_PROVIDER_ID, { models, flavor });
+        ctx.io.stdout(msg().subcommands.discover.cached(path));
+    }
+    catch (error) {
+        ctx.io.stderr(`ama: ${error.message}\n`);
+    }
+}
 export const DISCOVER_ACTION = {
     usage: "ama models discover <provider> [--probe] [--write] [--limit <n>] [--concurrency <n>] [--probe-timeout <ms>]",
     required: "<provider>",

package/dist/cli/subcommands/models-enable.d.ts

@@ -0,0 +1,13 @@
+/**
+ * `ama models enable <ref…>` / `ama models disable <ref…>` / `ama models list --enabled`：编辑与查看用户级
+ * `models.enabled`（模型选择器的显式清单，见 ai/providers/model-visibility.ts）。
+ *
+ * 写回走 config/edit.ts（重读目标文件、校验、`.bak` 备份、原子写）；`models` 只认用户级，没有 `--project`。
+ * 引用要是 `provider/model[@channel]` 或 `provider/*`，供应商必须存在；模型不在模型表里只警告（中转站与
+ * 订阅后端接受任意 id）。清单移空时删掉这个键。
+ */
+import type { ModelsAction, ModelsActionContext } from "./models.js";
+/** `ama models list --enabled`：清单（及各项供应商状态）；没设清单时列出选择器缺省显示的模型。 */
+export declare function listEnabled(ctx: ModelsActionContext): Promise<number>;
+export declare const ENABLE_ACTION: ModelsAction;
+export declare const DISABLE_ACTION: ModelsAction;

package/dist/cli/subcommands/models-enable.js

@@ -0,0 +1,145 @@
+/**
+ * `ama models enable <ref…>` / `ama models disable <ref…>` / `ama models list --enabled`：编辑与查看用户级
+ * `models.enabled`（模型选择器的显式清单，见 ai/providers/model-visibility.ts）。
+ *
+ * 写回走 config/edit.ts（重读目标文件、校验、`.bak` 备份、原子写）；`models` 只认用户级，没有 `--project`。
+ * 引用要是 `provider/model[@channel]` 或 `provider/*`，供应商必须存在；模型不在模型表里只警告（中转站与
+ * 订阅后端接受任意 id）。清单移空时删掉这个键。
+ */
+import { accessReady, addEnabled, enabledList, providerAccess, removeEnabled, splitEnabledRef, } from "../../ai/providers/model-visibility.js";
+import { readSnapshot, setConfigValue } from "../../config/edit.js";
+import { MODELS_ENABLED_REF } from "../../config/types-w5.js";
+import { msg } from "../../i18n/index.js";
+import { UsageError } from "../args.js";
+import { ExitCode } from "../exit-codes.js";
+function layerInput(ctx) {
+    const input = {
+        configDir: ctx.level.configDir,
+        cwd: ctx.io.cwd,
+        env: ctx.io.env,
+    };
+    if (ctx.level.profile !== undefined) {
+        input.profile = { config: ctx.level.profile.config };
+        input.hasProfile = true;
+    }
+    return input;
+}
+/** 校验引用；供应商不存在返回退出码，模型不在表里只警告。 */
+function checkRefs(ctx, refs) {
+    const m = msg().subcommands.modelsEnabled;
+    for (const ref of refs) {
+        const parts = splitEnabledRef(ref);
+        if (!MODELS_ENABLED_REF.test(ref) || parts === undefined)
+            throw new UsageError(m.badRef(ref));
+        const provider = ctx.registry.get(parts.provider);
+        if (provider === undefined) {
+            ctx.io.stderr(msg().subcommands.common.providerNotFound(parts.provider));
+            return ExitCode.NoModel;
+        }
+        if (parts.model !== "*" &&
+            provider.models.length > 0 &&
+            !provider.models.some((model) => model.id === parts.model))
+            ctx.io.stderr(m.unknownModel(ref));
+    }
+    return undefined;
+}
+function userList(input) {
+    return enabledList(readSnapshot(input).user?.models?.enabled);
+}
+async function enable(ctx) {
+    const m = msg().subcommands.modelsEnabled;
+    const refs = [...new Set(ctx.args)];
+    const bad = checkRefs(ctx, refs);
+    if (bad !== undefined)
+        return bad;
+    const input = layerInput(ctx);
+    const current = userList(input);
+    const fresh = refs.filter((ref) => !(current ?? []).includes(ref));
+    if (fresh.length === 0) {
+        ctx.io.stdout(m.alreadyListed(refs.join(", ")));
+        return ExitCode.Ok;
+    }
+    const result = setConfigValue({
+        ...input,
+        scope: "user",
+        key: "models.enabled",
+        value: addEnabled(current, fresh),
+    });
+    ctx.io.stdout(m.added(fresh.join(", "), result.path));
+    return ExitCode.Ok;
+}
+async function disable(ctx) {
+    const m = msg().subcommands.modelsEnabled;
+    const refs = [...new Set(ctx.args)];
+    for (const ref of refs)
+        if (!MODELS_ENABLED_REF.test(ref))
+            throw new UsageError(m.badRef(ref));
+    const input = layerInput(ctx);
+    const current = userList(input) ?? [];
+    const listed = refs.filter((ref) => current.includes(ref));
+    const missing = refs.filter((ref) => !current.includes(ref));
+    if (missing.length > 0)
+        ctx.io.stderr(m.notListed(missing.join(", ")));
+    if (listed.length === 0)
+        return missing.length > 0 ? ExitCode.RuntimeError : ExitCode.Ok;
+    const next = removeEnabled(current, listed);
+    const result = setConfigValue({ ...input, scope: "user", key: "models.enabled", value: next });
+    ctx.io.stdout(next === undefined ? m.cleared(result.path) : m.removed(listed.join(", "), result.path));
+    return ExitCode.Ok;
+}
+/** `ama models list --enabled`：清单（及各项供应商状态）；没设清单时列出选择器缺省显示的模型。 */
+export async function listEnabled(ctx) {
+    const m = msg().subcommands.modelsEnabled;
+    const labels = msg().panels.model;
+    const list = enabledList(ctx.level.merged.config.models?.enabled);
+    const status = async (providerId) => {
+        const provider = ctx.registry.get(providerId);
+        if (provider === undefined)
+            return "?";
+        const access = await providerAccess(ctx.registry, provider);
+        return access === "none" ? labels.noKey : labels[access];
+    };
+    if (list !== undefined) {
+        ctx.io.stdout(m.listHeader(ctx.level.userConfigPath));
+        for (const ref of list) {
+            const parts = splitEnabledRef(ref);
+            const provider = parts === undefined ? undefined : ctx.registry.get(parts.provider);
+            const known = parts === undefined ||
+                parts.model === "*" ||
+                provider === undefined ||
+                provider.models.length === 0 ||
+                provider.models.some((model) => model.id === parts.model);
+            const notes = [
+                parts === undefined ? "?" : await status(parts.provider),
+                ...(known ? [] : [m.notInTable]),
+            ];
+            ctx.io.stdout(`  ${ref}  ${notes.join(" · ")}\n`);
+        }
+        return ExitCode.Ok;
+    }
+    ctx.io.stdout(m.listUnset);
+    let shown = 0;
+    for (const provider of ctx.registry.list()) {
+        const access = await providerAccess(ctx.registry, provider);
+        if (!accessReady(access))
+            continue;
+        const label = access === "none" ? labels.noKey : labels[access];
+        for (const model of provider.models) {
+            ctx.io.stdout(`  ${provider.id}/${model.id}  ${label}\n`);
+            shown++;
+        }
+    }
+    if (shown === 0)
+        ctx.io.stdout(m.nothing);
+    return ExitCode.Ok;
+}
+export const ENABLE_ACTION = {
+    usage: "ama models enable <provider/model[@channel]|provider/*>…",
+    required: "<provider/model>",
+    run: enable,
+};
+export const DISABLE_ACTION = {
+    usage: "ama models disable <provider/model[@channel]|provider/*>…",
+    required: "<provider/model>",
+    run: disable,
+};

package/dist/cli/subcommands/models.d.ts

@@ -9,6 +9,8 @@
  * 选项表与必填位置参数都从表里来。
  *
  * [W5-M1] `refresh`：models.dev 显式刷新（`refresh-catalog` 保留为别名）。
+ *
+ * `enable` / `disable` / `list --enabled`：模型选择器清单 `models.enabled`（models-enable.ts）。
  */
 import type { ProviderRegistryApi } from "../../ai/types.js";
 import type { CliIo, RuntimeDeps } from "../deps.js";
@@ -38,5 +40,5 @@ export interface ModelsAction {
 export declare const CHECK_TIMEOUT_MS = 30000;
 /** 动作表：键是子命令名，顺序即用法文本顺序。 */
 export declare const MODELS_ACTIONS: Readonly<Record<string, ModelsAction>>;
-export declare const MODELS_USAGE: string;
+export declare function modelsUsage(): string;
 export declare function runModels(argv: readonly string[], io: CliIo, deps: Pick<RuntimeDeps, "providers"> | undefined): Promise<number>;