dsh-agy-acp 0.1.1 → 0.1.3

package/README.md

@@ -26,6 +26,7 @@
 | 本地精准单步 Token 账单 | 只读打开本机 `agy` SQLite 会话库——**无 WAL 侧车时**用 `?immutable=1`（不生成 `-wal`/`-shm`）；**活跃 WAL 存在时**退回普通只读，避免读到未 checkpoint 的半截快照，并与 ACP `usage_update` 做容差对账 |
 | 传递图片附件或本地截图 | 支持传入授权本地路径、`data:image/*;base64,...` 或宿主附件引用；远端**明确声明** `promptCapabilities.image=false` 时降级为纯文本并告警，未声明（`unknown`）则先按支持尝试发送 |
 | 按需查看剩余额度 | 监控面板点击「刷新额度」才按需运行只读命令 `agy -p /usage --output-format json`（可选 `/credits`），打开面板不自动起进程 |
+| 可视化管控模型权限 | 设置页「模型权限控制」逐模型切换 **允许 / 仅 Plan / 禁用**，直接写入 `blockedModels` / `planOnlyModels`；被禁用的模型仍留在列表里可随时改回，还能手输自定义 ID 封堵上游新模型。`agy_acp({ action: "models" })` 同步输出 `[blocked]` / `[plan-only]` 标注 |
 
 ## 快速开始
 
@@ -74,6 +75,7 @@ AgyWorkerService (src/worker-service.js)
 | **后台 `wait:false` 拒绝非白名单操作** | 父会话处于轮次间 idle 时，不在 `bridgeAllowlist` 内的权限请求一律 `fail-closed` 拒绝；仅 `wait:true` 前台模式弹窗询问宿主审批。 |
 | **Windows Low Integrity 保护** | 若 `agy` 落在 `AppData\\LocalLow` 或 ACL 含 `Low Mandatory Level`（`S-1-16-4096`），插件会直接拒绝启动并报错（`AGY_LOW_INTEGRITY_EXECUTABLE`），防止子进程挂死。 |
 | **额度与账单可信度** | 本地 SQLite 账单与 `/usage`/`/credits` 均零联网修改且严禁把 `unknown` 伪装成 `0`，仅作本地监控参考，不作为正式计费依据。 |
+| **模型权限是本地策略** | `blockedModels` / `planOnlyModels` 在工具层与 `runDirectTurn` 双路径按归一化模型名（大小写不敏感）拦截，但无法阻止其他客户端直连 `agy`。零思考档位的 `Orchestrator (Carbon)` 与 `gemini-pro-orchestrator-argon` 拒绝任何思考档位。 |
 
 ## 常见排障
 

package/client.js

@@ -45,6 +45,9 @@
     requestTimeoutMs: 600000,
     maxReportChars: 32000,
     quotaIncludeCredits: false,
+    // 模型权限黑白名单：恢复默认时一并清空（空数组 = 不限制任何模型）。
+    blockedModels: Object.freeze([]),
+    planOnlyModels: Object.freeze([]),
   });
   const MODEL_PRESETS = Object.freeze([
     'gemini-4-carbon',
@@ -53,6 +56,27 @@
     'gemini-pro-orchestrator',
     'claude-opus-5-5',
   ]);
+  /**
+   * 模型权限卡片的内置静态目录（与 Host DEFAULT_MODELS 对齐，并补上 Argon Orchestrator）。
+   * 即使连接未就绪、拿不到 snapshot.models，这里也足以渲染三态按钮。
+   */
+  const DEFAULT_MODEL_OPTIONS = Object.freeze([
+    'gemini-4-carbon',
+    'gemini-4-hydrogen',
+    'gemini-pro-orchestrator',
+    'claude-opus-5-5',
+    'gemini-4-argon',
+    'gemini-pro-orchestrator-argon',
+    'claude-sonnet-5-5',
+    'gpt-oss-120b-medium',
+  ]);
+  /** 三态权限取值与对应文案 key（顺序即按钮顺序）。 */
+  const MODEL_ACCESS_VALUES = Object.freeze(['allow', 'plan-only', 'blocked']);
+  const MODEL_ACCESS_LABEL_KEYS = Object.freeze({
+    allow: 'accessAllow',
+    'plan-only': 'accessPlanOnly',
+    blocked: 'accessBlocked',
+  });
   const EFFORT_PRESETS = Object.freeze(['low', 'medium', 'high', 'xhigh']);
   const CONCURRENCY_PRESETS = Object.freeze([1, 2, 3, 4]);
   const HANDSHAKE_TIMEOUT_PRESETS = Object.freeze([30000, 60000, 120000, 300000]);
@@ -77,6 +101,22 @@
     return value !== null && typeof value === 'object' && !Array.isArray(value);
   }
 
+  /**
+   * 解包真实宿主 @deepseek-ai/dsh-api-gateway 的一元 Remote 结果信封。
+   *
+   * 网关客户端 invoke() 的成功返回是 { ok: true, value: <payload> }（失败是
+   * { ok: false, error }），并不是裸 payload；离线的远程替身与旧宿主则直接返回
+   * payload。这里只剥一层、且只剥「成功信封」：
+   *   - ok:false 的失败信封原样返回，交给调用方既有的错误分支处理；
+   *   - 裸 payload 原样返回，绝不误剥业务字段里自带的 ok/value 组合。
+   */
+  function unwrapRemoteResult(response) {
+    if (isPlainObject(response) && response.ok === true && 'value' in response && response.value !== undefined) {
+      return response.value;
+    }
+    return response;
+  }
+
   function resolveService(ctx, name) {
     if (!ctx || typeof ctx !== 'object') return null;
     try {
@@ -354,6 +394,100 @@
     };
   }
 
+  /** 模型目录项：`{ value, name }`，空 value 丢弃（与 Host src/protocol.js 1:1 同步）。 */
+  function normalizeModelOption(raw) {
+    const value = toStr(raw && raw.value, '');
+    if (!value) return null;
+    const name = toStr(raw && raw.name, '');
+    return { value, name: name || value };
+  }
+
+  function normalizeModelCatalog(raw) {
+    if (!Array.isArray(raw)) return [];
+    const out = [];
+    for (const item of raw) {
+      const option = normalizeModelOption(item);
+      if (option) out.push(option);
+    }
+    return out;
+  }
+
+  /* ---------------- 模型权限（允许 / 仅 Plan / 禁用）辅助 ---------------- */
+
+  /** 归一化字符串列表：去空、去重（保留原始大小写与首次出现顺序）。 */
+  function normalizeStringList(value) {
+    if (!Array.isArray(value)) return [];
+    const out = [];
+    const seen = new Set();
+    for (const item of value) {
+      if (typeof item !== 'string') continue;
+      const text = item.trim();
+      if (!text) continue;
+      const key = text.toLowerCase();
+      if (seen.has(key)) continue;
+      seen.add(key);
+      out.push(text);
+    }
+    return out;
+  }
+
+  /**
+   * 合并模型目录：接受 string[] 或 { value, name }[] 两种来源形态，
+   * 按大小写不敏感去重并保留首次出现顺序。
+   */
+  function mergeModelCatalog(...sources) {
+    const seen = new Set();
+    const out = [];
+    const push = (value, name) => {
+      const text = typeof value === 'string' ? value.trim() : '';
+      if (!text) return;
+      const key = text.toLowerCase();
+      if (seen.has(key)) return;
+      seen.add(key);
+      out.push({ value: text, name: typeof name === 'string' && name ? name : text });
+    };
+    for (const source of sources) {
+      if (!Array.isArray(source)) continue;
+      for (const item of source) {
+        if (typeof item === 'string') push(item, item);
+        else if (item) push(item.value, item.name);
+      }
+    }
+    return out;
+  }
+
+  /** 某模型当前的三态权限：allow | plan-only | blocked（大小写不敏感）。 */
+  function modelAccessOf(value, blockedModels, planOnlyModels) {
+    const key = typeof value === 'string' ? value.trim().toLowerCase() : '';
+    if (!key) return 'allow';
+    const matches = (list) =>
+      normalizeStringList(list).some((item) => item.toLowerCase() === key);
+    if (matches(blockedModels)) return 'blocked';
+    return matches(planOnlyModels) ? 'plan-only' : 'allow';
+  }
+
+  /**
+   * 计算点三态按钮后的新黑白名单（纯函数，便于单测）：
+   *   - allow：从两个数组里都移除；
+   *   - plan-only：加入 planOnlyModels、从 blockedModels 移除；
+   *   - blocked：加入 blockedModels、从 planOnlyModels 移除。
+   */
+  function nextModelPolicy(blockedModels, planOnlyModels, value, access) {
+    const target = typeof value === 'string' ? value.trim() : '';
+    if (!target) {
+      return { blockedModels: normalizeStringList(blockedModels), planOnlyModels: normalizeStringList(planOnlyModels) };
+    }
+    const key = target.toLowerCase();
+    const blockedNow = normalizeStringList(blockedModels);
+    const planOnlyNow = normalizeStringList(planOnlyModels);
+    const withoutKey = (list) => list.filter((item) => item.toLowerCase() !== key);
+    const withKey = (list) => (list.some((item) => item.toLowerCase() === key) ? list : [...list, target]);
+    return {
+      blockedModels: access === 'blocked' ? withKey(blockedNow) : withoutKey(blockedNow),
+      planOnlyModels: access === 'plan-only' ? withKey(planOnlyNow) : withoutKey(planOnlyNow),
+    };
+  }
+
   function normalizeSnapshot(raw) {
     const semaphore = isPlainObject(raw && raw.semaphore) ? raw.semaphore : {};
     const totals = isPlainObject(raw && raw.totals) ? raw.totals : {};
@@ -383,6 +517,7 @@
       activeRuns: Array.isArray(raw && raw.activeRuns) ? raw.activeRuns.map(normalizeRun) : [],
       recentRuns: Array.isArray(raw && raw.recentRuns) ? raw.recentRuns.map(normalizeRun) : [],
       workers: Array.isArray(raw && raw.workers) ? raw.workers.map(normalizeWorker) : [],
+      models: normalizeModelCatalog(raw && raw.models),
       quota: raw && raw.quota ? normalizeQuota(raw.quota) : null,
     };
   }
@@ -684,6 +819,15 @@
       reportLabel: '报告字符上限',
       reportHint: '后台 Job 报告中回复正文的最大字符数，超出会截断。',
       resetDefaults: '恢复默认设置',
+      modelAccessTitle: '模型权限控制（允许 / 仅 Plan / 禁用）',
+      modelAccessHint: '逐个模型设置权限：允许 = 照常使用；仅 Plan = 只有 mode:"plan" 下可用；禁用 = 任何调用都会被拒绝。被标记的模型仍会留在这张列表里，随时可以改回来。',
+      modelAccessLabel: '权限',
+      accessAllow: '允许',
+      accessPlanOnly: '仅 Plan',
+      accessBlocked: '禁用',
+      customModelLabel: '手动添加模型 ID',
+      customModelPlaceholder: '例如 gemini-4-argon',
+      customModelHint: '上游新出的模型 ID 可直接在这里封堵：输入后点「仅 Plan」或「禁用」，会写入 planOnlyModels / blockedModels（大小写不敏感）。',
       guideTitle: '监控与使用说明',
       guideMonitor: '右侧栏会新增「ACP 进程监控」页签：活跃/排队轮次、最近 30 轮单步 SQLite Token 账单与 ACP usage_update 对账条都在那里。也可以点击会话顶栏的 ACP 徽章直接打开。',
       guideBilling: '账单数据全部来自本机 agy 的 SQLite 会话库（只读、immutable 打开，不会生成 -wal/-shm 侧车文件），不需要联网，也不会额外消耗额度。',
@@ -727,6 +871,15 @@
       reportLabel: 'Report character cap',
       reportHint: 'Maximum reply characters kept in the background job report.',
       resetDefaults: 'Reset Defaults',
+      modelAccessTitle: 'Model access control (allow / plan-only / blocked)',
+      modelAccessHint: 'Set access per model: Allow = normal use; Plan only = usable only with mode:"plan"; Blocked = every call is rejected. Tagged models stay in this list so you can always switch them back.',
+      modelAccessLabel: 'Access',
+      accessAllow: 'Allow',
+      accessPlanOnly: 'Plan only',
+      accessBlocked: 'Blocked',
+      customModelLabel: 'Add a model ID manually',
+      customModelPlaceholder: 'e.g. gemini-4-argon',
+      customModelHint: 'Block upstream model IDs as soon as they appear: type one and press "Plan only" or "Blocked" to write planOnlyModels / blockedModels (case-insensitive).',
       guideTitle: 'Monitor and usage notes',
       guideMonitor: 'A new "ACP process monitor" tab appears in the right sidebar: active/queued runs, the last 30 turn ledgers and the SQLite-vs-ACP reconciliation bar. The header ACP badge opens it too.',
       guideBilling: 'Ledger data comes from the local agy SQLite conversation database, opened read-only with immutable=1 so no -wal/-shm sidecar files are created. Nothing leaves the machine.',
@@ -823,7 +976,7 @@
         if (!api || typeof api.getAcpSnapshot !== 'function') {
           throw new Error('Host 端 dsh-agy-acp.getAcpSnapshot 服务未就绪');
         }
-        const response = await api.getAcpSnapshot({ sessionId: focusSessionId || GLOBAL });
+        const response = unwrapRemoteResult(await api.getAcpSnapshot({ sessionId: focusSessionId || GLOBAL }));
         if (isPlainObject(response) && response.ok === false) {
           throw new Error(formatErrorMessage(response.error || response));
         }
@@ -837,7 +990,7 @@
           if (!api || typeof api.stopAcpRun !== 'function') {
             return { ok: false, stopped: false, runId, phase: '', reason: 'host-unavailable' };
           }
-          const response = await api.stopAcpRun({ runId });
+          const response = unwrapRemoteResult(await api.stopAcpRun({ runId }));
           if (isPlainObject(response) && response.ok === false && response.error) {
             throw new Error(formatErrorMessage(response.error));
           }
@@ -871,7 +1024,9 @@
         if (!remoteApi || typeof remoteApi.getAcpQuota !== 'function') {
           throw new Error('Host 端 dsh-agy-acp.getAcpQuota 服务未就绪');
         }
-        const response = await remoteApi.getAcpQuota(isPlainObject(options) ? options : { force: true });
+        const response = unwrapRemoteResult(
+          await remoteApi.getAcpQuota(isPlainObject(options) ? options : { force: true })
+        );
         if (isPlainObject(response) && response.ok === false && response.error) {
           throw new Error(formatErrorMessage(response.error));
         }
@@ -1050,7 +1205,10 @@
             order: PATCH_ORDER,
             label: () => (locale && typeof locale.bind === 'function' ? locale.bind(SETTINGS_NS)('title') : 'Antigravity ACP'),
             locale: SETTINGS_NS,
-            inject: () => ({ form }),
+            // api 是上面构造好的客户端封装（fetchSnapshot 已解包宿主网关信封），
+            // 传入后设置页能真正拉到宿主实测 snapshot.models；拿不到时组件自动降级到
+            // 内置静态目录，绝不阻塞渲染、也绝不让离线单测崩掉。
+            inject: () => ({ form, api }),
           }, AcpSettingsView))
         ));
         return () => {
@@ -1168,6 +1326,14 @@
     ACP_REMOTE,
     SETTINGS_DICTIONARIES,
     DEFAULT_SETTINGS,
+    DEFAULT_MODEL_OPTIONS,
+    MODEL_ACCESS_VALUES,
+    unwrapRemoteResult,
+    normalizeModelCatalog,
+    normalizeStringList,
+    mergeModelCatalog,
+    modelAccessOf,
+    nextModelPolicy,
     initRuntime,
     buildAcpAddress,
     parseAcpAddress,
@@ -1240,6 +1406,13 @@
     const [pending, setPending] = React.useState(false);
     const [notice, setNotice] = React.useState('');
     const [drafts, setDrafts] = React.useState({});
+    // 模型权限卡片的数据源：props.models（宿主/测试注入）+ 连接就绪后异步拉一次快照。
+    const [catalogModels, setCatalogModels] = React.useState(() =>
+      props && Array.isArray(props.models) ? props.models : []
+    );
+    const [customModelDraft, setCustomModelDraft] = React.useState('');
+    // 输入框最新值同时落在 ref：点击「添加」时即便宿主还没重渲染也能读到用户刚敲的 ID。
+    const customModelRef = React.useRef('');
     const writing = React.useRef(false);
     const alive = React.useRef(true);
     const draftRef = React.useRef({});
@@ -1251,6 +1424,35 @@
       };
     }, []);
 
+    // 连接就绪后再补一次真实模型目录；任何异常（远程未挂载 / 未注入 api）都静默
+    // 降级到内置静态目录，绝不阻塞渲染、也绝不让离线单测崩掉。
+    // 两种注入形态都支持：本插件客户端封装 api.fetchSnapshot（已解包宿主网关
+    // { ok: true, value } 信封），以及宿主远程命名空间 api.getAcpSnapshot（这里再解一次）。
+    const snapshotApi = props && props.api ? props.api : null;
+    const useApiFetch = Boolean(snapshotApi && typeof snapshotApi.fetchSnapshot === 'function');
+    const canPullSnapshot =
+      useApiFetch || Boolean(snapshotApi && typeof snapshotApi.getAcpSnapshot === 'function');
+    React.useEffect(() => {
+      if (!canPullSnapshot || !snapshotApi) return undefined;
+      let cancelled = false;
+      const pull = async () => {
+        try {
+          const snap = useApiFetch
+            ? await snapshotApi.fetchSnapshot(GLOBAL)
+            : unwrapRemoteResult(await snapshotApi.getAcpSnapshot({ sessionId: GLOBAL }));
+          if (cancelled) return;
+          const models = normalizeModelCatalog(snap && snap.models);
+          if (models.length > 0) setCatalogModels(models);
+        } catch {
+          /* 忽略：静态目录已经够用 */
+        }
+      };
+      void pull();
+      return () => {
+        cancelled = true;
+      };
+    }, [canPullSnapshot, snapshotApi, useApiFetch]);
+
     const val = (state && state.value) || {};
     const isReady = state && state.status === 'ready';
     const isReadonly = isReady && state.writable !== true;
@@ -1330,6 +1532,60 @@
       }
     };
 
+    const blockedModels = normalizeStringList(readValue('blockedModels'));
+    const planOnlyModels = normalizeStringList(readValue('planOnlyModels'));
+    // 静态目录（稳定顺序）→ 真实快照 → 当前配置里出现过的自定义 ID，全部按大小写不敏感去重。
+    const modelRows = mergeModelCatalog(DEFAULT_MODEL_OPTIONS, catalogModels, blockedModels, planOnlyModels);
+    const accessLabel = (access) => t(MODEL_ACCESS_LABEL_KEYS[access] || 'accessAllow');
+
+    /**
+     * 三态切换：两个数组必须顺序写入（先 blockedModels、后 planOnlyModels），
+     * 全程受同一把 writing.current 防重入锁保护，只读态直接不写。
+     */
+    const applyModelAccess = async (modelValue, access) => {
+      if (!alive.current || disabled || writing.current || !formWritable()) return false;
+      const target = typeof modelValue === 'string' ? modelValue.trim() : '';
+      if (!target || !MODEL_ACCESS_VALUES.includes(access)) return false;
+      const next = nextModelPolicy(
+        readValue('blockedModels'),
+        readValue('planOnlyModels'),
+        target,
+        access
+      );
+      writing.current = true;
+      setPending(true);
+      setNotice('');
+      try {
+        const blockedOk = Boolean(await form.set('blockedModels', next.blockedModels));
+        let ok = blockedOk;
+        if (blockedOk) ok = Boolean(await form.set('planOnlyModels', next.planOnlyModels));
+        if (alive.current) setNotice(ok ? 'saved' : 'error');
+        return ok;
+      } catch {
+        if (alive.current) setNotice('error');
+        return false;
+      } finally {
+        writing.current = false;
+        if (alive.current) setPending(false);
+      }
+    };
+
+    const editCustomModel = (value) => {
+      const text = typeof value === 'string' ? value : '';
+      customModelRef.current = text;
+      if (alive.current) setCustomModelDraft(text);
+    };
+
+    const addCustomModel = async (access) => {
+      const target = String(customModelRef.current || '').trim();
+      if (!target || !MODEL_ACCESS_VALUES.includes(access)) return;
+      const ok = await applyModelAccess(target, access);
+      if (ok && alive.current) {
+        customModelRef.current = '';
+        setCustomModelDraft('');
+      }
+    };
+
     const presetGroup = (labelKey, hintKey, field, values, formatter) =>
       h('div', { className: 'row' },
         h('strong', null, t(labelKey)),
@@ -1367,6 +1623,67 @@
         h('p', { className: 'muted' }, t('effortHint'))
       ),
 
+      h('div', { className: 'card', 'data-card': 'model-access' },
+        h('h3', null, t('modelAccessTitle')),
+        h('div', { className: 'model-access-list', role: 'list', 'aria-label': t('modelAccessTitle') },
+          ...modelRows.map((model) => {
+            const access = modelAccessOf(model.value, blockedModels, planOnlyModels);
+            return h('div', { key: model.value, className: 'model-access-row', role: 'listitem' },
+              h('span', { className: 'model-access-name' },
+                h('strong', null, model.value),
+                model.name && model.name !== model.value
+                  ? h('span', { className: 'muted model-access-label' }, '（' + model.name + '）')
+                  : null
+              ),
+              h('div', {
+                className: 'group',
+                role: 'group',
+                'aria-label': model.value + ' · ' + t('modelAccessLabel'),
+              },
+                ...MODEL_ACCESS_VALUES.map((value) => h('button', {
+                  key: value,
+                  type: 'button',
+                  'aria-pressed': access === value,
+                  'data-model-access': value,
+                  'data-model': model.value,
+                  disabled,
+                  onClick: () => applyModelAccess(model.value, value),
+                }, accessLabel(value)))
+              )
+            );
+          })
+        ),
+        h('p', { className: 'muted' }, t('modelAccessHint')),
+        h('div', { className: 'field' },
+          h('label', { htmlFor: 'agy-acp-custom-model' }, t('customModelLabel')),
+          h('input', {
+            id: 'agy-acp-custom-model',
+            name: 'customModel',
+            type: 'text',
+            autoComplete: 'off',
+            spellCheck: false,
+            disabled,
+            'data-field': 'customModel',
+            placeholder: t('customModelPlaceholder'),
+            value: customModelDraft,
+            onChange: (event) => editCustomModel(event.target.value),
+          }),
+          h('button', {
+            type: 'button',
+            'data-action': 'add-model-plan-only',
+            disabled: disabled || !String(customModelDraft || '').trim(),
+            onClick: () => addCustomModel('plan-only'),
+          }, t('accessPlanOnly')),
+          h('button', {
+            type: 'button',
+            'data-action': 'add-model-blocked',
+            disabled: disabled || !String(customModelDraft || '').trim(),
+            onClick: () => addCustomModel('blocked'),
+          }, t('accessBlocked'))
+        ),
+        h('p', { className: 'muted' }, t('customModelHint'))
+      ),
+
       h('div', { className: 'card', 'data-card': 'runtime' },
         h('h3', null, t('runtimeTitle')),
         presetGroup('concurrencyLabel', 'concurrencyHint', 'maxConcurrent', CONCURRENCY_PRESETS),
@@ -1565,6 +1882,14 @@
     '.dsh-agy-acp-settings input{font:inherit;width:100%;padding:7px 10px;border:1px solid var(--dsw-alias-border-l2);border-radius:8px;background:var(--dsw-alias-bg-layer-1);color:var(--dsw-alias-label-primary)}',
     '.dsh-agy-acp-settings .status{min-height:20px;font-size:13px;color:var(--dsw-alias-label-secondary);margin-top:4px}',
     '.dsh-agy-acp-settings .status.error{color:var(--dsw-alias-state-error-primary)}',
+    '.dsh-agy-acp-settings .model-access-list{display:flex;flex-direction:column;gap:6px;margin:8px 0}',
+    '.dsh-agy-acp-settings .model-access-row{display:flex;gap:12px;align-items:center;justify-content:space-between;flex-wrap:wrap;padding:6px 10px;border:1px solid var(--dsw-alias-border-l1,rgba(128,128,128,.12));border-radius:8px;background:var(--dsw-alias-bg-layer-1)}',
+    '.dsh-agy-acp-settings .model-access-name{display:inline-flex;gap:6px;align-items:baseline;min-width:0;font-family:ui-monospace,SFMono-Regular,Consolas,monospace;font-size:12.5px;overflow-wrap:anywhere}',
+    '.dsh-agy-acp-settings .model-access-label{font-family:inherit}',
+    '.dsh-agy-acp-settings .model-access-row .group button{min-width:72px;padding:4px 10px}',
+    '.dsh-agy-acp-settings .model-access-row .group button[aria-pressed="true"][data-model-access="blocked"]{border-color:var(--dsw-alias-state-error-primary);color:var(--dsw-alias-state-error-primary)}',
+    '.dsh-agy-acp-settings .model-access-row .group button[aria-pressed="true"][data-model-access="plan-only"]{border-color:var(--dsw-alias-state-warn-primary);color:var(--dsw-alias-state-warn-primary)}',
+    '.dsh-agy-acp-settings .model-access-row .group button[aria-pressed="true"][data-model-access="allow"]{border-color:var(--dsw-alias-state-success-primary);color:var(--dsw-alias-state-success-primary)}',
     '.dsh-agy-acp-settings .guide summary{cursor:pointer;font-weight:600;font-size:14px;padding:2px 0;user-select:none}',
   ].join('\n');
 

package/docs/changelog.md

@@ -2,6 +2,33 @@
 
 [返回主页](../README.md) · [配置参考](configuration.md) · [接口参考](reference.md) · [开发与发布](development.md)
 
+## [0.1.3] - 2026-11-15
+
+### 修复
+- 修复真实宿主 `@deepseek-ai/dsh-api-gateway` 的一元 Remote 结果信封 `{ ok: true, value: <payload> }` 未解包的问题：`client.js` 新增 `unwrapRemoteResult()`（只剥成功信封；`ok: false` 失败信封与离线替身/旧宿主的裸 payload 一律原样返回），并接入 `fetchSnapshotOnce` / `stopRun` / `fetchQuotaOnce` 三处。
+  - 症状：面板快照恒为空、停止运行恒报 `stopped: false`、额度卡片读不到 `groups`，设置页也拿不到宿主实测模型列表。
+- 设置页 `settings.section` 槽位的 `inject` 改为传入已构造好的客户端封装 `api`（原为远程命名空间），并把 `AcpSettingsView` 的快照拉取改走 `api.fetchSnapshot`（仍兼容 `api.getAcpSnapshot` 形态并同样解包信封），真实桌面打开设置页即可把宿主实测模型合并进权限矩阵；离线测试只传 `{ form }` 时仍安全降级、绝不报错。
+
+### 测试
+- `test/acp-panel.test.mjs`：新增 `unwrapRemoteResult` 边界用例（成功信封 / 失败信封 / 裸 payload / `value: undefined`）、三处远程调用解包回归（`models`、`stopped: true`、`quota.groups`）、以及挂载后设置页注入 `api` 解包拉取 `models` 并合并进权限矩阵的回归。
+- `test/acp-quota.test.mjs`：新增 `api.fetchQuota` 解包网关信封后额度卡片读到 `groups`（0 余额精确保留）与失败信封继续抛错的回归。
+
+## [0.1.2] - 2026-11-15
+
+### 新增
+- 设置页新增「模型权限控制（允许 / 仅 Plan / 禁用）」卡片：逐模型三态切换，直接改写 `blockedModels` / `planOnlyModels`；两个数组顺序写入并共用同一把防重入锁，只读连接下全部禁用。
+- 支持手动输入自定义模型 ID 并标记为「仅 Plan」或「禁用」，便于第一时间封堵上游新出现的模型。
+- `getAcpSnapshot()` 新增 `models: [{ value, name }]` 字段（来自零进程的 `peekModels()`），`protocol.js` 与 `client.js` 内嵌描述器 1:1 同步归一化，旧快照缺字段时默认 `[]`。
+- `agy_acp({ action: "models" })` 输出为每个模型标注 `[blocked]` / `[plan-only]` 访问状态并给出策略统计，同时保留完整模型目录。
+
+### 变更
+- `DEFAULT_MODELS` 中 `gemini-pro-orchestrator` 的显示名更新为 `Orchestrator (Carbon)`。
+- `MODEL_THOUGHT_LEVELS` 补充 `gemini-pro-orchestrator-argon` 为零思考档位（与 `gemini-pro-orchestrator` 一致），显式 `-low/-medium/-high/-xhigh` 一律拒绝。
+- 设置页「恢复默认设置」现在会一并把 `blockedModels` 与 `planOnlyModels` 重置为空数组。
+
+### 测试
+- 新增 Orchestrator (Carbon/Argon) 零档位锁死回归、模型权限三态切换、手动添加自定义模型、恢复默认清空黑白名单、只读态禁用、`snapshot.models` 协议归一化与热更新实时生效等用例。
+
 ## [0.1.1] - 2026-11-14
 
 ### 修复

package/docs/configuration.md

@@ -24,8 +24,8 @@
 | `extraDirs` | `string[]` | `[]` | 启动 `agy` 时追加 `--add-dir`，同时计入本地图片读取的授权根目录 |
 | `mcpServers` | `object[]` | `[]` | 透传给 `session/new` 与 `session/load` 的 MCP 服务器列表 |
 | `bridgeAllowlist` | `object \| null` | `null` | MCP 桥权限白名单：`{ serverName, readOnlyTools, coordinationTools, writeTools }` |
-| `blockedModels` | `string[]` | `[]` | 一律拒绝的模型名（精确匹配归一化后的模型 ID，大小写不敏感） |
-| `planOnlyModels` | `string[]` | `[]` | 只允许在 `mode: "plan"` 下使用的模型名 |
+| `blockedModels` | `string[]` | `[]` | 一律拒绝的模型名（精确匹配归一化后的模型 ID，大小写不敏感；设置页可视化三态编辑） |
+| `planOnlyModels` | `string[]` | `[]` | 只允许在 `mode: "plan"` 下使用的模型名（同样支持设置页三态编辑） |
 | `quotaIncludeCredits` | `boolean` | `false` | 在设置页持久化：点击刷新额度时是否默认同时查询 `/credits` |
 
 ## 2. 可执行文件探测链与环境变量
@@ -69,3 +69,22 @@ config:
 - `readOnlyTools`：始终自动放行。
 - `coordinationTools`：仅产生受控协作副作用的工具，在 `plan` / 只读父会话下同样放行。
 - `writeTools`：仅非受限模式放行，`plan` / 只读模式下拒绝。
+
+## 4. 模型权限控制（0.1.2）
+
+设置页「默认模型与思考档位」之后新增**模型权限控制（允许 / 仅 Plan / 禁用）**卡片，与 `blockedModels` / `planOnlyModels` 双向对应：
+
+| 点击 | 写入效果 |
+| --- | --- |
+| 允许 | 从 `blockedModels` 与 `planOnlyModels` 中同时移除该模型 |
+| 仅 Plan | 加入 `planOnlyModels`，并从 `blockedModels` 移除 |
+| 禁用 | 加入 `blockedModels`，并从 `planOnlyModels` 移除 |
+
+- 两个数组按「先 `blockedModels`、后 `planOnlyModels`」顺序写入，全程共用同一把防重入锁；只读连接（`writable !== true`）下全部按钮禁用。
+- 列表数据来源 = 内置静态目录（含 `gemini-pro-orchestrator-argon`）+ `snapshot.models`（连接就绪后异步拉取一次，零子进程）+ 当前配置里已有的自定义 ID，按大小写不敏感去重。
+- 列表**不会隐藏**被禁用 / 仅 Plan 的模型，取消即可恢复；「恢复默认设置」会把两个数组一并清空。
+- 手动添加输入框可直接封堵上游新模型 ID，并选择写入「仅 Plan」还是「禁用」。
+
+### 零思考档位模型
+
+`gemini-pro-orchestrator`（显示名 `Orchestrator (Carbon)`）与 `gemini-pro-orchestrator-argon`（`Orchestrator (Argon)`）在服务端不提供 `thought_level`：静态表 `MODEL_THOUGHT_LEVELS` 对其锁定为空数组，任何显式 `effort` 或 `-low/-medium/-high/-xhigh` 后缀都会当场抛 `ACP_INVALID_CONFIG`，运行期也绝不下发 `set_config_option(thought_level)`。

package/docs/reference.md

@@ -25,8 +25,9 @@
 | --- | --- | --- |
 | `carbon` / `gemini-4-carbon-high` | `gemini-4-carbon` (+ `high`) | 支持 `low` / `medium` / `high` |
 | `hydrogen` / `hydrogen-xhigh` / `hydrogen-max` | `gemini-4-hydrogen` + `xhigh` | 唯一支持 `xhigh` 的模型，拒绝 `minimal` |
-| `orchestrator` | `gemini-pro-orchestrator` | 服务端无 `thought_level`，传任何档位均报错 |
-| `opus` / `argon` / `sonnet` | `claude-opus-5-5` / `gemini-4-argon` / `claude-sonnet-5-5` | 可配合 `Config.blockedModels` / `planOnlyModels` 管控 |
+| `orchestrator` | `gemini-pro-orchestrator`（显示名 `Orchestrator (Carbon)`） | 服务端无 `thought_level`，传任何档位（含 `-low/-medium/-high/-xhigh`）均报错 |
+| `gemini-pro-orchestrator-argon` | `gemini-pro-orchestrator-argon`（显示名 `Orchestrator (Argon)`） | 同为官方零思考档位，静态表锁定为空，任何档位均拒绝；可配合 `Config.blockedModels` 封堵 |
+| `opus` / `argon` / `sonnet` | `claude-opus-5-5` / `gemini-4-argon` / `claude-sonnet-5-5` | 可配合 `Config.blockedModels` / `planOnlyModels` 管控（模型权限卡片可视化设置） |
 | `gpt-oss-120b-medium` | `gpt-oss-120b-medium` (锁 `medium`) | 显式传冲突档位直接报错 |
 
 ## 3. 多模态图片输入规范
@@ -62,7 +63,9 @@
 
 - `service.runDirectTurn(input)`：绕过 `ctx.jobs` 直接排队执行单轮 ACP 任务。
 - `service.listModels({ cwd, accessMode, signal })`：握手探测真实目录（5 分钟缓存 + single-flight）。
-- `service.peekModels()`：同步零进程返回缓存或静态兜底目录。
+- `service.peekModels()`：同步零进程返回缓存或静态兜底目录（**保留全部已知模型，不隐藏被 `blockedModels` / `planOnlyModels` 命中的模型**，设置页才能把权限改回来）。
+- `service.peekModelOptions()`：同步零进程返回 `{ value, name }[]`，与 `peekModels()` 同源且**不做策略裁剪**（设置页与快照共用）。
+- `service.getAcpSnapshot()` 的返回值附带 `models: [{ value, name }]`（同源于 `peekModels()`，零启动子进程），供设置页渲染模型权限卡片。
 - `service.normalizeModelSpec(spec)`：同步校验模型、别名、档位与锁档冲突。
 - `service.getQuota({ force, includeCredits })` / `service.peekQuota()`：按需运行只读 `agy -p /usage --output-format json`（及可选 `/credits`），具备 5 分钟缓存、single-flight、不可关闭的 45 秒硬超时，失败时保留上一次成功快照并标记 `stale: true`，严格区分数字 `0` 与 `null`。
 

package/index.js

@@ -221,6 +221,32 @@ function assertModelPolicy(config, model, mode) {
   }
 }
 
+/**
+ * 给 `action:"models"` 的每项模型打上策略标记（大小写不敏感，与 normalizeModelSet 同源）：
+ *   - `blocked`：被 `Config.blockedModels` 禁用；
+ *   - `plan-only`：仅允许在 `mode:"plan"` 下使用；
+ *   - `allow`：无限制。
+ *
+ * 注意：这里只做「标注」，绝不从目录里剔除模型——模型清单必须保持完整，
+ * 用户才能在设置页把被禁用的模型改回允许。
+ */
+function annotateModelAccess(config, models) {
+  const blocked = normalizeModelSet(config?.blockedModels);
+  const planOnly = normalizeModelSet(config?.planOnlyModels);
+  const out = [];
+  for (const model of Array.isArray(models) ? models : []) {
+    if (!model || typeof model.value !== 'string' || !model.value) continue;
+    const key = model.value.trim().toLowerCase();
+    const access = blocked.has(key) ? 'blocked' : planOnly.has(key) ? 'plan-only' : 'allow';
+    out.push({
+      value: model.value,
+      name: typeof model.name === 'string' && model.name ? model.name : model.value,
+      access,
+    });
+  }
+  return out;
+}
+
 /* ------------------------------------------------------------------ */
 /* 工具                                                                */
 /* ------------------------------------------------------------------ */
@@ -302,6 +328,46 @@ function createAgyTool({ getService, getConfig, ctx, dshTools }) {
           const lines = [];
           const status = String(value?.status ?? 'ok');
           const workerName = value?.worker ?? args?.name ?? '';
+          if (status === 'models') {
+            const models = Array.isArray(value?.models) ? value.models : [];
+            const blockedCount = models.filter((model) => model?.access === 'blocked').length;
+            const planOnlyCount = models.filter((model) => model?.access === 'plan-only').length;
+            lines.push(
+              'agy 模型目录（' +
+                models.length +
+                ' 项，' +
+                (value?.cached ? '缓存命中' : '实时探测') +
+                '；[blocked] 禁用，[plan-only] 仅 Plan）'
+            );
+            for (const model of models) {
+              const tag =
+                model?.access === 'blocked'
+                  ? ' [blocked]'
+                  : model?.access === 'plan-only'
+                    ? ' [plan-only]'
+                    : '';
+              const label = String(model?.value ?? '');
+              const name = String(model?.name ?? '');
+              lines.push('- ' + label + (name && name !== label ? '（' + name + '）' : '') + tag);
+            }
+            const efforts = Array.isArray(value?.efforts) ? value.efforts : [];
+            lines.push('思考档位: ' + (efforts.length > 0 ? efforts.join(' | ') : '（无，服务端不提供 thought_level）'));
+            const modes = Array.isArray(value?.modes) ? value.modes : [];
+            if (modes.length > 0) lines.push('运行模式: ' + modes.join(' | '));
+            const current = value?.current ?? {};
+            if (current.model) {
+              lines.push(
+                '当前模型: ' + current.model + ' (' + String(current.effort ?? 'default') + ')'
+              );
+            }
+            lines.push(
+              '权限策略: 禁用 ' + blockedCount + ' 项 · 仅 Plan ' + planOnlyCount + ' 项'
+            );
+            lines.push(
+              '提示：被标记的模型仍保留在目录里，可在插件设置页「模型权限控制」改成允许 / 仅 Plan / 禁用。'
+            );
+            return [{ type: 'text', text: lines.join('\n') }];
+          }
           if (status === 'started') {
             lines.push('agy 后台任务已启动' + (workerName ? '（worker: ' + workerName + '）' : ''));
             if (value?.job_id) lines.push('job_id: ' + value.job_id);
@@ -410,14 +476,21 @@ function createAgyTool({ getService, getConfig, ctx, dshTools }) {
             accessMode: policy.accessMode,
             signal: exec?.signal,
           });
+          const models = annotateModelAccess(config, catalog.models);
           return {
             status: 'models',
-            models: catalog.models,
+            models,
             efforts: catalog.efforts,
             modes: catalog.modes,
             current: catalog.current,
             cached: catalog.cached,
             executable: config.executable,
+            policy: {
+              blockedModels: [...normalizeModelSet(config.blockedModels)],
+              planOnlyModels: [...normalizeModelSet(config.planOnlyModels)],
+              blockedCount: models.filter((model) => model.access === 'blocked').length,
+              planOnlyCount: models.filter((model) => model.access === 'plan-only').length,
+            },
           };
         }
 
@@ -1050,6 +1123,7 @@ module.exports = {
   toToolResult,
   formatResultReport,
   assertModelPolicy,
+  annotateModelAccess,
   mountAcpRemoteService,
   REMOTE_METHOD_DESCRIPTOR_KEY,
   AgyWorkerService,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-agy-acp",
   "displayName": "Antigravity ACP Worker",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Antigravity CLI (agy) ACP bridge for DeepSeek Harness: resumable worker turns, background job wakeup, semaphore queuing, four-tier permission gating, zero-sidecar SQLite token ledger, and on-demand quota inspection.",
   "license": "MIT",
   "author": "higekibaka",

package/src/acp-client.js

@@ -22,7 +22,7 @@ const executableMod = require('./executable.js');
 const imagesMod = require('./images.js');
 
 const PLUGIN_NAME = 'dsh-agy-acp';
-const PLUGIN_VERSION = '0.1.1';
+const PLUGIN_VERSION = '0.1.3';
 const PROTOCOL_VERSION = 1;
 const MAX_LINE_BYTES = 8 * 1024 * 1024;
 
@@ -34,7 +34,7 @@ const DEFAULT_MODELS = Object.freeze([
   { value: 'gemini-4-carbon', name: 'Gemini 4 Carbon' },
   { value: 'gemini-4-argon', name: 'Gemini 4 Argon' },
   { value: 'gemini-4-hydrogen', name: 'Gemini 4 Hydrogen' },
-  { value: 'gemini-pro-orchestrator', name: 'Orchestrator' },
+  { value: 'gemini-pro-orchestrator', name: 'Orchestrator (Carbon)' },
   { value: 'claude-opus-5-5', name: 'Claude Opus 5.5' },
   { value: 'claude-sonnet-5-5', name: 'Claude Sonnet 5.5' },
   { value: 'gpt-oss-120b-medium', name: 'GPT-OSS 120B (medium)' },
@@ -64,11 +64,13 @@ const DEFAULT_THOUGHT_LEVELS = Object.freeze(['low', 'medium', 'high']);
 /**
  * 模型级静态档位能力表：表内模型以表为准，其余模型沿用服务端目录或三档默认。
  * - gemini-4-hydrogen：官方四档（默认 high），独有 xhigh，拒绝 minimal。
- * - gemini-pro-orchestrator：服务端明确不提供 thought_level，任何档位都必须拒绝。
+ * - gemini-pro-orchestrator / gemini-pro-orchestrator-argon：服务端明确不提供 thought_level，
+ *   任何档位（含 -low/-medium/-high/-xhigh 后缀）都必须拒绝，两者同为官方零思考档位。
  */
 const MODEL_THOUGHT_LEVELS = Object.freeze({
   'gemini-4-hydrogen': Object.freeze(['low', 'medium', 'high', 'xhigh']),
   'gemini-pro-orchestrator': Object.freeze([]),
+  'gemini-pro-orchestrator-argon': Object.freeze([]),
 });
 
 /** Hydrogen 模型 ID 判定（当前 ACP 目录里的唯一形态）。 */

package/src/protocol.js

@@ -255,6 +255,25 @@ function normalizeWorkerItem(raw) {
   };
 }
 
+/** 模型目录项：`{ value, name }`，空 value 丢弃，绝不产生 undefined。 */
+function normalizeModelOption(raw) {
+  const value = coerceString(raw?.value, '');
+  if (!value) return null;
+  const name = coerceString(raw?.name, '');
+  return { value, name: name || value };
+}
+
+/** 模型目录归一化：旧快照没有 `models` 字段时默认空数组。 */
+function normalizeModelCatalog(raw) {
+  if (!Array.isArray(raw)) return [];
+  const out = [];
+  for (const item of raw) {
+    const option = normalizeModelOption(item);
+    if (option) out.push(option);
+  }
+  return out;
+}
+
 function normalizeAcpSnapshot(raw) {
   return {
     focusSessionId: coerceString(raw?.focusSessionId, GLOBAL_SESSION_ID),
@@ -282,6 +301,7 @@ function normalizeAcpSnapshot(raw) {
     activeRuns: Array.isArray(raw?.activeRuns) ? raw.activeRuns.map(normalizeRunItem) : [],
     recentRuns: Array.isArray(raw?.recentRuns) ? raw.recentRuns.map(normalizeRunItem) : [],
     workers: Array.isArray(raw?.workers) ? raw.workers.map(normalizeWorkerItem) : [],
+    models: normalizeModelCatalog(raw?.models),
     quota: raw?.quota ? normalizeAcpQuota(raw.quota) : null,
   };
 }
@@ -528,6 +548,8 @@ module.exports = {
   normalizeUsageReconciliation,
   normalizeRunItem,
   normalizeWorkerItem,
+  normalizeModelOption,
+  normalizeModelCatalog,
   normalizeAcpQuota,
   normalizeAcpSnapshot,
   parseSessionRequest,

package/src/worker-service.js

@@ -1680,6 +1680,9 @@ class AgyWorkerService {
       activeRuns,
       recentRuns,
       workers,
+      // 模型目录（零子进程）：完整保留全部已知模型，绝不按 blacklist 裁剪，
+      // 否则设置页取消勾选后无法把被禁用的模型钩回来。
+      models: this.peekModelOptions(),
       quota: this.peekQuota(),
     };
   }
@@ -1975,6 +1978,26 @@ class AgyWorkerService {
     };
   }
 
+  /**
+   * 面板 / 设置页用的模型目录摘要（零子进程），每项形如 `{ value, name }`。
+   *
+   * 与 `peekModels()` 同源，且**不做任何策略裁剪**：`blockedModels` /
+   * `planOnlyModels` 命中的模型也必须留在目录里，前端三态按钮才能再改回来。
+   */
+  peekModelOptions() {
+    const catalog = this.peekModels();
+    const list = Array.isArray(catalog?.models) ? catalog.models : [];
+    const out = [];
+    for (const model of list) {
+      if (!model || typeof model.value !== 'string' || !model.value) continue;
+      out.push({
+        value: model.value,
+        name: typeof model.name === 'string' && model.name ? model.name : model.value,
+      });
+    }
+    return out;
+  }
+
   /**
    * 共享执行入口的模型策略：先按别名/后缀/默认值归一化，再比对黑名单。
    *