@ai-wendao/ant 0.4.10 → 0.4.12

package/README.md

@@ -2,12 +2,20 @@
 
 ANT (AI-native Teams) connects a DeepSeek Harness Desktop profile to its team's membership and approved models.
 
+## 团队模型默认值
+
+团队管理员在 ANT 控制台设置团队默认模型，并授权成员可用模型。成员第一次在 ANT 插件中同步模型时，团队默认会写入 DSH 的全局默认模型；成员之后可在“团队模型”页选另一项已获准模型。普通同步保留成员选择；若模型被撤销，插件会回到仍获准的团队默认。该默认写入 DSH profile，因此也影响同一 profile 新建的普通 DSH 会话。ANT 对话和任务会额外校验当前用户的获准模型；Codex 与 Claude Code 使用各自执行器的默认模型。
+
+每个 OpenAI 兼容模型可配置 Chat Completions 或 Responses API。旧模型记录在升级后按 Chat Completions 解释；ANT 服务端继续使用原配置的 `/chat/completions` URL，并从相同 API 根路径派生 `/responses` 上游路径。
+
 飞书和企业微信的机器人连接、消息收发由 DSH-IM 负责；ANT Bundle 不保存机器人密钥或直连 IM 平台。ANT 继续负责团队成员身份和模型授权，并可在成员显式开启时接管一个专用飞书机器人的文本收件，按成员授权范围处理协作请求。
 
 ## 协作机器人与任务卡
 
 成员在 ANT 插件设置页选择一个 DSH-IM 飞书机器人并启用协作收件。每段私聊、群聊或话题由同一受限 DSH 会话自然回答和追问；只有 DSH 准备执行任务时，才通过 ANT 工具提交任务卡 ID 和参数，由服务端再次核对真实请求人、群、参数及授权。成员按需创建任务卡，设置意图、参数、请求人、适用会话和有效期；PR 审查只是可选示例。普通文字任务由没有本机工具权限的 DSH 会话处理。单个 Gitea PR 参数还可选择 Codex 专用只读 CLI，或 DSH 已注册的 Claude Code 子代理试用：ANT 用只读 Gitea 令牌为每项 PR 审查能力维护本机仓库缓存，并按已核验的 PR Head SHA 创建独立工作树；令牌不会交给执行器。Codex 使用固定只读权限配置，Claude Code 沿用 DSH 提供方的本机权限设置。执行器可查看完整源码和已核验 diff；工作区不含 `.git`、符号链接或子模块，也不会运行仓库脚本。Claude Code 仍是所有者手动开放的本机试用，不宣称具备操作系统级只读隔离。成员可查询或取消任务；每台电脑默认同时处理三项任务，成员可调整，旧版 PR 审查与新任务共用名额。
 
+PR 任务卡可勾选 DSH、Codex 和 Claude Code 等这台 DSH 可用的审查 Agent，并指定普通请求的默认执行方。普通审查只启动默认 Agent；请求人明确提出“交叉 review”时，ANT 会并行启动所有勾选项、提供分别标明执行方的结果。交叉审查至少需要两位 Agent；个别 Agent 失败时保留成功结果并标明失败项。Codex 和 Claude Code 只支持一个必填的 Gitea PR 参数；DSH 审查已提供的 diff，不读取完整仓库。
+
 私聊默认开启，所有者可按机器人单独关闭或重新开启；关闭后新私聊消息不会进入 DSH，机器人每五分钟最多向同一请求人发送一次静态恢复指引；所有者身份绑定命令仍可用。关闭前已提交的任务不会撤销，仍回复原私聊；群聊设置不受影响。群聊由所有者逐群启用普通聊天，任务授权再按卡单独设置。群里有人 @ 机器人后，群 ID 出现在插件列表；所有者也可手动填写群 ID。若所有者在群里，可先私聊机器人绑定飞书身份，再在群内提出“在本群启用聊天”，或按提示确认“在本群启用任务 任务名称”。群消息只在明确 @ 时处理，任务结果公开回复原群／原话题；要求私聊回复的群消息会提示请求人改为私聊发起。当前 DSH-IM 未提供可核验的机器人进／出群发起者，所以不会因被拉群自动启用。不同群、话题和私聊的上下文默认隔离；每项能力当前只能关联一个范围，即私聊或一个群；要让多个群或私聊都能执行，需分别建立能力卡，并分别设定请求人和有效期。群历史按需读取，默认先看十条、最多检查一百条平台记录，实际可见范围由飞书权限决定。
 
 新建任务卡的 Codex 与 Claude Code 执行方目前只接受一个必填 Gitea PR 参数。Gitea PR 源仓库和目标仓库大小按 API KiB 换算为 bytes，并在 fetch 前与 512 MiB 单仓库快照上限及本机总缓存预算核对。每台 DSH 的长期 bare 仓库缓存默认最多 10 GiB，可在插件的“本机处理设置”调整为 1–100 GiB；按缓存文件逻辑大小计算，不含临时工作目录及文件系统分配开销。预算也为即将拉取的仓库预留空间。Git fetch 强制使用单 pack；POSIX 系统用进程文件大小限制约束 pack 与 index 的总预算，并监控缓存总量。正常情况下不会淘汰仍启用能力的缓存；若实际 fetch 越界，会清理本项能力的仓库缓存（旧 PR 可在后续任务重新下载）。Windows 暂未实现等效的原生 fetch 硬限制，Codex/Claude Code PR 快照会失败关闭，界面会禁用对应选项并提示 DSH 差异审查。停用/过期能力的缓存会在刷新时回收。任务工作树是短期目录，受单快照 512 MiB、最多 10,000 个文件、单文件最多 64 MiB 限制，不计入长期缓存预算，完成后删除。快照不支持符号链接或子模块，也不下载 Git LFS 实际文件；快照中的 LFS 指针不能代表已审查的实际文件内容。Codex/Claude Code 的 granular Gitea Token 还需 `read:repository` 和 `read:user`，后者仅用于本机获取 Git HTTPS 用户名。超限时任务失败，不降级为 diff-only。快照与权限验收范围见[Claude Code 任务卡计划](../../docs/plans/2026-10-22-claude-code-task-card.md)及[执行方隔离](../../docs/decisions/2026-10-22-im-native-executor-isolation.md)。普通对话和 DSH 文字任务不直接获得文件、命令或网络工具。机器人独占收件模式由 DSH-IM 保存；停止 ANT 授权后若需恢复 DSH-IM 原有聊天，需要在 DSH-IM 中切回普通模式。

package/client.js

@@ -6,7 +6,9 @@ window.__ModuleLoader__.load({
     const { createElement, useEffect, useRef, useState } = require('react')
     const h = createElement
     const SERVICE_URL_STORAGE_KEY = 'ant-team-service-url'
+    const PROVIDER_ROUTES_STORAGE_KEY = 'ant-team-provider-routes'
     const DEVICE_ID_STORAGE_KEY = 'ant-team-device-id'
+    const DEFAULT_MODEL_INITIALIZED_KEY = 'ant-team-default-model-initialized'
     const ANT_BUNDLE_PACKAGE_NAME = '@ai-wendao/ant'
     const ANT_API_PROTOCOL_VERSIONS = [1]
     const PLUGIN_INSTALL_RECORD_PREFIX = 'ant-reviewed-plugin-install:'
@@ -473,12 +475,15 @@ window.__ModuleLoader__.load({
       const [examples, setExamples] = useState('')
       const [taskPrompt, setTaskPrompt] = useState('')
       const [runner, setRunner] = useState('dsh')
+      const [reviewers, setReviewers] = useState(['dsh'])
       const [parameters, setParameters] = useState([])
       const [giteaToken, setGiteaToken] = useState('')
       const [tokenConfigured, setTokenConfigured] = useState(false)
       const [senderScope, setSenderScope] = useState('any')
       const [senderIds, setSenderIds] = useState('')
       const [days, setDays] = useState(7)
+      const [editingCardId, setEditingCardId] = useState(null)
+      const [editingExpiresAt, setEditingExpiresAt] = useState(null)
       const [busy, setBusy] = useState(false)
       const [loading, setLoading] = useState(true)
       const [botLoadError, setBotLoadError] = useState(false)
@@ -554,17 +559,28 @@ window.__ModuleLoader__.load({
       const enrolledCount = enrolled.filter((item) => item.device_bound_to_current
         && connectedBots.some((bot) => bot.fingerprint === item.bot_fingerprint)).length
       const selectedTaskCount = activeCards.filter((card) => card.bot_fingerprint === selectedBot?.fingerprint).length
-      const selectedRunnerNeedsPr = ['codex', 'claude-code'].includes(runner)
+      const nativeReviewerSelected = reviewers.some((item) => ['codex', 'claude-code'].includes(item))
+      const hasPrParameter = parameters.some((item) => item.kind === 'gitea_pr')
       const codexAvailable = executors.some((item) => item.id === 'codex-readonly' && item.available)
       const claudeCodeAvailable = executors.some((item) => item.id === 'claude-code' && item.available)
+      const dshAvailable = executors.some((item) => item.id === 'dsh' && item.available)
       const nativePrUnavailableReason = executors.find((item) => item.reason)?.reason || null
+      const reviewerLabel = (id) => ({ dsh: 'DSH', codex: 'Codex', 'claude-code': 'Claude Code' })[id] || id
+      const cardReviewerSummary = (card) => {
+        const selected = Array.isArray(card.reviewers) && card.reviewers.length ? card.reviewers : [card.runner]
+        return selected.length > 1
+          ? `交叉可用：${selected.map(reviewerLabel).join('、')}；默认 ${reviewerLabel(card.runner)}`
+          : card.runner === 'codex' ? 'Codex PR 快照审查'
+            : card.runner === 'claude-code' ? 'Claude Code PR 快照审查'
+              : 'DSH 文字处理'
+      }
       const requesterSummary = senderScope === 'allowlist'
         ? `仅指定成员：${senderIds.trim() || '尚未填写成员 ID'}`
         : conversationKind === 'group' ? `群 ${groupId || '尚未选择'} 的所有成员` : '任何能私聊此机器人的人'
       const resultRouteSummary = conversationKind === 'group' ? '回复到原群（群内可见）' : '回复到发起任务的私聊'
       const executorSummary = runner === 'codex' ? '本机 Codex · PR 快照'
         : runner === 'claude-code' ? '本机 Claude Code · PR 快照' : 'DSH · 当前授权模型'
-      const resourceSummary = selectedRunnerNeedsPr ? '指定仓库的已核验 PR 快照'
+      const resourceSummary = nativeReviewerSelected ? '指定仓库的已核验 PR 快照'
         : '当前会话中 DSH 实际可见的内容'
       const cardBlockReason = enrollmentLoadError ? '暂时无法核对机器人是否已启用协作，请刷新状态后再试。'
         : !botConnected || !selectedEnrollmentBound ? '先在上方把机器人绑定到这台 DSH。'
@@ -577,20 +593,56 @@ window.__ModuleLoader__.load({
               : parameters.some((rule) => rule.kind === 'gitea_pr')
                 && normalizeServiceUrl(trustedOrigin) !== selectedEnrollment?.gitea_origin
                 ? '请先保存机器人级可信 Gitea 地址；PR 参数会自动使用这个地址。'
-              : selectedRunnerNeedsPr && (parameters.length !== 1 || parameters[0].kind !== 'gitea_pr')
+              : nativeReviewerSelected && (parameters.length !== 1 || parameters[0].kind !== 'gitea_pr')
                 ? 'Codex 和 Claude Code 目前只支持单个 Gitea PR 审查任务。'
-                : selectedRunnerNeedsPr && !parameters[0].required
+                : nativeReviewerSelected && !parameters[0].required
                   ? '本机代码审查的 Gitea PR 编号必须设为必填。'
-                : runner === 'codex' && !codexAvailable
-                  ? '这台 DSH 尚未找到可用的 Codex CLI，请先安装或检查 DSH 的 PATH。'
-                : runner === 'claude-code' && !claudeCodeAvailable
-                  ? '这台 DSH 尚未注册 Claude Code 子代理，请先在 DSH 中安装并启用它。'
+                : reviewers.includes('dsh') && !dshAvailable
+                  ? '这台 DSH 尚未准备好文字审查执行器。'
+                  : reviewers.includes('codex') && !codexAvailable
+                    ? '这台 DSH 尚未找到可用的 Codex CLI，请先安装或检查 DSH 的 PATH。'
+                    : reviewers.includes('claude-code') && !claudeCodeAvailable
+                      ? '这台 DSH 尚未注册 Claude Code 子代理，请先在 DSH 中安装并启用它。'
               : ''
       const loadNames = { bots: '机器人', 'enrolled-bots': '协作启用状态', groups: '群聊列表',
         cards: '任务授权', settings: '团队默认值', executors: '本机执行器',
         'local-settings': '本机设置', status: '最近任务' }
       const updateParameter = (index, patch) => setParameters((current) => current.map((rule, i) => i === index ? { ...rule, ...patch } : rule))
+      const changeReviewer = (id, enabled) => {
+        const next = enabled ? [...reviewers, id] : reviewers.filter((item) => item !== id)
+        if (!next.length) { setMessage('至少保留一位审查 Agent。'); return }
+        setReviewers([...new Set(next)])
+        if (!next.includes(runner)) setRunner(next[0])
+      }
+      const startNewCard = () => {
+        setEditingCardId(null); setEditingExpiresAt(null)
+        setDraftNotice('')
+        setTitle(''); setIntent(''); setExamples(''); setTaskPrompt(''); setRunner('dsh')
+        setReviewers(['dsh'])
+        setParameters([]); setConversationKind('dm'); setGroupId('')
+        setSenderScope('any'); setSenderIds(''); setDays(7); setCreateOpen(true)
+      }
+      const editCard = (card, copy = false) => {
+        setBotId(card.bot_id)
+        setTrustedOrigin(enrolled.find((bot) => bot.bot_id === card.bot_id)?.gitea_origin || '')
+        setEditingCardId(copy ? null : card.id); setEditingExpiresAt(copy ? null : card.expires_at)
+        setTitle(copy ? `${card.title.slice(0, 94)}（副本）` : card.title)
+        if (copy) setDays(7)
+        setIntent(card.intent); setExamples((card.examples || []).join('\n'))
+        setTaskPrompt(card.task_prompt); setRunner(card.runner)
+        setReviewers(Array.isArray(card.reviewers) && card.reviewers.length ? card.reviewers : [card.runner])
+        setParameters((card.parameters || []).map((rule) => ({
+          name: rule.name, kind: rule.kind, required: rule.required,
+          description: rule.description || '', min: rule.min == null ? '' : String(rule.min),
+          max: rule.max == null ? '' : String(rule.max), choices: (rule.choices || []).join(', '),
+          gitea_origin: rule.gitea_origin || '', repository: rule.repository || '',
+        })))
+        setConversationKind(card.conversation_kind); setGroupId(card.conversation_id || '')
+        setSenderScope(card.sender_scope); setSenderIds((card.sender_ids || []).join(', '))
+        setCreateOpen(true)
+      }
       const preparePrExample = () => {
+        setEditingCardId(null); setEditingExpiresAt(null)
         setTitle('审查 Gitea PR 差异')
         setIntent('同事希望查看指定 Gitea PR 的代码差异并获得审查意见。')
         setExamples('请帮我审查 123 号 PR\n看看刚才提到的 PR 有什么风险')
@@ -598,7 +650,13 @@ window.__ModuleLoader__.load({
         setParameters([{ name: 'pr_number', kind: 'gitea_pr', required: true,
           description: '要审查的 PR 编号', min: '1', max: '', choices: '',
           gitea_origin: selectedEnrollment?.gitea_origin || trustedOrigin || '', repository: '' }])
-        setRunner(codexAvailable ? 'codex' : claudeCodeAvailable ? 'claude-code' : 'dsh')
+        const availableReviewers = [
+          ...(codexAvailable ? ['codex'] : []),
+          ...(claudeCodeAvailable ? ['claude-code'] : []),
+        ]
+        const selected = availableReviewers.length ? availableReviewers : ['dsh']
+        setReviewers(selected)
+        setRunner(selected[0])
         setCreateOpen(true)
       }
       const saveGiteaToken = async () => {
@@ -804,6 +862,9 @@ window.__ModuleLoader__.load({
         event.preventDefault()
         setDraftNotice('')
         if (!selectedBot || !botConnected || !selectedEnrollmentBound) { setMessage('请先在这台 DSH 绑定选中的协作机器人。'); return }
+        if (editingCardId && (!editingExpiresAt || editingExpiresAt <= Math.floor(Date.now() / 1000))) {
+          setMessage('这项能力已到期，无法继续编辑；请返回后重新开放一项能力。'); return
+        }
         if (!title.trim() || !intent.trim() || !taskPrompt.trim()) {
           setMessage('请填写能力名称、适用请求说明和处理要求。'); return
         }
@@ -855,45 +916,67 @@ window.__ModuleLoader__.load({
         if (normalized.some((rule) => rule.kind === 'gitea_pr' && !validRepository(rule.repository))) {
           setMessage('Gitea 仓库请填写“团队名/仓库名”，不要包含空格或多余路径。'); return
         }
-        if (['codex', 'claude-code'].includes(runner) && (normalized.length !== 1
-          || normalized[0].kind !== 'gitea_pr' || !normalized[0].required)) {
-          setMessage('Codex 和 Claude Code 目前需要一个必填的 Gitea PR 编号参数。'); return
+        if (!reviewers.length || !reviewers.includes(runner)) {
+          setMessage('请至少选择一位审查 Agent，并设置普通请求的默认执行方。'); return
         }
-        if (runner === 'codex' && !codexAvailable) {
-          setMessage('这台 DSH 尚未找到可用的 Codex CLI。'); return
-        }
-        if (runner === 'claude-code' && !claudeCodeAvailable) {
-          setMessage('这台 DSH 尚未注册 Claude Code 子代理。'); return
+        if (nativeReviewerSelected && (normalized.length !== 1
+          || normalized[0].kind !== 'gitea_pr' || !normalized[0].required)) {
+          setMessage('选择 Codex 或 Claude Code 时，需要一个必填的 Gitea PR 编号参数。'); return
         }
         const scope = conversationKind === 'group' ? `群 ${groupId}` : '私聊'
         const resultDestination = conversationKind === 'group' ? '原群（群内可见）' : '发起任务的私聊'
-        const executionInfo = runner === 'codex'
-          ? 'ANT 会使用这台电脑已登录的 Codex，在已核验 PR Head 的临时完整代码快照中固定只读权限；会传入所有者要求、请求人原话和 PR 差异，不传 Gitea 令牌。'
-          : runner === 'claude-code'
-            ? 'ANT 会调用这台 DSH 已注册的 Claude Code 子代理，在已核验 PR Head 的临时完整代码快照中审查；会传入所有者要求、请求人原话和 PR 差异，不传 Gitea 令牌。它沿用 DSH 中 Claude Code 的本机权限设置；请确认该设置适合由获准成员请求审查。'
-            : '这项任务仅由受限 DSH 处理已提供的文字。'
-        if (!window.confirm(`开放“${title}”后，${requesterSummary}可在${scope}请求，有效期 ${days} 天；结果${resultDestination}。${executionInfo}请确认。`)) return
+        const executionDetails = {
+          dsh: 'DSH 只根据已提供的 PR diff 审查，不读取完整仓库。',
+          codex: 'Codex 使用已核验 PR Head 的临时代码快照，并启用本机固定只读权限；不接收 Gitea 令牌。',
+          'claude-code': 'Claude Code 使用同一份临时代码快照，沿用这台 DSH 的本机权限设置；请确认该权限适合由获准成员请求审查。',
+        }
+        const executionInfo = reviewers.length > 1
+          ? `普通请求默认由 ${reviewerLabel(runner)} 执行；请求人明确说“交叉 review”时，会并行启动 ${reviewers.map(reviewerLabel).join('、')}，分别返回审查结果。${reviewers.map((item) => executionDetails[item]).join(' ')}`
+          : executionDetails[reviewers[0]]
+        const actionDescription = editingCardId
+          ? `更新“${title}”后，${requesterSummary}可在${scope}使用新配置；旧待确认请求将失效，已提交任务继续使用提交时的配置。结果${resultDestination}。到期时间保持为 ${new Date(editingExpiresAt * 1000).toLocaleString('zh-CN')}。`
+          : `开放“${title}”后，${requesterSummary}可在${scope}请求，有效期 ${days} 天；结果${resultDestination}。`
+        if (!window.confirm(`${actionDescription}${executionInfo}请确认。`)) return
         setBusy(true)
         try {
           const response = await fetch('/api/ant-teams/delegation/cards', {
-            method: 'POST', headers: { 'content-type': 'application/json' },
-            body: JSON.stringify({ bot_id: selectedBot.bot_id, bot_fingerprint: selectedBot.fingerprint,
+            method: editingCardId ? 'PUT' : 'POST', headers: { 'content-type': 'application/json' },
+            body: JSON.stringify({ ...(editingCardId ? { id: editingCardId } : {}),
+              bot_id: selectedBot.bot_id, bot_fingerprint: selectedBot.fingerprint,
               title, intent, examples: exampleLines,
-              parameters: normalized, task_prompt: taskPrompt, runner, workspace: null,
+              parameters: normalized, task_prompt: taskPrompt, runner, reviewers, workspace: null,
               sender_scope: senderScope, sender_ids: senderScope === 'allowlist'
                 ? senderIds.split(/[\s,，]+/u).filter(Boolean) : [], conversation_kind: conversationKind,
               ...(conversationKind === 'group' ? { conversation_id: groupId } : {}),
-              expires_at: Math.floor(Date.now() / 1000) + Number(days) * 86400 }),
+              expires_at: editingCardId ? editingExpiresAt : Math.floor(Date.now() / 1000) + Number(days) * 86400 }),
           })
           const result = await readLocalJsonResponse(response)
-          if (!response.ok && runner === 'claude-code' && result.code === 'INVALID_REQUEST') {
-            throw new Error('当前团队服务端可能尚不支持 Claude Code 执行方。请管理员升级服务端后刷新重试。')
+          if (!response.ok && reviewers.includes('claude-code') && result.code === 'INVALID_REQUEST') {
+            throw new Error('当前团队服务端可能尚不支持 Claude Code 审查配置。请管理员升级服务端后刷新重试。')
           }
           if (!response.ok) throw new Error(result.message || '能力保存失败。')
-          setTitle(''); setIntent(''); setExamples(''); setTaskPrompt(''); setParameters([]); setRunner('dsh')
+          const savedReviewers = Array.isArray(result.reviewers) && result.reviewers.length
+            ? result.reviewers : [result.runner]
+          if ([...savedReviewers].sort().join('\0') !== [...reviewers].sort().join('\0')) {
+            if (!editingCardId && typeof result.id === 'string') {
+              const cleanup = await fetch('/api/ant-teams/delegation/cards', {
+                method: 'DELETE', headers: { 'content-type': 'application/json' },
+                body: JSON.stringify({ id: result.id }),
+              }).catch(() => null)
+              if (!cleanup?.ok) {
+                await load().catch(() => undefined)
+                throw new Error('团队服务端尚不支持多 Agent 审查配置；旧服务端可能已保存单 Agent 授权，请刷新列表并停止它，再升级 ANT 服务端。')
+              }
+            }
+            throw new Error('当前团队服务端尚不支持多 Agent 审查配置；请管理员升级 ANT 服务端后重试。')
+          }
+          setTitle(''); setIntent(''); setExamples(''); setTaskPrompt(''); setParameters([]); setRunner('dsh'); setReviewers(['dsh'])
+          setEditingCardId(null); setEditingExpiresAt(null)
           await load()
           setCreateOpen(false)
-          setMessage('能力已开放。同事可自然地提出这类请求；参数不完整时机器人会追问。')
+          setMessage(editingCardId
+            ? '能力配置已更新。新请求将使用新配置，已提交任务保留原配置。'
+            : '能力已开放。同事可自然地提出这类请求；参数不完整时机器人会追问。')
         } catch (error) { setMessage(error.message) }
         finally { setBusy(false) }
       }
@@ -910,6 +993,7 @@ window.__ModuleLoader__.load({
         finally { setBusy(false) }
       }
       const copyCardToDraft = (card) => {
+        setEditingCardId(null); setEditingExpiresAt(null)
         const cardBot = bots.find((bot) => bot.fingerprint === card.bot_fingerprint)
         const cardEnrollment = enrolled.find((bot) => bot.bot_fingerprint === card.bot_fingerprint)
         const titleChars = Array.from(`复制：${card.title || '未命名能力'}`)
@@ -921,6 +1005,7 @@ window.__ModuleLoader__.load({
         setExamples(Array.isArray(card.examples) ? card.examples.join('\n') : '')
         setTaskPrompt(card.task_prompt || '')
         setRunner(['dsh', 'codex', 'claude-code'].includes(card.runner) ? card.runner : 'dsh')
+        setReviewers(Array.isArray(card.reviewers) && card.reviewers.length ? card.reviewers : [card.runner || 'dsh'])
         setParameters(Array.isArray(card.parameters) ? card.parameters.map((rule) => ({
           ...rule, min: String(rule.min ?? ''), max: String(rule.max ?? ''), choices: Array.isArray(rule.choices) ? rule.choices.join(',') : String(rule.choices ?? ''),
         })) : [])
@@ -1067,8 +1152,6 @@ window.__ModuleLoader__.load({
             ? `群 ${groups.find((group) => group.group_id === card.conversation_id)?.group_code || card.conversation_id}` : '私聊'
           const requester = card.sender_scope === 'allowlist' ? '指定成员可请求'
             : card.conversation_kind === 'group' ? '群成员可请求' : '可私聊者可请求'
-          const runnerName = card.runner === 'codex' ? '本机 Codex · PR 快照'
-            : card.runner === 'claude-code' ? '本机 Claude Code · PR 快照' : 'DSH 文字处理'
           const parametersText = (card.parameters || []).map((rule) => {
             const constraint = rule.kind === 'gitea_pr' && rule.repository ? `仓库 ${rule.repository}`
               : rule.kind === 'choice' ? `选项 ${(rule.choices || []).join('、')}`
@@ -1087,7 +1170,7 @@ window.__ModuleLoader__.load({
               h('strong', { style: { overflowWrap: 'anywhere' } }, card.title || '未命名能力'),
               h('span', { style: { ...mutedTextStyle, padding: '2px 8px', borderRadius: 999,
                 backgroundColor: 'var(--dsw-alias-bg-layer-2)', color: remainingDaysLabel, whiteSpace: 'nowrap' } }, expiry)),
-            h('span', { style: mutedTextStyle }, `${runnerName} · ${conversation} · ${requester} · 结果回复原${card.conversation_kind === 'group' ? '群' : '私聊'}`),
+          h('span', { style: mutedTextStyle }, `${cardReviewerSummary(card)} · ${conversation} · ${requester} · 结果回复原${card.conversation_kind === 'group' ? '群' : '私聊'}`),
             h('details', null,
               h('summary', { style: { cursor: 'pointer', color: 'var(--dsw-alias-link)', fontSize: 13 } }, '查看配置'),
               h('div', { style: { display: 'grid', gap: 4, paddingTop: 6 } },
@@ -1098,6 +1181,7 @@ window.__ModuleLoader__.load({
                 examplesText ? h('p', { style: mutedTextStyle }, `请求示例：${examplesText}`) : null,
                 card.task_prompt ? h('p', { style: mutedTextStyle }, `处理要求：${card.task_prompt}`) : null))),
           h('div', { style: { display: 'flex', gap: 6, flexWrap: 'wrap', justifyContent: 'flex-end' } },
+            h('button', { type: 'button', disabled: busy, onClick: () => editCard(card), style: secondaryButtonStyle }, '编辑'),
             h('button', { type: 'button', disabled: busy, onClick: () => copyCardToDraft(card), style: secondaryButtonStyle }, '复制'),
             h('button', { type: 'button', disabled: busy, onClick: () => void revokeCard(card), style: secondaryButtonStyle }, '停止')))
         }),
@@ -1133,10 +1217,12 @@ window.__ModuleLoader__.load({
         h('details', { id: 'ant-new-task', open: createOpen,
           onToggle: (event) => setCreateOpen(event.currentTarget.open),
           style: { border: '1px solid var(--dsw-alias-border-l2)', borderRadius: 8, padding: 12 } },
-          h('summary', { id: 'ant-new-task-summary', style: { cursor: 'pointer', fontWeight: 600 } }, '开放一项能力'),
+          h('summary', { id: 'ant-new-task-summary', style: { cursor: 'pointer', fontWeight: 600 } }, editingCardId ? '编辑能力配置' : '开放一项能力'),
         h('div', { style: { display: 'grid', gridTemplateColumns: 'repeat(auto-fit, minmax(min(100%, 320px), 1fr))',
           gap: 16, alignItems: 'start', marginTop: 12 } },
         h('form', { id: 'ant-capability-create-form', onSubmit: createCard, style: { display: 'grid', gap: 9, minWidth: 0 } },
+          editingCardId ? h('p', { role: 'status', style: mutedTextStyle },
+            `保存会生成新的授权版本并停止旧版本；到期时间保持不变：${new Date(editingExpiresAt * 1000).toLocaleString('zh-CN')}。已提交任务继续使用原配置。`) : null,
           h('p', { style: mutedTextStyle }, selectedBot
             ? `当前机器人：${selectedBot.name}${selectedEnrollmentBound ? ' · 已绑定此设备' : ' · 请先绑定到此设备'}`
             : '请先在上方选择机器人并启用协作。'),
@@ -1156,20 +1242,29 @@ window.__ModuleLoader__.load({
             onChange: (event) => setExamples(event.target.value), placeholder: '帮我总结一下刚才的讨论', style: inputStyle })),
           h('label', null, '处理要求', h('textarea', { required: true, maxLength: 4000, rows: 3, value: taskPrompt,
             onChange: (event) => setTaskPrompt(event.target.value), placeholder: '只使用当前会话可见的内容，列出结论和待办', style: inputStyle })),
-          h('label', null, '执行方', h('select', { value: runner,
-            onChange: (event) => setRunner(event.target.value), style: inputStyle },
-            h('option', { value: 'dsh' }, 'DSH · 已提供文字'),
-            h('option', { value: 'codex',
-              disabled: !codexAvailable }, 'Codex · 单个 Gitea PR 完整快照审查试用'),
-            h('option', { value: 'claude-code', disabled: !claudeCodeAvailable },
-              'Claude Code · 单个 Gitea PR 完整快照试用'))),
+          h('fieldset', { style: { ...panelStyle, padding: 10, display: 'grid', gap: 7 } },
+            h('legend', null, '审查 Agent（可多选）'),
+            h('p', { style: mutedTextStyle }, '普通请求使用默认 Agent；明确说“交叉 review”时，所有勾选项会并行审查同一份 PR 快照（至少勾选两位才构成交叉审查，最多三位，并会同时消耗各自的本机或团队模型额度）。'),
+            h('div', { style: { display: 'flex', gap: 14, flexWrap: 'wrap' } },
+              h('label', null, h('input', { type: 'checkbox', 'aria-label': '审查 Agent DSH', checked: reviewers.includes('dsh'), disabled: !dshAvailable && !reviewers.includes('dsh'),
+                onChange: (event) => changeReviewer('dsh', event.target.checked) }), ' DSH · 仅审查已提供的 diff'),
+              h('label', null, h('input', { type: 'checkbox', 'aria-label': '审查 Agent Codex', checked: reviewers.includes('codex'),
+                disabled: (!codexAvailable || !hasPrParameter) && !reviewers.includes('codex'),
+                onChange: (event) => changeReviewer('codex', event.target.checked) }), ' Codex · 完整快照只读审查'),
+              h('label', null, h('input', { type: 'checkbox', 'aria-label': '审查 Agent Claude Code', checked: reviewers.includes('claude-code'),
+                disabled: (!claudeCodeAvailable || !hasPrParameter) && !reviewers.includes('claude-code'),
+                onChange: (event) => changeReviewer('claude-code', event.target.checked) }), ' Claude Code · 使用本机权限审查')),
+            !hasPrParameter ? h('p', { style: mutedTextStyle }, 'Codex 与 Claude Code 需要先添加一个必填的 Gitea PR 编号参数。') : null,
+            reviewers.length > 1 ? h('label', null, '普通请求默认执行方', h('select', { value: runner,
+              onChange: (event) => setRunner(event.target.value), style: inputStyle },
+              ...reviewers.map((item) => h('option', { key: item, value: item }, reviewerLabel(item))))) : null),
           nativePrUnavailableReason ? h('p', { role: 'status', style: mutedTextStyle },
             `${nativePrUnavailableReason}，已禁用 Codex/Claude Code 完整快照选项；可选择 DSH 差异审查。`) : null,
-          runner === 'codex' ? h('p', { role: 'status', style: mutedTextStyle },
-            'Codex 使用这台电脑的登录账号及其用量；ANT 为每项能力维护仓库缓存，每次审查创建固定到 PR Head 的临时代码快照。不会收到 Gitea 令牌；请以这台 DSH 的实际子代理权限为准，只有强制只读隔离已验证时才视为只读。Git LFS 实际文件不会下载。') : null,
-          runner === 'claude-code' ? h('p', { role: 'status', style: mutedTextStyle },
-            'Claude Code 通过 DSH 已注册的子代理运行，可查看本次 PR 的临时代码快照。ANT 不会传 Gitea 令牌；Claude Code 沿用 DSH 提供方的本机权限，不具备 Codex 路径相同的固定只读隔离。Git LFS 实际文件不会下载。') : null,
-          selectedRunnerNeedsPr ? h('p', { role: 'status', style: mutedTextStyle },
+          reviewers.includes('codex') ? h('p', { role: 'status', style: mutedTextStyle },
+            'Codex 使用这台电脑的登录账号及其用量；ANT 为每项能力维护仓库缓存，每次审查创建固定到 PR Head 的临时代码快照。不会收到 Gitea 令牌；Git LFS 实际文件不会下载。') : null,
+          reviewers.includes('claude-code') ? h('p', { role: 'status', style: mutedTextStyle },
+            'Claude Code 通过 DSH 已注册的子代理运行，可查看同一 PR 快照。ANT 不会传 Gitea 令牌；它沿用 DSH 的本机权限设置，不具备 Codex 路径相同的固定只读隔离。Git LFS 实际文件不会下载。') : null,
+          nativeReviewerSelected ? h('p', { role: 'status', style: mutedTextStyle },
             '本机 PR 执行方需要 Gitea granular token 的只读权限 read:repository 和 read:user；read:user 仅用于这台 DSH 获取 Git HTTPS 登录名。') : null,
           h('details', { style: { border: '1px solid var(--dsw-alias-border-l2)', borderRadius: 8, padding: 10 } },
             h('summary', { style: { cursor: 'pointer' } }, '参数与授权范围'),
@@ -1186,7 +1281,7 @@ window.__ModuleLoader__.load({
               onChange: (event) => updateParameter(index, { kind: event.target.value }), style: { ...inputStyle, flex: '1 1 150px' } },
               h('option', { value: 'text' }, '文本'), h('option', { value: 'integer' }, '整数'),
               h('option', { value: 'choice' }, '选项'), h('option', { value: 'gitea_pr' }, 'Gitea PR 编号')),
-            h('label', null, h('input', { type: 'checkbox', checked: rule.required, 'aria-label': '参数必填',
+            h('label', null, h('input', { type: 'checkbox', 'aria-label': '参数必填', checked: rule.required,
               onChange: (event) => updateParameter(index, { required: event.target.checked }) }), ' 必填'),
             ['integer', 'gitea_pr'].includes(rule.kind) ? h('input', { 'aria-label': '最小值', type: 'number', value: rule.min,
               onChange: (event) => updateParameter(index, { min: event.target.value }), placeholder: '最小值', style: { ...inputStyle, width: 120 } }) : null,
@@ -1225,8 +1320,9 @@ window.__ModuleLoader__.load({
             h('option', { value: 'allowlist' }, '指定 IM 用户 ID'))),
           senderScope === 'allowlist' ? h('input', { 'aria-label': '可请求的 IM 用户 ID', required: true, value: senderIds,
             onChange: (event) => setSenderIds(event.target.value), placeholder: '多个 ID 用逗号分隔', style: inputStyle }) : null,
-          h('label', null, '有效期', h('select', { value: days, onChange: (event) => setDays(Number(event.target.value)), style: inputStyle },
-            h('option', { value: 1 }, '1 天'), h('option', { value: 7 }, '7 天'), h('option', { value: 30 }, '30 天')))),
+          editingCardId ? h('p', { style: mutedTextStyle }, `有效期：${new Date(editingExpiresAt * 1000).toLocaleString('zh-CN')}（编辑时保持不变）`)
+            : h('label', null, '有效期', h('select', { value: days, onChange: (event) => setDays(Number(event.target.value)), style: inputStyle },
+              h('option', { value: 1 }, '1 天'), h('option', { value: 7 }, '7 天'), h('option', { value: 30 }, '30 天')))),
         ),
         h('aside', { id: 'ant-authorization-review', role: 'region', 'aria-label': '开放前复核', tabIndex: -1,
           style: { ...settingsPanelStyle, padding: 14, gap: 10,
@@ -1242,7 +1338,7 @@ window.__ModuleLoader__.load({
               ['可请求人', requesterSummary],
               ['执行方', executorSummary],
               ['读取资料', resourceSummary],
-              ['有效期', `${days} 天`],
+              ['有效期', editingCardId ? new Date(editingExpiresAt * 1000).toLocaleString('zh-CN') : `${days} 天`],
               ['回复位置', resultRouteSummary],
             ].map(([label, value]) => h('div', { key: label, style: { display: 'grid', gridTemplateColumns: '84px minmax(0, 1fr)', gap: 8 } },
               h('dt', { style: mutedTextStyle }, label),
@@ -1250,7 +1346,7 @@ window.__ModuleLoader__.load({
           cardBlockReason ? h('p', { role: 'status', style: { ...mutedTextStyle,
             color: 'var(--dsw-alias-state-warning-primary, var(--dsw-alias-label-secondary))' } }, cardBlockReason) : null,
           h('button', { type: 'submit', form: 'ant-capability-create-form', disabled: busy || Boolean(cardBlockReason),
-            style: { ...primaryButtonStyle, width: '100%' } }, '确认并开放能力'))))),
+            style: { ...primaryButtonStyle, width: '100%' } }, editingCardId ? '保存能力修改' : '确认并开放能力'))))),
         h('div', { role: 'region', 'aria-label': '本机处理设置', style: { display: activeTab === 'local' ? 'grid' : 'none', gap: 12 } },
         h('section', { style: { ...settingsPanelStyle, padding: 14 } },
           h('strong', null, 'Gitea 本机凭据'),
@@ -1816,6 +1912,11 @@ window.__ModuleLoader__.load({
       const [bundleRelease, setBundleRelease] = useState(null)
       const [bundleUpdate, setBundleUpdate] = useState({ state: 'idle', currentVersion: '', message: '' })
       const [authorizedModels, setAuthorizedModels] = useState([])
+      const [serverDefaultModel, setServerDefaultModel] = useState(null)
+      const [dshDefaultSelection, setDshDefaultSelection] = useState(null)
+      const [defaultModelDraft, setDefaultModelDraft] = useState('')
+      const [defaultModelBusy, setDefaultModelBusy] = useState(false)
+      const [defaultModelMessage, setDefaultModelMessage] = useState('')
       const [lastModelSync, setLastModelSync] = useState(null)
       const [serviceCompatibility, setServiceCompatibility] = useState({ state: 'idle', message: '' })
       const [pinnedServiceUrl, setPinnedServiceUrl] = useState(null)
@@ -1889,37 +1990,182 @@ window.__ModuleLoader__.load({
         return status
       }
 
-      const applyAuthorizedModels = async (models, rawServiceUrl) => {
+      const modelProvider = (model) => model.protocol === 'anthropic'
+        ? model.provider_id === 'anthropic-default' || !model.provider_id ? 'ant-team-anthropic' : `ant-team-anthropic-${model.provider_id}`
+        : model.provider_id === 'openai-default' || !model.provider_id
+          ? model.openai_api_mode === 'responses' ? 'ant-team-openai-responses' : 'ant-team-openai-chat-completions'
+          : `ant-team-openai-${model.provider_id}`
+      const modelSelectionKey = (model) => JSON.stringify({ provider_id: model.provider_id || '', protocol: model.protocol, model_id: model.model_id })
+      const defaultPreferenceKey = (rawServiceUrl) => `${DEFAULT_MODEL_INITIALIZED_KEY}:${normalizeServiceUrl(rawServiceUrl)}:${savedDeviceId() || ''}`
+      const readDefaultPreference = (rawServiceUrl) => {
+        try { return JSON.parse(localStorage.getItem(defaultPreferenceKey(rawServiceUrl)) || 'null') } catch { return null }
+      }
+      const saveDefaultPreference = (rawServiceUrl, value) => {
+        try { localStorage.setItem(defaultPreferenceKey(rawServiceUrl), JSON.stringify(value)) } catch {}
+      }
+      const modelForProviderSelection = (selection, models) => {
+        if (!selection) return null
+        const exact = models.find((model) => model.model_id === selection.model && modelProvider(model) === selection.provider)
+        if (exact) return exact
+        const legacyProvider = ['ant-team-openai', 'ant-team-openai-chat-completions', 'ant-team-openai-responses'].includes(selection.provider)
+          ? 'openai-default' : selection.provider === 'ant-team-anthropic' ? 'anthropic-default' : null
+        return legacyProvider ? models.find((model) => model.provider_id === legacyProvider && model.model_id === selection.model) : null
+      }
+      const readDshDefaultSelection = async () => {
+        if (typeof remote?.settings?.describe !== 'function') throw new Error('当前 DSH 未提供全局默认模型读取接口。')
+        const response = await remote.settings.describe()
+        if (!response?.ok) throw new Error(response?.error?.message || '无法读取这台 DSH 的全局默认模型。')
+        const value = response.value?.namespaces?.find((entry) => entry.ns === 'agent-default-model')?.value
+        return value && typeof value.provider === 'string' && typeof value.model === 'string'
+          ? { provider: value.provider, model: value.model,
+            ...(typeof value.reasoningEffort === 'string' ? { reasoningEffort: value.reasoningEffort } : {}) } : null
+      }
+      const writeDshDefaultModel = async (model) => {
+        const response = await remote.settings.mutate('agent-default-model', [
+          { op: 'set', path: ['provider'], value: modelProvider(model) },
+          { op: 'set', path: ['model'], value: model.model_id },
+          { op: 'unset', path: ['reasoningEffort'] },
+        ], undefined)
+        if (!response?.ok) throw new Error(response?.error?.message || 'DSH 无法保存全局默认模型。')
+        const selection = { provider: modelProvider(model), model: model.model_id }
+        setDshDefaultSelection(selection)
+        setDefaultModelDraft(modelSelectionKey(model))
+        return selection
+      }
+      const applyUserDefaultModel = async (model) => {
+        if (!model || !authorizedModels.some((item) => modelSelectionKey(item) === modelSelectionKey(model))) {
+          setDefaultModelMessage('请选择当前已获准的模型。')
+          return
+        }
+        setDefaultModelBusy(true)
+        try {
+          const selection = await writeDshDefaultModel(model)
+          const preference = readDefaultPreference(serviceUrl) || { initialized: true, serverDefault: '' }
+          const isServerDefault = serverDefaultModel && modelSelectionKey(model) === modelSelectionKey(serverDefaultModel)
+          if (isServerDefault) preference.serverDefault = modelSelectionKey(serverDefaultModel)
+          preference.initialized = true
+          saveDefaultPreference(serviceUrl, preference)
+          setDshDefaultSelection(selection)
+          setDefaultModelMessage(`已将 ${model.display_name || model.model_id} 设为 DSH 全局默认模型。`)
+        } catch (error) {
+          setDefaultModelMessage(error instanceof Error ? error.message : '保存本机默认模型失败。')
+        } finally { setDefaultModelBusy(false) }
+      }
+      const applyAuthorizedModels = async (models, rawServiceUrl, rawDefaultModel = null) => {
         const normalized = normalizeServiceUrl(rawServiceUrl)
         if (!normalized || !Array.isArray(models)) throw new Error('ANT 返回的团队模型目录格式无效。')
         if (typeof remote?.settings?.mutate !== 'function') throw new Error('当前 DSH 版本未提供模型设置接口。')
-        const grouped = {
-          openai: models.filter((model) => model.protocol === 'openai'),
-          anthropic: models.filter((model) => model.protocol === 'anthropic'),
+        const grouped = new Map()
+        for (const model of models) {
+          const protocol = model.protocol
+          if (!['openai', 'anthropic'].includes(protocol)) continue
+          const providerId = model.provider_id || (protocol === 'openai' ? 'openai-default' : 'anthropic-default')
+          const key = `${providerId}\u0000${protocol}`
+          let provider = grouped.get(key)
+          if (!provider) {
+            provider = {
+              providerId,
+              providerName: model.provider_name || (protocol === 'openai'
+                ? `ANT 团队 · OpenAI · ${model.openai_api_mode === 'responses' ? 'Responses' : 'Chat Completions'}`
+                : 'ANT 团队 · Anthropic'),
+              protocol,
+              apiMode: model.openai_api_mode === 'responses' ? 'responses' : 'chat_completions',
+              legacyEndpoint: typeof model.provider_id !== 'string' || !model.provider_id,
+              models: [],
+            }
+            grouped.set(key, provider)
+          }
+          provider.models.push(model)
         }
+        const providers = [...grouped.values()]
+        const routeForProvider = (provider) => provider.providerId === 'openai-default'
+          ? provider.apiMode === 'responses' ? 'ant-team-openai-responses' : 'ant-team-openai-chat-completions'
+          : provider.providerId === 'anthropic-default'
+            ? 'ant-team-anthropic' : `ant-team-${provider.protocol}-${provider.providerId}`
+        const routes = providers.map(routeForProvider)
         const ops = []
-        for (const protocol of ['openai', 'anthropic']) {
-          const route = protocol === 'openai' ? 'ant-team-openai' : 'ant-team-anthropic'
-          const protocolModels = grouped[protocol]
-          if (protocolModels.length === 0) {
-            ops.push({ op: 'unset', path: ['providers', route] })
-            continue
-          }
+        let previousRoutes = []
+        try {
+          const parsed = JSON.parse(localStorage.getItem(PROVIDER_ROUTES_STORAGE_KEY) || '[]')
+          if (Array.isArray(parsed)) previousRoutes = parsed.filter((route) => typeof route === 'string')
+        } catch {}
+        const knownRoutes = new Set([...previousRoutes, 'ant-team-openai', 'ant-team-openai-chat-completions',
+          'ant-team-openai-responses', 'ant-team-anthropic'])
+        for (const route of knownRoutes) {
+          if (!routes.includes(route)) ops.push({ op: 'unset', path: ['providers', route] })
+        }
+        for (const provider of providers) {
+          const route = routeForProvider(provider)
+          const api = provider.protocol === 'openai'
+            ? provider.apiMode === 'responses' ? 'openai-responses' : 'openai-completions'
+            : 'anthropic-messages'
+          const baseURL = provider.legacyEndpoint
+            ? new URL(provider.protocol === 'openai' ? '/model-gateway/openai/v1' : '/model-gateway/anthropic', normalized).toString()
+            : provider.protocol === 'openai'
+              ? new URL(`/model-gateway/openai/providers/${encodeURIComponent(provider.providerId)}/v1`, normalized).toString()
+              : new URL(`/model-gateway/anthropic/providers/${encodeURIComponent(provider.providerId)}`, normalized).toString()
           ops.push({ op: 'set', path: ['providers', route], value: {
-            displayName: protocol === 'openai' ? 'Lakala (OpenAI)' : 'Lakala (Anthropic)',
+            displayName: provider.providerName,
             apiKeyEnv: 'ANT_MODEL_API_KEY',
-            api: protocol === 'openai' ? 'openai-completions' : 'anthropic-messages',
-            baseURL: protocol === 'openai'
-              ? new URL('/model-gateway/openai/v1', normalized).toString()
-              : new URL('/model-gateway/anthropic', normalized).toString(),
-            models: protocolModels.map((model) => ({ id: model.model_id, name: model.display_name })),
+            api,
+            baseURL,
+            models: provider.models.map((model) => ({ id: model.model_id, name: model.display_name })),
           } })
         }
         const settingsWrite = await remote.settings.mutate('llm-pi-ai', ops, undefined)
         if (!settingsWrite.ok) throw new Error(settingsWrite.error?.message || 'DSH 无法更新团队模型设置。')
+        try { localStorage.setItem(PROVIDER_ROUTES_STORAGE_KEY, JSON.stringify(routes)) } catch {}
+        const defaultMatch = rawDefaultModel && models.find((model) =>
+          (rawDefaultModel.provider_id ? model.provider_id === rawDefaultModel.provider_id : model.protocol === rawDefaultModel.protocol)
+          && model.protocol === rawDefaultModel.protocol && model.model_id === rawDefaultModel.model_id)
+        const serverDefault = defaultMatch || null
+        const initialDefault = defaultMatch || (rawDefaultModel == null ? models[0] : null)
+        setServerDefaultModel(serverDefault)
+        const preference = readDefaultPreference(normalized)
+        let statusMessage = ''
+        let selection
+        if (!preference?.initialized && initialDefault) {
+          const previousDefault = await readDshDefaultSelection()
+          selection = await writeDshDefaultModel(initialDefault)
+          saveDefaultPreference(normalized, { initialized: true, serverDefault: modelSelectionKey(serverDefault || initialDefault), previousDefault })
+          statusMessage = serverDefault
+            ? '已按团队默认模型设置 DSH 全局默认。该 Profile 的新会话会使用此模型；你之后可在此更改，刷新不会覆盖选择。'
+            : '当前无法使用团队默认模型；已用首个获准模型初始化 DSH 全局默认。请管理员检查默认设置和成员授权。'
+        } else {
+          selection = await readDshDefaultSelection()
+          const currentAuthorized = modelForProviderSelection(selection, models)
+          const baseline = models.find((model) => modelSelectionKey(model) === preference?.serverDefault)
+          const stillUsingBaseline = baseline && currentAuthorized && modelSelectionKey(currentAuthorized) === modelSelectionKey(baseline)
+          if (currentAuthorized && selection?.provider !== modelProvider(currentAuthorized)) {
+            selection = await writeDshDefaultModel(currentAuthorized)
+          }
+          if (serverDefault && stillUsingBaseline && modelSelectionKey(serverDefault) !== preference.serverDefault) {
+            selection = await writeDshDefaultModel(serverDefault)
+            saveDefaultPreference(normalized, { ...preference, initialized: true, serverDefault: modelSelectionKey(serverDefault) })
+            statusMessage = '团队默认模型已更新；你尚未设置个人覆盖，因此已同步到 DSH 全局默认。'
+          } else if (selection?.provider?.startsWith('ant-team-') && !currentAuthorized && models.length) {
+            const fallback = serverDefault || models[0]
+            selection = await writeDshDefaultModel(fallback)
+            saveDefaultPreference(normalized, { ...preference, initialized: true,
+              serverDefault: modelSelectionKey(serverDefault || fallback) })
+            statusMessage = serverDefault
+              ? '当前默认模型已失去授权，已恢复为团队默认模型。'
+              : '当前默认模型已失去授权，已改用首个获准模型；请管理员设置团队默认模型。'
+          }
+          const effectiveAuthorized = modelForProviderSelection(selection, models)
+          setDshDefaultSelection(selection)
+          setDefaultModelDraft(effectiveAuthorized ? modelSelectionKey(effectiveAuthorized) : '')
+          if (!serverDefault && !statusMessage) statusMessage = rawDefaultModel
+            ? '团队默认模型不在这台设备的获准范围内；请联系管理员调整模型权限。'
+            : '团队默认模型尚未设置；请联系管理员设置，或在下方选择本机可用的默认模型。'
+          else if (!statusMessage) statusMessage = effectiveAuthorized
+            ? '已保留你选择的 DSH 全局默认模型。'
+            : '当前 DSH 默认不属于 ANT 获准模型；ANT 对话和任务会使用服务端默认模型。'
+        }
+        setDefaultModelMessage(statusMessage)
         try { localStorage.setItem(SERVICE_URL_STORAGE_KEY, normalized) } catch {}
         onServiceUrlChange(normalized)
-        return models.length
+        return { count: models.length, defaultSelection: selection }
       }
 
       const refreshModels = async () => {
@@ -1931,19 +2177,21 @@ window.__ModuleLoader__.load({
         setModelMessage('正在从 ANT 刷新获准模型…')
         try {
           await requireCompatibleService(serviceUrl, true)
-          const response = await fetch('/api/ant-teams/models', { method: 'POST' })
+          const response = await fetch('/api/ant-teams/models', {
+            method: 'POST', headers: { 'x-ant-model-provider-config': '1' },
+          })
           const result = await readLocalJsonResponse(response)
           if (!response.ok) {
             if (response.status === 401) setNeedsReconnect(true)
             throw new Error(result.message || `刷新失败（${response.status}）`)
           }
-          const count = await applyAuthorizedModels(result.models, result.service_url)
+          const sync = await applyAuthorizedModels(result.models, result.service_url, result.default_model)
           setAuthorizedModels(result.models)
           setLastModelSync(new Date())
           setCredentialConfigured(true)
           setNeedsReconnect(false)
           setReauthenticate(false)
-          setModelMessage(`模型目录已刷新，共 ${count} 个获准模型。`)
+          setModelMessage(`模型目录已刷新，共 ${sync.count} 个获准模型。`)
         } catch (error) {
           setModelMessage(error instanceof Error ? error.message : '刷新模型失败，请稍后重试。')
         } finally {
@@ -2097,15 +2345,55 @@ window.__ModuleLoader__.load({
 
       const clearLocalConnection = async () => {
         if (typeof remote?.settings?.mutate !== 'function') throw new Error('DSH 未提供模型设置接口。')
-        const settingsResult = await remote.settings.mutate('llm-pi-ai', [
-          { op: 'unset', path: ['providers', 'ant-team-openai'] },
-          { op: 'unset', path: ['providers', 'ant-team-anthropic'] },
-        ], undefined)
+        const selection = await readDshDefaultSelection()
+        if (selection?.provider?.startsWith('ant-team-')) {
+          const previous = readDefaultPreference(serviceUrl)?.previousDefault
+          const restore = previous && typeof previous.provider === 'string' && typeof previous.model === 'string'
+            && !previous.provider.startsWith('ant-team-')
+          const operations = restore
+            ? [
+              { op: 'set', path: ['provider'], value: previous.provider },
+              { op: 'set', path: ['model'], value: previous.model },
+              previous.reasoningEffort
+                ? { op: 'set', path: ['reasoningEffort'], value: previous.reasoningEffort }
+                : { op: 'unset', path: ['reasoningEffort'] },
+            ]
+            : [
+              { op: 'unset', path: ['provider'] },
+              { op: 'unset', path: ['model'] },
+              { op: 'unset', path: ['reasoningEffort'] },
+            ]
+          const reset = await remote.settings.mutate('agent-default-model', [
+            ...operations,
+          ], undefined)
+          if (!reset.ok) throw new Error(reset.error?.message || 'DSH 全局默认模型未能恢复。')
+        }
+        let managedRoutes = []
+        try {
+          const parsed = JSON.parse(localStorage.getItem(PROVIDER_ROUTES_STORAGE_KEY) || '[]')
+          if (Array.isArray(parsed)) managedRoutes = parsed.filter((route) => typeof route === 'string')
+        } catch {}
+        if (typeof remote?.settings?.describe === 'function') {
+          const described = await remote.settings.describe()
+          if (!described?.ok) throw new Error(described?.error?.message || '无法读取 DSH 中的 ANT 提供方列表。')
+          const providers = described.value?.namespaces?.find((item) => item.ns === 'llm-pi-ai')?.value?.providers
+          for (const [route, provider] of Object.entries(providers || {})) {
+            if (route.startsWith('ant-team-') && provider?.apiKeyEnv === 'ANT_MODEL_API_KEY') managedRoutes.push(route)
+          }
+        }
+        const routes = new Set([...managedRoutes, 'ant-team-openai-chat-completions', 'ant-team-openai-responses',
+          'ant-team-openai', 'ant-team-anthropic'])
+        const settingsResult = await remote.settings.mutate('llm-pi-ai', [...routes].map((route) => ({
+          op: 'unset', path: ['providers', route],
+        })), undefined)
         if (!settingsResult.ok) throw new Error(settingsResult.error?.message || 'ANT 模型设置未能清除。')
+        try { localStorage.removeItem(PROVIDER_ROUTES_STORAGE_KEY) } catch {}
         if (typeof remote?.credentials?.unset !== 'function') throw new Error('DSH 未提供凭证删除接口。')
         const credentialResult = await remote.credentials.unset('ANT_MODEL_API_KEY')
         if (!credentialResult.ok) throw new Error(credentialResult.error?.message || 'ANT 成员凭证未能清除。')
         setCredentialConfigured(false)
+        setAuthorizedModels([]); setServerDefaultModel(null); setDshDefaultSelection(null); setDefaultModelDraft('')
+        try { localStorage.removeItem(`${DEFAULT_MODEL_INITIALIZED_KEY}:${normalizeServiceUrl(serviceUrl)}:${savedDeviceId() || ''}`) } catch {}
         onConnectionChange?.(null)
         setNeedsReconnect(false)
         setReauthenticate(false)
@@ -2266,7 +2554,7 @@ window.__ModuleLoader__.load({
           localStorage.setItem(SERVICE_URL_STORAGE_KEY, normalized)
           const response = await fetch('/api/ant-teams/connect', {
             method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
+            headers: { 'Content-Type': 'application/json', 'x-ant-model-provider-config': '1' },
             body: JSON.stringify({
               service_url: normalized,
               email: normalizedEmail,
@@ -2285,7 +2573,7 @@ window.__ModuleLoader__.load({
           const credentialWrite = await remote.credentials.set('ANT_MODEL_API_KEY', result.token)
           if (!credentialWrite.ok) throw new Error(credentialWrite.error?.message || 'DSH 无法安全保存 ANT 凭证。')
           credentialSaved = true
-          await applyAuthorizedModels(result.models, normalized)
+          await applyAuthorizedModels(result.models, normalized, result.default_model)
           setAuthorizedModels(result.models)
           setLastModelSync(new Date())
           setCode('')
@@ -2316,13 +2604,14 @@ window.__ModuleLoader__.load({
       const canCheckUpdate = bindingReady && credentialConfigured === true && !needsReconnect
       const updateGuideUrl = pinnedServiceUrl
         ? new URL('/ant-update', pinnedServiceUrl).href : null
-      const modelRows = authorizedModels.map((model) => h('div', { key: `${model.protocol}:${model.model_id}`, role: 'listitem',
+      const currentDshDefaultModel = modelForProviderSelection(dshDefaultSelection, authorizedModels)
+      const modelRows = authorizedModels.map((model) => h('div', { key: `${model.provider_id || ''}:${model.protocol}:${model.model_id}`, role: 'listitem',
         style: { display: 'grid', gridTemplateColumns: 'minmax(0, 1fr) minmax(120px, auto) minmax(130px, auto)',
           gap: 12, alignItems: 'center', padding: '10px 2px', borderBottom: '1px solid var(--dsw-alias-border-l2)' } },
-        h('strong', { style: { minWidth: 0, overflowWrap: 'anywhere' } }, model.display_name || model.model_id),
+        h('strong', { style: { minWidth: 0, overflowWrap: 'anywhere' } }, `${model.provider_name ? `${model.provider_name} · ` : ''}${model.display_name || model.model_id}`),
         h('span', { style: { display: 'inline-flex', justifySelf: 'start', padding: '3px 8px', borderRadius: 999,
           backgroundColor: 'var(--dsw-alias-bg-layer-2)', color: 'var(--dsw-alias-label-secondary)', fontSize: 12 } },
-        `${model.protocol === 'anthropic' ? 'Anthropic' : 'OpenAI'} 协议`),
+        model.protocol === 'anthropic' ? 'Anthropic Messages' : `OpenAI · ${model.openai_api_mode === 'responses' ? 'Responses' : 'Chat Completions'}`),
         h('span', { style: { ...mutedTextStyle, textAlign: 'right' } }, '已同步到 DSH')))
       const connectionPanel = h('section', { style: { ...settingsPanelStyle, display: activeTab === 'connection' ? 'grid' : 'none' } },
         h('div', null,
@@ -2386,6 +2675,29 @@ window.__ModuleLoader__.load({
             backgroundColor: credentialConfigured === true && bindingReady ? 'var(--dsw-alias-state-success-tertiary)' : 'var(--dsw-alias-bg-layer-2)',
             fontSize: 12,
           } }, credentialConfigured === true ? bindingReady ? '已连接' : '待核对' : credentialConfigured === false ? '未连接' : '检查中')),
+        h('section', { style: { ...infoNoticeStyle, gap: 8 } },
+          h('div', { style: { display: 'flex', justifyContent: 'space-between', gap: 10, flexWrap: 'wrap', alignItems: 'center' } },
+            h('strong', null, 'ANT 默认模型'),
+            h('span', { style: mutedTextStyle }, serverDefaultModel
+              ? `团队默认：${serverDefaultModel.display_name || serverDefaultModel.model_id}`
+              : '团队默认尚未设置，或当前成员无权使用')),
+          h('p', { style: mutedTextStyle }, '首次同步时，ANT 会用团队默认初始化 DSH 全局默认模型。它会影响该 Profile 的新会话以及 ANT 对话和任务；之后刷新保留你的个人覆盖。'),
+          h('label', { style: { display: 'grid', gap: 5, maxWidth: 720 } }, 'DSH 全局默认模型',
+            h('select', { 'aria-label': 'DSH 全局默认模型', value: defaultModelDraft,
+              disabled: credentialConfigured !== true || !authorizedModels.length || defaultModelBusy || busy,
+              onChange: (event) => setDefaultModelDraft(event.target.value), style: inputStyle },
+              h('option', { value: '' }, '选择获准模型'),
+              ...authorizedModels.map((model) => h('option', { key: modelSelectionKey(model), value: modelSelectionKey(model) },
+                `${model.provider_name ? `${model.provider_name} · ` : ''}${model.display_name || model.model_id} · ${model.protocol === 'anthropic' ? 'Anthropic' : model.openai_api_mode === 'responses' ? 'OpenAI Responses' : 'OpenAI Chat Completions'}`)))),
+          h('div', { style: { display: 'flex', gap: 8, flexWrap: 'wrap', alignItems: 'center' } },
+            h('button', { type: 'button', disabled: defaultModelBusy || !defaultModelDraft,
+              onClick: () => { const chosen = authorizedModels.find((model) => modelSelectionKey(model) === defaultModelDraft); void applyUserDefaultModel(chosen) },
+              style: primaryButtonStyle }, defaultModelBusy ? '保存中…' : '保存为 DSH 全局默认'),
+            h('button', { type: 'button', disabled: defaultModelBusy || !serverDefaultModel
+              || modelSelectionKey(currentDshDefaultModel || {}) === modelSelectionKey(serverDefaultModel),
+              onClick: () => void applyUserDefaultModel(serverDefaultModel), style: secondaryButtonStyle }, '恢复团队默认'),
+            currentDshDefaultModel ? h('span', { style: mutedTextStyle }, `当前 DSH 默认：${currentDshDefaultModel.display_name || currentDshDefaultModel.model_id}`) : null),
+          defaultModelMessage ? h('p', { role: 'status', style: mutedTextStyle }, defaultModelMessage) : null),
         h('div', { role: 'list', 'aria-label': '获准模型', style: { display: 'grid', gap: 0, borderTop: '1px solid var(--dsw-alias-border-l2)' } },
           modelRows.length ? modelRows : h('div', { style: { display: 'grid', gap: 8, padding: '12px 0' } },
             h('p', { style: mutedTextStyle }, credentialConfigured === true && modelMessage.startsWith('正在') ? modelMessage
@@ -2394,7 +2706,7 @@ window.__ModuleLoader__.load({
             credentialConfigured !== true ? h('button', { type: 'button', onClick: () => onSelectTab('connection'),
               style: secondaryButtonStyle }, '前往团队连接') : null)),
         h('div', { style: { display: 'flex', flexWrap: 'wrap', alignItems: 'center', gap: 10 } },
-          h('button', { type: 'button', disabled: busy || !bindingReady || credentialConfigured !== true,
+          h('button', { type: 'button', disabled: busy || defaultModelBusy || !bindingReady || credentialConfigured !== true,
             onClick: () => void refreshModels(), style: primaryButtonStyle }, busy ? '刷新中…' : '刷新团队模型'),
           lastModelSync ? h('span', { style: mutedTextStyle }, `最近同步：${lastModelSync.toLocaleString('zh-CN')}`) : null),
         modelMessage && !modelMessage.startsWith('正在') ? h('p', { role: 'status', style: mutedTextStyle }, modelMessage) : null)

package/conversation.js

@@ -114,9 +114,9 @@ async function restrictedSession(ctx, model, root, sessionIds, configure = null,
       ? undefined : 'ANT 协作对话不能调用本机工具。')
     disposeTools = configure ? configure(agent, sessionId) : []
     await ctx.sessionController.selectModel({ sessionId,
-      provider: model.protocol === 'anthropic' ? 'ant-team-anthropic' : 'ant-team-openai', model: model.model_id })
+      provider: teamModelProvider(model), model: model.model_id })
     return { sessionId, cwd, disposeTools,
-      modelKey: `${model.protocol}\0${model.model_id}` }
+      modelKey: `${teamModelProvider(model)}\0${model.model_id}` }
   } catch (error) {
     for (const dispose of disposeTools) dispose?.()
     sessionIds.delete(sessionId)
@@ -166,19 +166,56 @@ async function prompt(ctx, sessionId, content, signal) {
   throw new Error('DSH 对话等待超时。')
 }
 
-async function modelFor(memberJson, connection) {
+export function teamModelProvider(model) {
+  if (model.protocol === 'anthropic') {
+    return !model.provider_id || model.provider_id === 'anthropic-default'
+      ? 'ant-team-anthropic' : `ant-team-anthropic-${model.provider_id}`
+  }
+  if (!model.provider_id || model.provider_id === 'openai-default') {
+    return model.openai_api_mode === 'responses' ? 'ant-team-openai-responses' : 'ant-team-openai-chat-completions'
+  }
+  return `ant-team-openai-${model.provider_id}`
+}
+
+function dshDefaultSelection(ctx) {
+  try { return (ctx.agentDefaultModel || ctx.get?.('agentDefaultModel'))?.currentSelection?.() || null }
+  catch { return null }
+}
+
+export async function modelFor(ctx, memberJson, connection) {
   const catalog = await memberJson(connection, '/api/me/models')
-  const model = catalog.models?.find((item) => ['openai', 'anthropic'].includes(item.protocol))
+  const models = catalog.models?.filter((item) => ['openai', 'anthropic'].includes(item.protocol)) || []
+  const selection = dshDefaultSelection(ctx)
+  const localDefault = selection && models.find((item) => item.model_id === selection.model
+    && teamModelProvider(item) === selection.provider)
+  const serverDefault = catalog.default_model && models.find((item) =>
+    (catalog.default_model.provider_id ? item.provider_id === catalog.default_model.provider_id : item.protocol === catalog.default_model.protocol)
+    && item.protocol === catalog.default_model.protocol && item.model_id === catalog.default_model.model_id)
+  const model = localDefault || serverDefault || (!Object.hasOwn(catalog, 'default_model') ? models[0] : null)
+  if (!model && models.length) throw new Error('当前没有可用的 ANT 默认模型；请在插件“团队模型”中选择本机默认，或联系管理员检查授权。')
   if (!model) throw new Error('当前没有可用的团队模型。')
   return model
 }
 
+export function cardReviewers(card) {
+  const selected = Array.isArray(card?.reviewers)
+    ? [...new Set(card.reviewers.filter((runner) => ['dsh', 'codex', 'claude-code'].includes(runner)))] : []
+  return selected.length ? selected : card?.runner ? [card.runner] : []
+}
+
+export function isCrossReviewRequest(text) {
+  const value = (typeof text === 'string' ? text : '').normalize('NFKC').toLowerCase()
+  if (/(?:不要|别|不用|不需要|不做|取消)\s*(?:进行|做)?\s*(?:交叉\s*(?:review|审查|评审)|cross[\s-]*review)/iu.test(value)
+    || /\b(?:do\s+not|don't|without|no\s+need\s+to)\s+cross[\s-]*review\b/iu.test(value)) return false
+  return /(?:交叉\s*(?:review|审查|评审)|cross[\s-]*review)/iu.test(value)
+}
+
 export function hasRequiredCodexReviewPr(card, parameters) {
-  return card?.runner === 'codex' && hasRequiredNativeReviewPr(card, parameters)
+  return cardReviewers(card).includes('codex') && hasRequiredNativeReviewPr(card, parameters)
 }
 
 export function hasRequiredNativeReviewPr(card, parameters) {
-  if (!['codex', 'claude-code'].includes(card?.runner)
+  if (!cardReviewers(card).some((runner) => ['codex', 'claude-code'].includes(runner))
     || !Array.isArray(card.parameters) || card.parameters.length !== 1) return false
   const [rule] = card.parameters
   const value = parameters?.[rule.name]
@@ -328,7 +365,7 @@ function chatGate(maxActive = 4) {
 }
 
 export function createConversationEngine({ ctx, ledger, readConnection, memberJson, fetchPr,
-  preparePrWorkspace, runNativeReview,
+  preparePrWorkspace, runCodexReview = runCodexReadOnly, runNativeReview, runDshReview,
   logger, sessionIds, signal, workspaceRoot, gate }) {
   let settings = { context_messages: 10, history_max_records: 100, max_concurrency: 3 }
   let cardsByFingerprint = new Map()
@@ -430,11 +467,11 @@ export function createConversationEngine({ ctx, ledger, readConnection, memberJs
   async function scopeSession(scope, model) {
     const live = scopeSessions.get(scope)
     if (live) {
-      const modelKey = `${model.protocol}\0${model.model_id}`
+      const modelKey = `${teamModelProvider(model)}\0${model.model_id}`
       if (live.modelKey !== modelKey) {
         try {
           await ctx.sessionController.selectModel({ sessionId: live.sessionId,
-            provider: model.protocol === 'anthropic' ? 'ant-team-anthropic' : 'ant-team-openai',
+            provider: teamModelProvider(model),
             model: model.model_id })
           live.modelKey = modelKey
         } catch (error) {
@@ -457,9 +494,10 @@ export function createConversationEngine({ ctx, ledger, readConnection, memberJs
       }
       try {
         register('ant_capabilities',
-          '查看当前请求人在这段对话里可申请的任务能力。普通聊天无需调用。', {},
+          '查看当前请求人在这段对话里可申请的任务能力。普通聊天无需调用。若能力支持多个审查 Agent，普通请求用默认 Agent；请求人明确提出交叉 review 时调用该能力，由 ANT 并行运行全部已选 Agent。', {},
           withTurn(async (current) => current.cards.map((card) => ({ id: card.id,
             title: card.title, intent: card.intent, examples: card.examples,
+            reviewers: cardReviewers(card), cross_review_enabled: cardReviewers(card).length > 1,
             parameters: card.parameters.map((rule) => ({ name: rule.name, description: rule.description,
               kind: rule.kind, required: rule.required, choices: rule.choices,
               min: rule.min, max: rule.max, repository: rule.repository })) }))));
@@ -757,7 +795,7 @@ export function createConversationEngine({ ctx, ledger, readConnection, memberJs
     let answer = '我暂时没法继续这段对话，请稍后再试。'
     let session = null
     try {
-      const model = await modelFor(memberJson, connection)
+      const model = await modelFor(ctx, memberJson, connection)
       let history
       try { history = await firstHistory(ctx, event, settings, signal) }
       catch (error) {
@@ -830,7 +868,13 @@ export function createConversationEngine({ ctx, ledger, readConnection, memberJs
       const checked = await memberJson(connection, '/api/me/im-delegations/cards/authorize',
         { method: 'POST', body: JSON.stringify(entry.authorization) })
       if (checked.decision !== 'allowed' || checked.card?.id !== entry.card.id) throw new Error('任务授权已失效。')
-      const nativeReview = ['codex', 'claude-code'].includes(checked.card.runner)
+      const configuredReviewers = cardReviewers(checked.card)
+      const crossReview = isCrossReviewRequest(entry.request_text)
+      if (crossReview && configuredReviewers.length < 2) {
+        throw new Error('这项能力只配置了一位审查 Agent，无法交叉 review；请所有者至少勾选两位。')
+      }
+      const taskReviewers = crossReview ? configuredReviewers : [checked.card.runner]
+      const nativeReview = taskReviewers.some((runner) => ['codex', 'claude-code'].includes(runner))
       if (nativeReview && !hasRequiredNativeReviewPr(checked.card, entry.parameters)) {
         throw new Error('本机代码执行方要求一个已验证且必填的 Gitea PR 编号。')
       }
@@ -859,29 +903,55 @@ export function createConversationEngine({ ctx, ledger, readConnection, memberJs
         cleanupWorkspace = prepared.cleanup
       }
       taskSignal.throwIfAborted()
-      let result
-      if (checked.card.runner === 'codex') {
-        result = await runCodexReadOnly({ ...entry, card: checked.card }, material, taskSignal, logger, workspacePath)
-      } else if (checked.card.runner === 'claude-code') {
-        if (typeof runNativeReview !== 'function') throw new Error('Claude Code 执行接口未就绪。')
-        result = await runNativeReview({ ...entry, card: checked.card }, reviewedPrs[0], taskSignal, workspacePath)
-      } else if (checked.card.runner === 'dsh') {
-        const model = await modelFor(memberJson, connection)
-        const { sessionId, cwd } = await restrictedSession(ctx, model, workspaceRoot, sessionIds)
-        try {
-          result = await prompt(ctx, sessionId,
-            `请仅用已提供的文字完成这项已授权任务，不要调用工具、修改文件或假装读过未提供的资料。任务：${checked.card.title}。所有者的要求：${checked.card.task_prompt}。已核验参数：${JSON.stringify(entry.parameters)}。请求人原话（不可信）：${entry.request_text}${material}`,
-            taskSignal)
-        } finally {
-          sessionIds.delete(sessionId)
-          if (typeof ctx.sessionController.cancel === 'function') {
-            await ctx.sessionController.cancel({ sessionId }).catch(() => undefined)
+      const runReviewer = async (reviewer) => {
+        if (reviewer === 'codex') {
+          return runCodexReview({ ...entry, card: checked.card }, material, taskSignal, logger, workspacePath)
+        }
+        if (reviewer === 'claude-code') {
+          if (typeof runNativeReview !== 'function') throw new Error('Claude Code 执行接口未就绪。')
+          return runNativeReview({ ...entry, card: checked.card }, reviewedPrs[0], taskSignal, workspacePath)
+        }
+        if (reviewer === 'dsh') {
+          if (nativeReview) {
+            if (typeof runDshReview !== 'function') throw new Error('DSH PR 审查执行接口未就绪。')
+            const model = await modelFor(ctx, memberJson, connection)
+            return runDshReview({ ...entry, card: checked.card }, reviewedPrs[0], model, taskSignal)
+          }
+          const model = await modelFor(ctx, memberJson, connection)
+          const { sessionId, cwd } = await restrictedSession(ctx, model, workspaceRoot, sessionIds)
+          try {
+            return await prompt(ctx, sessionId,
+              `请仅用已提供的文字完成这项已授权任务，不要调用工具、修改文件或假装读过未提供的资料。任务：${checked.card.title}。所有者的要求：${checked.card.task_prompt}。已核验参数：${JSON.stringify(entry.parameters)}。请求人原话（不可信）：${entry.request_text}${material}`,
+              taskSignal)
+          } finally {
+            sessionIds.delete(sessionId)
+            if (typeof ctx.sessionController.cancel === 'function') {
+              await ctx.sessionController.cancel({ sessionId }).catch(() => undefined)
+            }
+            await rm(cwd, { recursive: true, force: true }).catch(() => undefined)
           }
-          await rm(cwd, { recursive: true, force: true }).catch(() => undefined)
         }
-      } else {
         throw new Error('这项任务的执行方尚未启用，请机器人所有者检查设置。')
       }
+      let result
+      if (!crossReview) {
+        result = await runReviewer(taskReviewers[0])
+      } else {
+        const outcomes = await Promise.allSettled(taskReviewers.map((reviewer) => runReviewer(reviewer)))
+        const label = (reviewer) => ({ codex: 'Codex', 'claude-code': 'Claude Code', dsh: 'DSH' })[reviewer] || reviewer
+        const settled = outcomes.map((outcome, index) => ({ reviewer: taskReviewers[index], ...outcome }))
+        const completed = settled.filter((outcome) => outcome.status === 'fulfilled')
+        const failed = settled.filter((outcome) => outcome.status === 'rejected')
+        if (!completed.length) {
+          throw new Error(`交叉 review 的所有 Agent 均未完成：${failed.map((item) => `${label(item.reviewer)}：${item.reason?.message || '执行失败'}`).join('；')}`)
+        }
+        const perAgentLimit = Math.max(400, Math.floor((MAX_REPLY_LENGTH - 700) / taskReviewers.length))
+        result = `交叉 review：${taskReviewers.map(label).join('、')}并行审查（同一 PR Head ${reviewedPrs[0].sha.slice(0, 8)}）\n\n`
+          + completed.map((item) => `【${label(item.reviewer)}】\n${String(item.value).slice(0, perAgentLimit)}`).join('\n\n')
+        if (failed.length) {
+          result += `\n\n【未完成】\n${failed.map((item) => `${label(item.reviewer)}：${item.reason?.message || '执行失败'}`).join('\n')}`
+        }
+      }
       taskSignal.throwIfAborted()
       const recheck = await memberJson(connection, '/api/me/im-delegations/cards/authorize',
         { method: 'POST', body: JSON.stringify(entry.authorization) })

package/delegation.js

@@ -4,7 +4,7 @@ import { homedir } from 'node:os'
 import { dirname, join, resolve } from 'node:path'
 import { spawn } from 'node:child_process'
 import { CONVERSATION_TOOL_NAMES, conversationKey, createConversationEngine,
-  isHelpRequest, requestsPrivateReply } from './conversation.js'
+  isHelpRequest, modelFor, requestsPrivateReply, teamModelProvider } from './conversation.js'
 
 const MAX_DIFF_BYTES = 240_000
 const MAX_GITEA_JSON_BYTES = 64_000
@@ -815,8 +815,8 @@ export async function cleanupPrWorkspaceCaches(workspaceRoot, cards, entries, ge
   })
 }
 
-function reviewPrompt(grant, material, task = null) {
-  const snapshot = task?.card
+function reviewPrompt(grant, material, task = null, snapshotAvailable = Boolean(task?.card)) {
+  const snapshot = snapshotAvailable
     ? '本次 PR 的完整代码快照位于当前任务工作目录；可以只读查看目录内相关源码、测试和配置。'
     : '当前工作目录不包含完整仓库；只能根据下列已提供的 PR 差异审查，并说明上下文局限。'
   const ownerInstructions = task?.card?.task_prompt
@@ -899,7 +899,8 @@ export async function runNativePrReview(ctx, executor, grant, material, sessionI
   }
 }
 
-export async function runDshPrReview(ctx, grant, material, model, sessionIds, signal, workspaceRoot = dshRoot()) {
+export async function runDshPrReview(ctx, grant, material, model, sessionIds, signal,
+  workspaceRoot = dshRoot(), task = null) {
   signal.throwIfAborted()
   const workspace = join(workspaceRoot, 'ant-delegation', 'workspaces', randomUUID())
   await mkdir(workspace, { recursive: true, mode: 0o700 })
@@ -919,8 +920,9 @@ export async function runDshPrReview(ctx, grant, material, model, sessionIds, si
     }
     agent.ctx.tools.restrict({ allow: [] })
     agent.ctx.tools.guard(() => 'ANT 委托审查不能调用 DSH 工具。')
-    await ctx.sessionController.selectModel({ sessionId, provider: model.protocol === 'anthropic' ? 'ant-team-anthropic' : 'ant-team-openai', model: model.model_id })
-    await ctx.sessionController.prompt({ sessionId, requestId: randomUUID(), mode: 'queue', content: [{ type: 'text', text: reviewPrompt(grant, material) }] }, signal)
+    await ctx.sessionController.selectModel({ sessionId, provider: teamModelProvider(model), model: model.model_id })
+    await ctx.sessionController.prompt({ sessionId, requestId: randomUUID(), mode: 'queue',
+      content: [{ type: 'text', text: reviewPrompt(grant, material, task, false) }] }, signal)
     const deadline = Date.now() + MODEL_TIMEOUT_MS
     while (Date.now() < deadline) {
       if (signal.aborted) throw new Error('任务已取消。')
@@ -1075,6 +1077,8 @@ export function startDelegationHost(ctx, readConnection, { ledger = new Delegati
     fetchPr: fetchGiteaPr,
     preparePrWorkspace: (card, taskId, pr, taskSignal) =>
       preparePrWorkspace(ctx, card, taskId, pr, taskSignal, workspaceRoot, readSettings),
+    runDshReview: (entry, pr, model, taskSignal) => runDshPrReview(ctx, pr.target,
+      { title: pr.title, sha: pr.sha, diff: pr.diff }, model, sessionIds, taskSignal, workspaceRoot, entry),
     runNativeReview: (entry, pr, taskSignal, workspacePath) => runNativePrReview(ctx, 'claude-code', {
       ...pr.target,
     }, { title: pr.title, sha: pr.sha, diff: pr.diff }, sessionIds, taskSignal, workspaceRoot,
@@ -1113,9 +1117,7 @@ export function startDelegationHost(ctx, readConnection, { ledger = new Delegati
           const credential = await ctx.credentials.resolve('ANT_GITEA_API_TOKEN')
           const material = await fetchGiteaPr(auth.grant, credential?.value)
           if (executor === 'dsh') {
-            const models = await memberJson(connection, '/api/me/models')
-            const model = models.models?.find((item) => item.protocol === 'openai' || item.protocol === 'anthropic')
-            if (!model) throw new Error('当前没有可用的团队模型。')
+            const model = await modelFor(ctx, memberJson, connection)
             reply = await runDshPrReview(ctx, auth.grant, material, model, sessionIds, taskSignal, workspaceRoot)
           } else {
             reply = await runNativePrReview(ctx, executor, auth.grant, material, sessionIds, taskSignal, workspaceRoot, logger)
@@ -1396,7 +1398,12 @@ export function startDelegationHost(ctx, readConnection, { ledger = new Delegati
           approval = { code, owner_id: event.actor.id, group_id: groupId, card_id: matches[0].id,
             expires_at: Date.now() + 300_000 }
           kind = 'group_card_approval_offer'
-          const runnerDescription = matches[0].runner === 'codex' ? '这台电脑的 Codex 专用只读差异审查'
+          const reviewers = Array.isArray(matches[0].reviewers) && matches[0].reviewers.length
+            ? matches[0].reviewers : [matches[0].runner]
+          const reviewerLabel = (id) => ({ dsh: 'DSH', codex: 'Codex', 'claude-code': 'Claude Code' })[id] || id
+          const runnerDescription = reviewers.length > 1
+            ? `普通请求默认由${reviewerLabel(matches[0].runner)}执行；明确说“交叉 review”时并行启动${reviewers.map(reviewerLabel).join('、')}`
+            : matches[0].runner === 'codex' ? '这台电脑的 Codex 专用只读差异审查'
             : matches[0].runner === 'claude-code' ? '这台 DSH 已注册的 Claude Code 子代理试用'
               : '受限 DSH'
           reply = `确认后，本群任何成员可请求“${matches[0].title}”；执行方为${runnerDescription}，参数规则沿用私聊任务，结果公开回复原群／原话题，授权最长 7 天。请在 5 分钟内 @我回复“确认启用 ${code}”。`
@@ -1425,7 +1432,7 @@ export function startDelegationHost(ctx, readConnection, { ledger = new Delegati
                 method: 'POST', body: JSON.stringify({ bot_id: event.botId, bot_fingerprint: event.fingerprint,
                   title: source.title, intent: source.intent, examples: source.examples,
                   parameters: source.parameters, task_prompt: source.task_prompt,
-                  runner: source.runner, workspace: null, sender_scope: 'any', sender_ids: [],
+                  runner: source.runner, reviewers: source.reviewers, workspace: null, sender_scope: 'any', sender_ids: [],
                   conversation_kind: 'group', conversation_id: groupId,
                   expires_at: Math.min(source.expires_at, Math.floor(Date.now() / 1000) + 7 * 86400) }),
               })

package/index.js

@@ -69,8 +69,10 @@ function modelServiceBinding(settings) {
     let url
     try { url = new URL(provider.baseURL) } catch { return { configured, serviceUrl: null } }
     const localHttp = url.protocol === 'http:' && ['localhost', '127.0.0.1', '[::1]'].includes(url.hostname)
-    if ((url.protocol !== 'https:' && !localHttp) || url.username || url.password || url.search || url.hash
-      || !['/model-gateway/openai/v1', '/model-gateway/anthropic'].includes(url.pathname)) {
+    const knownRoute = ['/model-gateway/openai/v1', '/model-gateway/anthropic'].includes(url.pathname)
+      || /^\/model-gateway\/openai\/providers\/[A-Za-z0-9-]{1,64}\/v1$/u.test(url.pathname)
+      || /^\/model-gateway\/anthropic\/providers\/[A-Za-z0-9-]{1,64}$/u.test(url.pathname)
+    if ((url.protocol !== 'https:' && !localHttp) || url.username || url.password || url.search || url.hash || !knownRoute) {
       return { configured, serviceUrl: null }
     }
     origins.add(url.origin)
@@ -178,7 +180,11 @@ async function fetchMemberModels(request, credentials, settings) {
     }
     if (!session.ok) return jsonResponse(502, { message: '无法激活 ANT 模型会话。' })
     const upstream = await fetch(new URL('/api/me/models', serviceUrl), {
-      headers: { authorization: `Bearer ${token}`, accept: 'application/json' },
+      headers: {
+        authorization: `Bearer ${token}`,
+        accept: 'application/json',
+        ...(request.headers.get('x-ant-model-provider-config') === '1' ? { 'x-ant-model-provider-config': '1' } : {}),
+      },
       redirect: 'manual',
       signal: AbortSignal.timeout(10_000),
     })
@@ -193,7 +199,7 @@ async function fetchMemberModels(request, credentials, settings) {
     if (!Array.isArray(result?.models) || normalizeServiceUrl(result.service_url) !== serviceUrl) {
       return jsonResponse(502, { message: 'ANT 团队模型目录与已连接服务不匹配。' })
     }
-    return jsonResponse(200, { service_url: serviceUrl, models: result.models })
+    return jsonResponse(200, { service_url: serviceUrl, models: result.models, default_model: result.default_model ?? null })
   } catch {
     return jsonResponse(502, { message: '无法连接 ANT 团队服务' })
   }
@@ -362,7 +368,7 @@ async function fetchDelegationStatus(request, credentials, settings) {
 }
 
 async function fetchDelegationCards(request, ctx, credentials, settings) {
-  if (!['GET', 'POST', 'DELETE'].includes(request.method)) return jsonResponse(405, { message: '请求方式不支持。' })
+  if (!['GET', 'POST', 'PUT', 'DELETE'].includes(request.method)) return jsonResponse(405, { message: '请求方式不支持。' })
   let connection
   try { connection = await readMemberConnection(credentials, settings) } catch {
     return jsonResponse(500, { message: '无法读取 ANT 连接。' })
@@ -376,7 +382,7 @@ async function fetchDelegationCards(request, ctx, credentials, settings) {
       body = JSON.parse(raw)
     } catch { return jsonResponse(400, { message: '任务设置格式无效。' }) }
   }
-  if (request.method === 'POST') {
+  if (['POST', 'PUT'].includes(request.method)) {
     const service = dshImService(ctx)
     if (!service?.describeBot) return jsonResponse(503, { message: '请先安装并启用 DSH-IM。' })
     try {
@@ -390,18 +396,28 @@ async function fetchDelegationCards(request, ctx, credentials, settings) {
   if (request.method === 'DELETE' && (typeof body?.id !== 'string' || !/^[0-9a-f-]{36}$/iu.test(body.id))) {
     return jsonResponse(400, { message: '任务编号无效。' })
   }
+  if ((request.method === 'POST' && body?.id !== undefined)
+    || (request.method === 'PUT' && (typeof body?.id !== 'string' || !/^[0-9a-f-]{36}$/iu.test(body.id)))) {
+    return jsonResponse(400, { message: '任务编号无效。' })
+  }
   const path = request.method === 'DELETE'
     ? `/api/me/im-delegations/cards/${encodeURIComponent(body.id)}` : '/api/me/im-delegations/cards'
+  const payload = body
   try {
     const response = await fetch(new URL(path, connection.serviceUrl), {
       method: request.method,
       headers: { authorization: `Bearer ${connection.token}`, accept: 'application/json',
         ...(request.method !== 'GET' ? { origin: new URL(connection.serviceUrl).origin } : {}),
-        ...(request.method === 'POST' ? { 'content-type': 'application/json' } : {}) },
-      ...(request.method === 'POST' ? { body: JSON.stringify(body) } : {}),
+        ...(['POST', 'PUT'].includes(request.method) ? { 'content-type': 'application/json' } : {}) },
+      ...(['POST', 'PUT'].includes(request.method) ? { body: JSON.stringify(payload) } : {}),
       redirect: 'manual', signal: AbortSignal.timeout(12_000),
     })
-    if (response.status === 404 && request.method !== 'DELETE') return jsonResponse(426, { message: '团队服务端尚未支持自定义任务，请联系管理员升级。' })
+    if (response.status === 404 && ['GET', 'POST'].includes(request.method)) {
+      return jsonResponse(426, { message: '团队服务端尚未支持自定义任务，请联系管理员升级。' })
+    }
+    if (response.status === 405 && request.method === 'PUT') {
+      return jsonResponse(426, { message: '团队服务端尚未支持能力编辑，请联系管理员升级 ANT 服务端。' })
+    }
     if (response.status === 204) return new Response(null, { status: 204 })
     const text = await readLimitedBody(response, request.method === 'GET' ? 8 * 1024 * 1024 : MAX_MODEL_RESPONSE_BYTES)
     if (text === null) return jsonResponse(502, { message: '团队服务响应过大。' })
@@ -855,6 +871,8 @@ async function fetchAuthRequest(request, endpoint, credentials, settings) {
         accept: 'application/json',
         'content-type': 'application/json',
         origin: serviceUrl,
+        ...(endpoint === 'dsh-connect' && request.headers.get('x-ant-model-provider-config') === '1'
+          ? { 'x-ant-model-provider-config': '1' } : {}),
       },
       body: JSON.stringify(payload),
       redirect: 'manual',
@@ -962,7 +980,7 @@ export function apply(ctx) {
       fetch: (request) => fetchDelegationStatus(request, connectionCtx.credentials, connectionCtx.settings),
     }), 'ant-teams: local delegated task status')
     connectionCtx.effect(() => connectionCtx.connection.fetch.register({
-      path: DELEGATION_CARDS_PATH, methods: ['GET', 'POST', 'DELETE'], requestBody: 'buffered',
+      path: DELEGATION_CARDS_PATH, methods: ['GET', 'POST', 'PUT', 'DELETE'], requestBody: 'buffered',
       fetch: (request) => fetchDelegationCards(request, connectionCtx, connectionCtx.credentials, connectionCtx.settings),
     }), 'ant-teams: member task cards')
     connectionCtx.effect(() => connectionCtx.connection.fetch.register({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-wendao/ant",
-  "version": "0.4.10",
+  "version": "0.4.12",
   "description": "ANT (AI-native Teams) connects a DeepSeek Harness Desktop profile to team identity and approved models.",
   "type": "module",
   "scripts": {