@ai-wendao/ant 0.3.9 → 0.3.11

package/MIGRATION.md

@@ -13,7 +13,7 @@
 此方式适用于 DSH Desktop RC2 使用默认、启用 HMR 的 Desktop profile，且目标 ANT 版本已发布到 npm：
 
 1. 打开 **插件 → ANT**，点击 **卸载** 并确认。
-2. 回到插件列表，点击 **添加插件**，输入已发布的直接包名，例如 `@ai-wendao/ant@0.3.9`，然后点击 **安装**。
+2. 回到插件列表，点击 **添加插件**，输入已发布的直接包名，例如 `@ai-wendao/ant@0.3.11`，然后点击 **安装**。
 3. 安装完成后启用 ANT，打开设置页，检查服务连接与获准模型。
 
 RC2 的 Desktop 基础 profile 默认启用 HMR；官方管理器在该模式下会先卸载 Bundle，再用随 DSH 提供的包管理器移除依赖。包卸载本身不会调用 ANT 的“断开设备”操作，也不会清空 DSH 凭证存储。若 profile 禁用了 HMR，管理器会提示先停止 profile；此时改用下方 CLI 备用流程。真实成员 profile 的凭证保留仍需在目标 RC2 客户端上验收。
@@ -59,14 +59,14 @@ node packages/ant-bundle/tools/migrate-legacy.mjs migrate --apply
 安装了系统 Node.js 的成员也可以从已发布 npm 包运行：
 
 ```sh
-npm exec --yes --package @ai-wendao/ant@0.3.9 -- ant-migrate inspect
-npm exec --yes --package @ai-wendao/ant@0.3.9 -- ant-migrate migrate
+npm exec --yes --package @ai-wendao/ant@0.3.11 -- ant-migrate inspect
+npm exec --yes --package @ai-wendao/ant@0.3.11 -- ant-migrate migrate
 ```
 
 退出 DSH 后执行变更：
 
 ```sh
-npm exec --yes --package @ai-wendao/ant@0.3.9 -- ant-migrate migrate --apply
+npm exec --yes --package @ai-wendao/ant@0.3.11 -- ant-migrate migrate --apply
 ```
 
 若 CLI 不在 PATH，可追加 `--dsh-cli "<Desktop CLI 完整路径>"`；若 DSH 使用自定义数据目录，可追加 `--dsh-home "<DSH_HOME 路径>"`。
@@ -76,8 +76,8 @@ npm exec --yes --package @ai-wendao/ant@0.3.9 -- ant-migrate migrate --apply
 `migrate --apply` 会输出受限权限的备份目录，备份包含 profile 的 `package.json`、`pnpm-lock.yaml`、`pnpm-workspace.yaml`（若存在）及其 SHA-256 校验值，不包含密钥库。备份仅用于迁移状态核验和保留原始清单，不等于离线恢复包。确认 DSH 已退出后，通过同一工具调用：
 
 ```sh
-npm exec --yes --package @ai-wendao/ant@0.3.9 -- ant-migrate rollback --backup "<备份目录>"
-npm exec --yes --package @ai-wendao/ant@0.3.9 -- ant-migrate rollback --backup "<备份目录>" --apply
+npm exec --yes --package @ai-wendao/ant@0.3.11 -- ant-migrate rollback --backup "<备份目录>"
+npm exec --yes --package @ai-wendao/ant@0.3.11 -- ant-migrate rollback --backup "<备份目录>" --apply
 ```
 
 回退只在 scoped 包已安装、旧 alias 尚未移除的中间态工作；它会卸载 scoped 包并保留旧 alias。已完成迁移的 profile 不接受该回退，避免自动恢复已知有加载问题的 alias。若安装包时 npm registry 不可用，保持 DSH 关闭，稍后重新运行 `migrate --apply`。

package/README.md

@@ -1,6 +1,14 @@
 # ANT for DeepSeek Harness
 
-ANT connects a DeepSeek Harness Desktop profile to its team's approved models and collaboration services.
+ANT (AI-native Teams) connects a DeepSeek Harness Desktop profile to its team's membership and approved models.
+
+飞书和企业微信的机器人连接、消息收发由 DSH-IM 负责；ANT Bundle 不再提供自己的 IM 接入。ANT 继续负责团队成员身份和模型授权。
+
+## 企业精选技能
+
+团队管理员可在 ANT 管理台从 GitHub 目录、ZIP、TAR、TAR.GZ／TGZ 或单份 `SKILL.md` 导入技能，核对来源、文件和依赖后发布。已连接团队的成员在 ANT 插件页面点击“安装到这台 DSH”，由 ANT Host 将固定版本的完整文件集放进 DSH 的用户技能目录；随后由 DSH 原生技能提供者发现和使用。
+
+安装不会自动运行技能脚本或安装 Python、Node 等系统依赖。ANT 只更新或卸载自己管理且本机内容未被修改的技能目录；发现同名个人技能或本机改动时会停止覆盖。
 
 ## Existing `ant` alias installations
 

package/client.js

@@ -144,6 +144,78 @@ window.__ModuleLoader__.load({
         h(ModelSyncFooter, { remote, serviceUrl, onServiceUrlChange: setServiceUrl }))
     }
 
+    function SkillCenter({ connected }) {
+      const [skills, setSkills] = useState([])
+      const [loading, setLoading] = useState(false)
+      const [workingId, setWorkingId] = useState('')
+      const [message, setMessage] = useState('')
+      const refresh = async () => {
+        if (!connected) return
+        setLoading(true)
+        try {
+          const response = await fetch('/api/ant-teams/skills', { cache: 'no-store' })
+          const result = await readLocalJsonResponse(response)
+          if (!response.ok) throw new Error(result.message || `读取技能失败（${response.status}）。`)
+          if (!Array.isArray(result.skills)) throw new Error('企业技能目录格式无效。')
+          setSkills(result.skills)
+          setMessage(result.skills.length ? '' : '团队暂未发布精选技能。')
+        } catch (error) {
+          setSkills([])
+          setMessage(error instanceof Error ? error.message : '无法读取企业精选技能。')
+        }
+        finally { setLoading(false) }
+      }
+      useEffect(() => {
+        if (connected) void refresh()
+        else { setSkills([]); setMessage('') }
+      }, [connected])
+      const changeInstall = async (skill, remove = false) => {
+        const action = remove ? '卸载' : skill.local_status === 'update-available' ? '更新' : '安装'
+        const prompt = remove
+          ? `从这台 DSH 卸载 ${skill.title}？已修改的本地文件不会被删除。`
+          : `将 ${skill.title} ${action}到这台 DSH？\n\n本机依赖：${skill.requirements}\n\n技能可能让 DSH 读取文件或执行脚本，仍受 DSH 的工具授权控制。ANT 不会自动安装系统依赖。`
+        if (!window.confirm(prompt)) return
+        setWorkingId(skill.id)
+        setMessage(`正在${action} ${skill.title}…`)
+        try {
+          const response = await fetch(`/api/ant-teams/skills/${remove ? 'uninstall' : 'install'}`, {
+            method: 'POST', headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(remove ? { dsh_name: skill.dsh_name } : { skill_id: skill.id }),
+          })
+          const result = await readLocalJsonResponse(response)
+          if (!response.ok) throw new Error(result.message || `${action}失败（${response.status}）。`)
+          await refresh()
+          setMessage(`${skill.title} 已${action}。DSH 将从本机技能目录发现它。`)
+        } catch (error) { setMessage(error instanceof Error ? error.message : `${action}失败。`) }
+        finally { setWorkingId('') }
+      }
+      return h('section', { style: panelStyle },
+        h('div', { style: { display: 'flex', justifyContent: 'space-between', alignItems: 'flex-start', gap: 12 } },
+          h('div', null,
+            h('h3', { style: { margin: 0, fontSize: 16, fontWeight: 650 } }, '企业精选技能'),
+            h('p', { style: { ...mutedTextStyle, marginTop: 4 } }, '管理员审核后发布；点击安装即可交给 DSH 原生技能系统使用。')),
+          h('button', { type: 'button', disabled: !connected || loading || Boolean(workingId), onClick: () => void refresh(), style: secondaryButtonStyle }, loading ? '读取中…' : '刷新')),
+        !connected ? h('p', { style: mutedTextStyle }, '连接团队后可浏览和安装精选技能。') : null,
+        message ? h('p', { role: 'status', style: mutedTextStyle }, message) : null,
+        ...skills.map((skill) => h('div', { key: skill.id, style: { display: 'grid', gap: 7, padding: '12px 0', borderTop: '1px solid var(--dsw-alias-border, #8c99994d)' } },
+          h('strong', { style: { fontSize: 14 } }, skill.title),
+          h('p', { style: mutedTextStyle }, skill.description),
+          h('p', { style: mutedTextStyle }, `来源：${skill.source_kind === 'github' ? 'GitHub' : '管理员上传'} · 许可证：${skill.license} · ${skill.file_count} 个文件`),
+          h('p', { style: mutedTextStyle }, `本机依赖：${skill.requirements}`),
+          skill.local_status === 'conflict'
+            ? h('p', { role: 'status', style: mutedTextStyle }, '本机同名技能有未受 ANT 管理的内容、文件已被修改或备份损坏；请联系管理员处理。')
+            : skill.local_status === 'not-discovered'
+              ? h('div', null,
+                h('p', { role: 'status', style: mutedTextStyle }, '文件已在本机，但 DSH 技能服务没有发现它；请检查 DSH 技能目录配置。'),
+                h('button', { type: 'button', disabled: Boolean(workingId), onClick: () => void changeInstall(skill, true), style: secondaryButtonStyle }, '卸载本机副本'))
+            : h('div', { style: { display: 'flex', flexWrap: 'wrap', gap: 8 } },
+              h('button', { type: 'button', disabled: !connected || Boolean(workingId) || skill.local_status === 'installed',
+                onClick: () => void changeInstall(skill), style: primaryButtonStyle },
+              skill.local_status === 'installed' ? '已安装' : skill.local_status === 'update-available' ? '更新技能' : '安装到这台 DSH'),
+              skill.local_status !== 'not-installed' ? h('button', { type: 'button', disabled: Boolean(workingId),
+                onClick: () => void changeInstall(skill, true), style: secondaryButtonStyle }, '卸载') : null))))
+    }
+
     function ModelSyncFooter({ remote, serviceUrl, onServiceUrlChange }) {
       const [email, setEmail] = useState('')
       const [code, setCode] = useState('')
@@ -153,14 +225,6 @@ window.__ModuleLoader__.load({
       const [credentialConfigured, setCredentialConfigured] = useState(null)
       const [reauthenticate, setReauthenticate] = useState(false)
       const [needsReconnect, setNeedsReconnect] = useState(false)
-      const [feishuCode, setFeishuCode] = useState('')
-      const [feishuCodeMessage, setFeishuCodeMessage] = useState('')
-      const [feishuApps, setFeishuApps] = useState([])
-      const [feishuAppId, setFeishuAppId] = useState('')
-      const [feishuAppSecret, setFeishuAppSecret] = useState('')
-      const [feishuVerificationToken, setFeishuVerificationToken] = useState('')
-      const [feishuEncryptKey, setFeishuEncryptKey] = useState('')
-      const [feishuAppStatus, setFeishuAppStatus] = useState('')
       const [bundleRelease, setBundleRelease] = useState(null)
       const [bundleUpdate, setBundleUpdate] = useState({ state: 'idle', currentVersion: '', message: '' })
       const [approvedBuilds, setApprovedBuilds] = useState([])
@@ -439,7 +503,6 @@ window.__ModuleLoader__.load({
           if (configured) {
             void refreshModels()
             void checkBundleUpdate()
-            void refreshFeishuApps().catch((error) => setFeishuAppStatus(error.message))
           }
         }).catch(() => { if (current) setCredentialConfigured(null) })
         return () => { current = false }
@@ -524,7 +587,6 @@ window.__ModuleLoader__.load({
           setCredentialConfigured(true)
           setNeedsReconnect(false)
           setReauthenticate(false)
-          await refreshFeishuApps().catch((error) => setFeishuAppStatus(error.message))
           setMessage(`已连接 ${result.email || normalizedEmail}，同步 ${result.models.length} 个获准模型。它们现已出现在 DSH 模型选择器中。`)
         } catch (error) {
           setMessage(error instanceof Error ? error.message : '连接失败，请稍后重试。')
@@ -533,82 +595,6 @@ window.__ModuleLoader__.load({
         }
       }
 
-      const manageFeishuApps = async (body) => {
-        const response = await fetch('/api/ant-teams/feishu/apps', {
-          method: 'POST',
-          headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify(body),
-        })
-        const result = await readLocalJsonResponse(response)
-        if (!response.ok) throw new Error(result.message || `飞书操作失败（${response.status}）`)
-        return result
-      }
-
-      const refreshFeishuApps = async () => {
-        const result = await manageFeishuApps({ action: 'list' })
-        if (!Array.isArray(result.apps)) throw new Error('ANT 返回的飞书应用列表格式无效。')
-        setFeishuApps(result.apps)
-      }
-
-      const saveFeishuApp = async (event) => {
-        event.preventDefault()
-        setBusy(true)
-        setFeishuAppStatus('正在验证飞书应用并保存密钥…')
-        setFeishuCode('')
-        setFeishuCodeMessage('')
-        try {
-          const result = await manageFeishuApps({
-            action: 'save',
-            app_id: feishuAppId.trim(),
-            app_secret: feishuAppSecret,
-            verification_token: feishuVerificationToken,
-            encrypt_key: feishuEncryptKey,
-          })
-          if (!result.app?.id || !result.app?.callback_url) throw new Error('ANT 未返回飞书回调信息。')
-          setFeishuAppId('')
-          setFeishuAppSecret('')
-          setFeishuVerificationToken('')
-          setFeishuEncryptKey('')
-          setFeishuApps((apps) => [...apps.filter((app) => app.id !== result.app.id), result.app])
-          setFeishuAppStatus('App ID 和 App Secret 已验证；回调密钥已加密保存。请把下方回调地址填入该飞书应用的事件订阅设置。')
-        } catch (error) {
-          setFeishuAppStatus(error instanceof Error ? error.message : '飞书应用保存失败，请稍后重试。')
-        } finally {
-          setBusy(false)
-        }
-      }
-
-      const createFeishuLinkCode = async (app) => {
-        setBusy(true)
-        setFeishuCode('')
-        setFeishuCodeMessage('正在生成一次性飞书绑定码…')
-        try {
-          const result = await manageFeishuApps({ action: 'link-code', id: app.id })
-          if (typeof result.code !== 'string') throw new Error(result.message || 'ANT 未返回绑定码。')
-          setFeishuCode(result.code)
-          setFeishuCodeMessage(`有效期 ${Math.ceil(result.expires_in_seconds / 60)} 分钟。请在飞书中私聊该机器人，发送：绑定 ${result.code}`)
-        } catch (error) {
-          setFeishuCodeMessage(error instanceof Error ? error.message : '飞书绑定码生成失败，请稍后重试。')
-        } finally {
-          setBusy(false)
-        }
-      }
-
-      const disableFeishuApp = async (app) => {
-        if (!window.confirm(`停用飞书应用 ${app.app_id}？停用后它不能再触发新任务，已接收的任务仍会尝试完成并回复。`)) return
-        setBusy(true)
-        setFeishuAppStatus('正在停用飞书应用…')
-        try {
-          await manageFeishuApps({ action: 'disable', id: app.id })
-          await refreshFeishuApps()
-          setFeishuAppStatus('飞书应用已停用，并解除其成员身份绑定。')
-        } catch (error) {
-          setFeishuAppStatus(error instanceof Error ? error.message : '飞书应用停用失败。')
-        } finally {
-          setBusy(false)
-        }
-      }
-
       const showConnectForm = credentialConfigured !== true || reauthenticate || needsReconnect
       return h('div', { style: { display: 'grid', gridTemplateColumns: 'repeat(auto-fit, minmax(min(100%, 400px), 1fr))', alignItems: 'start', gap: 16 } },
         h('section', { style: panelStyle },
@@ -669,43 +655,8 @@ window.__ModuleLoader__.load({
             }),
             h('button', { type: 'submit', disabled: busy || code.length !== 8, style: primaryButtonStyle }, busy ? '连接中…' : '验证并连接')) : null,
           message ? h('p', { role: 'status', style: mutedTextStyle }, message) : null),
-        credentialConfigured === true && !needsReconnect && !reauthenticate ? h('section', { style: panelStyle },
-          h('div', null,
-            h('h3', { style: { margin: 0, fontSize: 16, fontWeight: 650 } }, '个人飞书应用'),
-            h('p', { style: { ...mutedTextStyle, marginTop: 4 } }, '每位成员自行管理飞书应用和身份绑定。群 ID 不参与授权；只有绑定到此应用的本人可以触发自己的 DSH。')),
-          h('form', { onSubmit: saveFeishuApp, style: { display: 'grid', gap: 9 } },
-            h('label', { htmlFor: 'ant-feishu-app-id', style: { fontSize: 13, fontWeight: 550 } }, '飞书 App ID'),
-            h('input', { id: 'ant-feishu-app-id', value: feishuAppId, required: true, maxLength: 128, placeholder: 'cli_…', onChange: (event) => setFeishuAppId(event.target.value), style: inputStyle }),
-            h('p', { style: mutedTextStyle }, '在飞书开放平台的应用凭证页查看，通常以 cli_ 开头。'),
-            h('label', { htmlFor: 'ant-feishu-app-secret', style: { fontSize: 13, fontWeight: 550 } }, 'App Secret'),
-            h('input', { id: 'ant-feishu-app-secret', type: 'password', autoComplete: 'new-password', value: feishuAppSecret, required: true, maxLength: 512, onChange: (event) => setFeishuAppSecret(event.target.value), style: inputStyle }),
-            h('p', { style: mutedTextStyle }, '同一应用凭证页中的密钥；ANT 用它验证 App ID 并读取机器人身份。'),
-            h('label', { htmlFor: 'ant-feishu-verification-token', style: { fontSize: 13, fontWeight: 550 } }, 'Verification Token'),
-            h('input', { id: 'ant-feishu-verification-token', type: 'password', autoComplete: 'new-password', value: feishuVerificationToken, required: true, maxLength: 512, onChange: (event) => setFeishuVerificationToken(event.target.value), style: inputStyle }),
-            h('p', { style: mutedTextStyle }, '在事件订阅设置中生成，用来校验飞书回调是否属于此应用。'),
-            h('label', { htmlFor: 'ant-feishu-encrypt-key', style: { fontSize: 13, fontWeight: 550 } }, 'Encrypt Key'),
-            h('input', { id: 'ant-feishu-encrypt-key', type: 'password', autoComplete: 'new-password', value: feishuEncryptKey, required: true, maxLength: 512, onChange: (event) => setFeishuEncryptKey(event.target.value), style: inputStyle }),
-            h('p', { style: mutedTextStyle }, '在事件订阅设置中生成；启用事件加密时，ANT 用它校验签名并解密回调。'),
-          h('p', { style: mutedTextStyle }, '保存时 ANT 会验证 App ID 和 App Secret，并读取该应用机器人的身份。所有密钥只在服务端加密保存。'),
-            h('button', { type: 'submit', disabled: busy, style: primaryButtonStyle }, busy ? '正在验证并保存…' : '验证并保存应用')),
-          feishuAppStatus ? h('p', { role: 'status', style: mutedTextStyle }, feishuAppStatus) : null,
-          feishuApps.length ? h('div', { style: { display: 'grid', gap: 10 } }, ...feishuApps.map((app) => h('article', { key: app.id, style: { ...panelStyle, padding: 14, gap: 8 } },
-            h('div', { style: { display: 'flex', justifyContent: 'space-between', gap: 12 } },
-              h('strong', null, app.app_id),
-              h('span', { style: mutedTextStyle }, !app.active ? '已停用' : app.linked ? '已绑定飞书身份' : '尚未绑定')),
-            h('p', { style: mutedTextStyle }, '飞书事件回调地址：'),
-            h('code', { style: { overflowWrap: 'anywhere', padding: 8, borderRadius: 6, backgroundColor: 'var(--dsw-alias-bg-layer-2)' } }, app.callback_url),
-            app.active ? h('div', { style: { display: 'flex', flexWrap: 'wrap', gap: 8 } },
-              h('button', { type: 'button', disabled: busy, onClick: () => void createFeishuLinkCode(app), style: primaryButtonStyle }, '生成此机器人的绑定码'),
-              h('button', { type: 'button', disabled: busy, onClick: () => void disableFeishuApp(app), style: secondaryButtonStyle }, '停用应用'))
-              : h('button', { type: 'button', disabled: busy, onClick: () => { setFeishuAppId(app.app_id); setFeishuAppStatus('请重新填写此应用的三个密钥以启用。') }, style: secondaryButtonStyle }, '重新配置启用')))) : null,
-          feishuCode ? h('code', { style: {
-            display: 'block', padding: '12px 14px', borderRadius: 9,
-            color: 'var(--dsw-alias-label-primary)',
-            backgroundColor: 'var(--dsw-alias-bg-layer-2)', fontSize: 18, letterSpacing: '.12em',
-          } }, feishuCode) : null,
-          feishuCodeMessage ? h('p', { role: 'status', style: mutedTextStyle }, feishuCodeMessage) : null,
-          h('p', { style: mutedTextStyle }, '保存后，把对应应用显示的回调地址填入飞书事件订阅，订阅 im.message.receive_v1。私聊绑定和机器人收发消息需要 im:message；群内 @ 机器人触发还需要 im:message.group_at_msg。验证回调后生成绑定码，再在飞书中私聊该机器人发送“绑定 <验证码>”。之后可在任意群中 @ 该机器人；ANT 会核对机器人和发送者身份，再把任务交给你的 DSH。')) : null)
+        h(SkillCenter, { connected: credentialConfigured === true }))
+
     }
 
     function apply(ctx) {

package/index.js

@@ -1,5 +1,7 @@
 export const name = 'ant'
 
+import { installSkill, listSkills, uninstallSkill } from './skill-install.js'
+
 export const inject = []
 
 const MODEL_SYNC_PATH = '/api/ant-teams/models'
@@ -8,20 +10,14 @@ const BUNDLE_RELEASE_PATH = '/api/ant-teams/bundle-release'
 const DISCONNECT_PATH = '/api/ant-teams/disconnect'
 const REQUEST_CODE_PATH = '/api/ant-teams/request-code'
 const CONNECT_PATH = '/api/ant-teams/connect'
-const FEISHU_LINK_CODE_PATH = '/api/ant-teams/feishu/link-code'
-const FEISHU_MEMBER_APPS_PATH = '/api/ant-teams/feishu/apps'
-const FEISHU_CLAIM_PATH = '/api/ant-teams/feishu/tasks/claim'
-const FEISHU_HEARTBEAT_PATH = '/api/ant-teams/feishu/tasks/heartbeat'
-const FEISHU_COMPLETE_PATH = '/api/ant-teams/feishu/tasks/complete'
-const FEISHU_FINISH_PATH = '/api/ant-teams/feishu/tasks/finish'
+const SKILLS_PATH = '/api/ant-teams/skills'
+const SKILL_INSTALL_PATH = '/api/ant-teams/skills/install'
+const SKILL_UNINSTALL_PATH = '/api/ant-teams/skills/uninstall'
 const ANT_NPM_PACKAGE_NAME = '@ai-wendao/ant'
 const MAX_MODEL_RESPONSE_BYTES = 1024 * 1024
 const MODEL_TOKEN_REF = 'ANT_MODEL_API_KEY'
 const SERVICE_RECORD_KEY = 'ant/team-service'
 const SESSION_HEARTBEAT_INTERVAL_MS = 30_000
-const FEISHU_POLL_INTERVAL_MS = 5_000
-const FEISHU_TASK_HEARTBEAT_INTERVAL_MS = 30_000
-const FEISHU_TASK_MAX_RUNTIME_MS = 30 * 60_000
 
 function jsonResponse(status, value) {
   return new Response(JSON.stringify(value), {
@@ -309,231 +305,53 @@ async function disconnectMember(request, credentials, settings) {
   }
 }
 
-async function relayFeishuRequest(request, path, credentials, settings) {
-  if (request.method !== 'POST') return jsonResponse(405, { message: '只支持 POST 请求' })
-  let connection
-  try { connection = await readMemberConnection(credentials, settings) } catch {
-    return jsonResponse(500, { message: 'DSH 无法读取 ANT 连接配置。' })
-  }
-  if (!connection) return jsonResponse(401, { message: '请先在 ANT 插件中连接团队。' })
-  try {
-    const session = await updateModelSession(connection.serviceUrl, connection.token, 'heartbeat')
-    if (session.status === 401 || session.status === 403) return jsonResponse(401, { message: 'ANT 成员凭证已失效。' })
-    if (!session.ok) return jsonResponse(502, { message: '无法激活 ANT 模型会话。' })
-    const body = await request.text()
-    if (body.length > 64 * 1024) return jsonResponse(413, { message: '飞书任务请求过大。' })
-    const upstream = await fetch(new URL(path, connection.serviceUrl), {
-      method: 'POST',
-      headers: {
-        authorization: `Bearer ${connection.token}`,
-        ...(body ? { 'content-type': 'application/json' } : {}),
-        accept: 'application/json',
-      },
-      ...(body ? { body } : {}),
-      redirect: 'manual',
-      signal: AbortSignal.timeout(15_000),
-    })
-    const text = await readLimitedBody(upstream)
-    if (text === null) return jsonResponse(502, { message: 'ANT 飞书任务响应过大。' })
-    return new Response(text, {
-      status: upstream.status,
-      headers: { 'content-type': upstream.headers.get('content-type') || 'application/json', 'cache-control': 'no-store' },
-    })
-  } catch {
-    return jsonResponse(502, { message: '无法连接 ANT 飞书任务服务。' })
-  }
+async function memberSkillConnection(credentials, settings) {
+  const connection = await readMemberConnection(credentials, settings)
+  if (!connection) return null
+  const session = await updateModelSession(connection.serviceUrl, connection.token, 'heartbeat')
+  if (!session.ok) return null
+  return connection
 }
 
-async function requestFeishuJson(serviceUrl, token, path, body, timeout = 15_000) {
-  const response = await fetch(new URL(path, serviceUrl), {
-    method: 'POST',
-    headers: {
-      authorization: `Bearer ${token}`,
-      accept: 'application/json',
-      ...(body === undefined ? {} : { 'content-type': 'application/json' }),
-    },
-    ...(body === undefined ? {} : { body: JSON.stringify(body) }),
-    redirect: 'manual',
-    signal: AbortSignal.timeout(timeout),
-  })
-  const text = await readLimitedBody(response)
-  if (text === null) throw new Error('ANT 飞书任务响应过大')
-  if (!response.ok) throw new Error(`ANT 飞书任务请求失败（${response.status}）`)
-  if (response.status === 204 || text === '') return null
-  try { return JSON.parse(text) } catch { throw new Error('ANT 飞书任务响应格式无效') }
-}
-
-async function syncModelsToHost(settings, serviceUrl, models) {
-  if (typeof settings?.mutate !== 'function') throw new Error('当前 DSH 版本未提供模型设置接口。')
-  const grouped = {
-    openai: models.filter((model) => model.protocol === 'openai'),
-    anthropic: models.filter((model) => model.protocol === 'anthropic'),
-  }
-  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
-    }
-    ops.push({ op: 'set', path: ['providers', route], value: {
-      displayName: protocol === 'openai' ? 'Lakala (OpenAI)' : 'Lakala (Anthropic)',
-      apiKeyEnv: 'ANT_MODEL_API_KEY',
-      api: protocol === 'openai' ? 'openai-completions' : 'anthropic-messages',
-      baseURL: protocol === 'openai'
-        ? new URL('/model-gateway/openai/v1', serviceUrl).toString()
-        : new URL('/model-gateway/anthropic', serviceUrl).toString(),
-      models: protocolModels.map((model) => ({ id: model.model_id, name: model.display_name })),
-    } })
+async function fetchMemberSkills(request, credentials, settings, registry) {
+  if (request.method !== 'GET') return jsonResponse(405, { message: '只支持 GET 请求' })
+  try {
+    const connection = await memberSkillConnection(credentials, settings)
+    if (!connection) return jsonResponse(401, { message: '请先连接 ANT 团队，或重新验证工作邮箱。' })
+    return jsonResponse(200, { skills: await listSkills(connection, registry) })
+  } catch (error) {
+    return jsonResponse(502, { message: error instanceof Error ? error.message : '无法读取企业精选技能。' })
   }
-  const result = await settings.mutate('llm-pi-ai', ops, undefined)
-  if (!result.ok) throw new Error('DSH 无法更新 ANT 获准模型。')
-}
-
-function assistantMessageText(event) {
-  const content = event?.data?.message?.content
-  if (!Array.isArray(content)) return ''
-  return content.filter((part) => part?.type === 'text' && typeof part.text === 'string')
-    .map((part) => part.text).join('')
 }
 
-async function executeFeishuTask(task, connection, settings, sessionController, stoppedSignal) {
-  let sessionId
-  let promptAccepted = false
-  let followAbort
-  let taskHeartbeat
-  let runtimeTimeout
-  let timedOut = false
-  let stopSignalListener
+async function installMemberSkill(request, credentials, settings, registry) {
+  if (request.method !== 'POST') return jsonResponse(405, { message: '只支持 POST 请求' })
+  let body
   try {
-    const catalogResponse = await fetch(new URL('/api/me/models', connection.serviceUrl), {
-      headers: { authorization: `Bearer ${connection.token}`, accept: 'application/json' },
-      redirect: 'manual',
-      signal: AbortSignal.timeout(10_000),
-    })
-    const text = await readLimitedBody(catalogResponse)
-    if (!catalogResponse.ok || text === null) throw new Error('ANT 当前无法返回获准模型。')
-    const catalog = JSON.parse(text)
-    if (normalizeServiceUrl(catalog.service_url) !== connection.serviceUrl || !Array.isArray(catalog.models)) {
-      throw new Error('ANT 返回的模型目录无效。')
-    }
-    await syncModelsToHost(settings, connection.serviceUrl, catalog.models)
-    const model = task.models?.[0]
-    if (!model || !catalog.models.some((item) => item.protocol === model.protocol && item.model_id === model.model_id)) {
-      throw new Error('任务模型已不在成员授权目录中。')
-    }
-    if (typeof sessionController?.create !== 'function' || typeof sessionController?.follow !== 'function'
-      || typeof sessionController?.selectModel !== 'function' || typeof sessionController?.prompt !== 'function') {
-      throw new Error('当前 DSH 版本未提供 Session Controller 接口。')
-    }
-    sessionId = await sessionController.create(task.session_id ? { sessionId: task.session_id } : {})
-    const provider = model.protocol === 'openai' ? 'ant-team-openai' : 'ant-team-anthropic'
-    await sessionController.selectModel({ sessionId, provider, model: model.model_id })
-    followAbort = new AbortController()
-    stopSignalListener = () => followAbort.abort()
-    stoppedSignal.addEventListener('abort', stopSignalListener, { once: true })
-    const follow = sessionController.follow({ address: { kind: 'session', sessionId } }, followAbort.signal)
-    const iterator = follow[Symbol.asyncIterator]()
-    const opening = await iterator.next()
-    if (opening.done || opening.value?.type !== 'snapshot') throw new Error('DSH 会话无法开始跟随。')
-    if (stoppedSignal.aborted) throw new Error('DSH 客户端正在关闭。')
-
-    await sessionController.prompt({
-      requestId: globalThis.crypto.randomUUID(),
-      sessionId,
-      mode: 'queue',
-      content: [{ type: 'text', text: task.prompt }],
-    }, followAbort.signal)
-    promptAccepted = true
-    taskHeartbeat = setInterval(() => {
-      void updateModelSession(connection.serviceUrl, connection.token, 'heartbeat')
-        .then((response) => {
-          if (!response.ok) throw new Error('ANT model session expired')
-          return requestFeishuJson(connection.serviceUrl, connection.token, '/api/feishu/tasks/heartbeat', { task_id: task.id })
-        })
-        .catch(() => followAbort.abort())
-    }, FEISHU_TASK_HEARTBEAT_INTERVAL_MS)
-    taskHeartbeat.unref?.()
-    runtimeTimeout = setTimeout(() => { timedOut = true; followAbort.abort() }, FEISHU_TASK_MAX_RUNTIME_MS)
-    runtimeTimeout.unref?.()
-
-    let result = ''
-    while (!stoppedSignal.aborted) {
-      const next = await iterator.next()
-      if (next.done) throw new Error('DSH 会话结果流意外结束。')
-      const frame = next.value
-      if (frame?.type !== 'event') continue
-      const event = frame.event
-      if (event?.type === 'assistant/message') {
-        const message = assistantMessageText(event)
-        if (message) result = message
-      }
-      if (event?.type === 'turn/end') {
-        if (event.data?.reason?.kind !== 'completed' || !result.trim()) throw new Error('DSH 任务未能正常完成。')
-        await requestFeishuJson(connection.serviceUrl, connection.token, '/api/feishu/tasks/complete', {
-          task_id: task.id,
-          session_id: sessionId,
-          result,
-        })
-        return
-      }
-    }
-    if (stoppedSignal.aborted) throw new Error('DSH 客户端正在关闭。')
-  } catch {
-    const status = promptAccepted ? 'unknown' : 'failed'
-    try {
-      await requestFeishuJson(connection.serviceUrl, connection.token, '/api/feishu/tasks/finish', {
-        task_id: task.id,
-        status: timedOut && promptAccepted ? 'unknown' : status,
-      })
-    } catch {}
-  } finally {
-    clearInterval(taskHeartbeat)
-    clearTimeout(runtimeTimeout)
-    if (stopSignalListener) stoppedSignal.removeEventListener('abort', stopSignalListener)
-    followAbort?.abort()
+    const text = await request.text()
+    if (text.length > 4096) throw new Error()
+    body = JSON.parse(text)
+  } catch { return jsonResponse(400, { message: '技能安装请求无效。' }) }
+  try {
+    const connection = await memberSkillConnection(credentials, settings)
+    if (!connection) return jsonResponse(401, { message: '请先连接 ANT 团队，或重新验证工作邮箱。' })
+    return jsonResponse(200, await installSkill(connection, body?.skill_id, registry))
+  } catch (error) {
+    return jsonResponse(409, { message: error instanceof Error ? error.message : '技能安装失败。' })
   }
 }
 
-function installFeishuTaskWorker(credentials, settings, sessionController) {
-  let stopped = false
-  let busy = false
-  let taskAbort
-  let work = Promise.resolve()
-  let pollWork = Promise.resolve()
-  const poll = async () => {
-    if (stopped || busy) return
-    busy = true
-    try {
-      const connection = await readMemberConnection(credentials, settings)
-      if (!connection) return
-      const session = await updateModelSession(connection.serviceUrl, connection.token, 'heartbeat')
-      if (!session.ok || stopped) return
-      const claim = await requestFeishuJson(connection.serviceUrl, connection.token, '/api/feishu/tasks/claim')
-      if (!claim?.task || stopped) return
-      taskAbort = new AbortController()
-      work = executeFeishuTask(claim.task, connection, settings, sessionController, taskAbort.signal)
-      await work
-    } catch {
-      // A transient polling error is retried on the next interval.
-    } finally {
-      busy = false
-    }
-  }
-  const schedulePoll = () => {
-    if (stopped || busy) return
-    pollWork = poll()
-  }
-  const timer = setInterval(schedulePoll, FEISHU_POLL_INTERVAL_MS)
-  timer.unref?.()
-  schedulePoll()
-  return async () => {
-    stopped = true
-    clearInterval(timer)
-    taskAbort?.abort()
-    await pollWork
-    await work
+async function uninstallMemberSkill(request) {
+  if (request.method !== 'POST') return jsonResponse(405, { message: '只支持 POST 请求' })
+  let body
+  try {
+    const text = await request.text()
+    if (text.length > 4096) throw new Error()
+    body = JSON.parse(text)
+  } catch { return jsonResponse(400, { message: '技能卸载请求无效。' }) }
+  try { return jsonResponse(200, await uninstallSkill(body?.dsh_name)) }
+  catch (error) {
+    return jsonResponse(409, { message: error instanceof Error ? error.message : '技能卸载失败。' })
   }
 }
 
@@ -593,7 +411,9 @@ async function fetchAuthRequest(request, endpoint, credentials) {
 }
 
 export function apply(ctx) {
-  ctx.inject(['connection', 'credentials', 'settings', 'sessionController'], (connectionCtx) => {
+  let skillRegistry
+  ctx.inject(['skills'], (skillCtx) => { skillRegistry = skillCtx.skills })
+  ctx.inject(['connection', 'credentials', 'settings'], (connectionCtx) => {
     connectionCtx.effect(() => connectionCtx.connection.fetch.register({
       path: SERVICE_INFO_PATH,
       methods: ['POST'],
@@ -609,8 +429,21 @@ export function apply(ctx) {
     connectionCtx.effect(() => connectionCtx.connection.fetch.register({
       path: BUNDLE_RELEASE_PATH,
       methods: ['GET'],
+      requestBody: 'buffered',
       fetch: (request) => fetchBundleRelease(request, connectionCtx.credentials, connectionCtx.settings),
     }), 'ant-teams: authenticated Bundle release relay')
+    connectionCtx.effect(() => connectionCtx.connection.fetch.register({
+      path: SKILLS_PATH, methods: ['GET'], requestBody: 'buffered',
+      fetch: (request) => fetchMemberSkills(request, connectionCtx.credentials, connectionCtx.settings, skillRegistry),
+    }), 'ant-teams: enterprise skill catalog')
+    connectionCtx.effect(() => connectionCtx.connection.fetch.register({
+      path: SKILL_INSTALL_PATH, methods: ['POST'], requestBody: 'buffered',
+      fetch: (request) => installMemberSkill(request, connectionCtx.credentials, connectionCtx.settings, skillRegistry),
+    }), 'ant-teams: install approved skill into DSH')
+    connectionCtx.effect(() => connectionCtx.connection.fetch.register({
+      path: SKILL_UNINSTALL_PATH, methods: ['POST'], requestBody: 'buffered',
+      fetch: (request) => uninstallMemberSkill(request),
+    }), 'ant-teams: remove managed DSH skill')
     connectionCtx.effect(() => connectionCtx.connection.fetch.register({
       path: DISCONNECT_PATH,
       methods: ['POST'],
@@ -628,21 +461,6 @@ export function apply(ctx) {
       requestBody: 'buffered',
       fetch: (request) => fetchAuthRequest(request, 'dsh-connect', connectionCtx.credentials),
     }), 'ant-teams: relay DSH account connection')
-    for (const [path, endpoint] of [
-      [FEISHU_MEMBER_APPS_PATH, '/api/feishu/member-apps'],
-      [FEISHU_LINK_CODE_PATH, '/api/feishu/link-code'],
-      [FEISHU_CLAIM_PATH, '/api/feishu/tasks/claim'],
-      [FEISHU_HEARTBEAT_PATH, '/api/feishu/tasks/heartbeat'],
-      [FEISHU_COMPLETE_PATH, '/api/feishu/tasks/complete'],
-      [FEISHU_FINISH_PATH, '/api/feishu/tasks/finish'],
-    ]) {
-      connectionCtx.effect(() => connectionCtx.connection.fetch.register({
-        path,
-        methods: ['POST'],
-        requestBody: 'buffered',
-        fetch: (request) => relayFeishuRequest(request, endpoint, connectionCtx.credentials, connectionCtx.settings),
-      }), `ant-teams: relay Feishu ${endpoint.split('/').at(-1)}`)
-    }
     connectionCtx.effect(() => {
       let stopped = false
       let inFlight = Promise.resolve()
@@ -670,9 +488,5 @@ export function apply(ctx) {
         } catch {}
       }
     }, 'ant-teams: ANT model activity session')
-    connectionCtx.effect(
-      () => installFeishuTaskWorker(connectionCtx.credentials, connectionCtx.settings, connectionCtx.sessionController),
-      'ant-teams: DSH-owned Feishu task worker',
-    )
   })
 }

package/locale/en.json

@@ -1,6 +1,6 @@
 {
   "meta": {
     "title": "ANT",
-    "description": "AI-native team service for DeepSeek Harness"
+    "description": "ANT (AI-native Teams) connects a DeepSeek Harness Desktop profile to team identity and approved models."
   }
 }

package/locale/zh.json

@@ -1,6 +1,6 @@
 {
   "meta": {
     "title": "ANT",
-    "description": "面向 DeepSeek Harness 的 AI-native团队服务"
+    "description": "ANT（AI-native Teams）连接 DeepSeek Harness Desktop profile，并提供团队成员身份与获准模型管理。"
   }
 }

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@ai-wendao/ant",
-  "version": "0.3.9",
-  "description": "AI-native team service for DeepSeek Harness",
+  "version": "0.3.11",
+  "description": "ANT (AI-native Teams) connects a DeepSeek Harness Desktop profile to team identity and approved models.",
   "type": "module",
   "scripts": {
-    "test": "node --test client.test.js index.test.js tools/migrate-legacy.test.mjs"
+    "test": "node --test client.test.js index.test.js skill-install.test.js tools/migrate-legacy.test.mjs"
   },
   "bin": {
     "ant-migrate": "tools/migrate-legacy.mjs"
@@ -16,7 +16,7 @@
     "./client": "./client.js",
     "./locale/*.json": "./locale/*.json"
   },
-  "files": ["index.js", "client.js", "cordis.patch.yml", "locale/*.json", "tools/migrate-legacy.mjs", "MIGRATION.md", "README.md"],
+  "files": ["index.js", "client.js", "skill-install.js", "cordis.patch.yml", "locale/*.json", "tools/migrate-legacy.mjs", "MIGRATION.md", "README.md"],
   "dsh": {
     "bundle": {
       "patch": "./cordis.patch.yml"

package/skill-install.js

@@ -0,0 +1,337 @@
+import { createHash, randomUUID } from 'node:crypto'
+import { chmod, lstat, mkdir, readFile, readdir, rename, rm, writeFile } from 'node:fs/promises'
+import { homedir } from 'node:os'
+import { dirname, join, resolve } from 'node:path'
+import { gunzipSync } from 'node:zlib'
+
+const MARKER = '.ant-managed.json'
+const MAX_FILES = 20_000
+const MAX_FILE_BYTES = 8 * 1024 * 1024
+const MAX_TOTAL_BYTES = 64 * 1024 * 1024
+const MAX_PACKAGE_BYTES = 80 * 1024 * 1024
+const MAX_JSON_BYTES = 4 * 1024 * 1024
+const activeSkills = new Set()
+
+async function assertDiscovered(registry, root, name) {
+  if (typeof registry?.list !== 'function') throw new Error('DSH 技能服务不可用，无法确认安装结果。')
+  const expected = resolve(root, name, 'SKILL.md')
+  for (let attempt = 0; attempt < 6; attempt++) {
+    const entries = await registry.list()
+    if (Array.isArray(entries) && entries.some((entry) => entry.name === name
+      && typeof entry.path === 'string'
+      && (process.platform === 'win32' ? resolve(entry.path).toLowerCase() === expected.toLowerCase() : resolve(entry.path) === expected))) return
+    if (attempt < 5) await new Promise((done) => setTimeout(done, 300))
+  }
+  throw new Error('DSH 没有发现此技能；请检查 DSH 技能目录配置。')
+}
+
+const hash = (bytes) => createHash('sha256').update(bytes).digest('hex')
+const safeName = (name) => typeof name === 'string' && /^ant-[a-z0-9]+(?:-[a-z0-9]+)*$/u.test(name) && name.length <= 64
+const safePath = (name) => typeof name === 'string' && name.length > 0 && name.length <= 1024
+  && !name.includes('\\') && !name.includes('\0') && name !== MARKER
+  && name.split('/').every((part) => part && part !== '.' && part !== '..' && part.length <= 255
+    && !/[<>:"|?*]/u.test(part) && !/[. ]$/u.test(part)
+    && !/^(?:con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\.|$)/iu.test(part))
+const validHash = (value) => typeof value === 'string' && /^[a-f0-9]{64}$/u.test(value)
+const skillRoot = () => {
+  const configured = process.env.DSH_HOME?.trim()
+  const home = !configured ? join(homedir(), '.dsh')
+    : configured === '~' ? homedir()
+      : configured.startsWith('~/') || configured.startsWith('~\\')
+        ? join(homedir(), configured.slice(2)) : configured
+  return join(resolve(home), 'skills')
+}
+const validManagedMarker = (marker, name) => marker?.dsh_name === name && validHash(marker.content_sha256)
+  && Array.isArray(marker.files) && marker.files.length > 0 && marker.files.length <= MAX_FILES
+  && marker.files.every((file) => safePath(file.path) && validHash(file.sha256) && typeof file.executable === 'boolean')
+  && new Set(marker.files.map((file) => file.path)).size === marker.files.length
+
+async function isPresent(path) {
+  try { return await lstat(path) } catch (error) {
+    if (error?.code === 'ENOENT') return null
+    throw error
+  }
+}
+
+async function safeRoot() {
+  const root = skillRoot()
+  const existing = await isPresent(root)
+  if (existing && (!existing.isDirectory() || existing.isSymbolicLink())) throw new Error('DSH 技能目录不是普通目录，无法安全安装。')
+  if (!existing) await mkdir(root, { recursive: true, mode: 0o700 })
+  const conflicts = await recoverInterruptedUpdates(root)
+  return { root, conflicts }
+}
+
+async function recoverInterruptedUpdates(root) {
+  const conflicts = new Set()
+  const stagingRoot = join(dirname(root), '.ant-skill-staging')
+  const stat = await isPresent(stagingRoot)
+  if (!stat) return conflicts
+  if (!stat.isDirectory() || stat.isSymbolicLink()) throw new Error('ANT 暂存目录不是普通目录。')
+  for (const entry of await readdir(stagingRoot, { withFileTypes: true })) {
+    const removedName = entry.name.match(/^removed-(ant-[a-z0-9-]+)-[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/u)?.[1]
+    if (entry.isDirectory() && !entry.isSymbolicLink() && safeName(removedName)
+      && !activeSkills.has(removedName)) {
+      await rm(join(stagingRoot, entry.name), { recursive: true }).catch(() => {})
+      continue
+    }
+    if (!entry.isDirectory() || entry.isSymbolicLink() || !entry.name.startsWith('old-ant-')) continue
+    const backup = join(stagingRoot, entry.name)
+    const recoveredName = entry.name.match(/^old-(ant-[a-z0-9-]+)-[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/u)?.[1]
+    if (!safeName(recoveredName)) continue
+    const target = join(root, recoveredName)
+    if (await isPresent(target)) continue
+    const markerStat = await isPresent(join(backup, MARKER))
+    if (!markerStat?.isFile() || markerStat.isSymbolicLink() || markerStat.size > MAX_JSON_BYTES) {
+      conflicts.add(recoveredName); continue
+    }
+    let marker
+    try { marker = JSON.parse(await readFile(join(backup, MARKER), 'utf8')) }
+    catch { conflicts.add(recoveredName); continue }
+    if (marker?.dsh_name !== recoveredName || !validManagedMarker(marker, recoveredName)) {
+      conflicts.add(recoveredName); continue
+    }
+    if (activeSkills.has(recoveredName)) continue
+    try {
+      await verifyManagedTree(stagingRoot, entry.name, marker)
+      await rename(backup, target)
+    } catch { conflicts.add(marker.dsh_name) }
+  }
+  return conflicts
+}
+
+async function readManaged(root, name) {
+  if (!safeName(name)) throw new Error('技能名称无效。')
+  const target = join(root, name)
+  const stat = await isPresent(target)
+  if (!stat) return null
+  if (!stat.isDirectory() || stat.isSymbolicLink()) throw new Error('同名目录不是 ANT 管理的普通技能目录。')
+  const markerStat = await isPresent(join(target, MARKER))
+  if (!markerStat || !markerStat.isFile() || markerStat.isSymbolicLink() || markerStat.size > MAX_JSON_BYTES) {
+    throw new Error('同名技能已有本地内容；ANT 不会覆盖。')
+  }
+  let marker
+  try { marker = JSON.parse(await readFile(join(target, MARKER), 'utf8')) } catch {
+    throw new Error('同名技能的管理记录无效；ANT 不会覆盖。')
+  }
+  if (!validManagedMarker(marker, name)) {
+    throw new Error('同名技能的管理记录无效；ANT 不会覆盖。')
+  }
+  return marker
+}
+
+async function verifyManagedTree(root, name, marker) {
+  const target = join(root, name)
+  const expected = new Set([MARKER])
+  for (const file of marker.files) {
+    const parts = file.path.split('/')
+    for (let index = 1; index < parts.length; index++) expected.add(parts.slice(0, index).join('/'))
+    expected.add(file.path)
+    const fullPath = join(target, ...file.path.split('/'))
+    const stat = await isPresent(fullPath)
+    if (!stat?.isFile() || stat.isSymbolicLink() || stat.size > MAX_FILE_BYTES
+      || (process.platform !== 'win32' && Boolean(stat.mode & 0o111) !== file.executable)
+      || hash(await readFile(fullPath)) !== file.sha256) {
+      throw new Error('技能文件已被本机修改；ANT 不会覆盖或删除。')
+    }
+  }
+  const walk = async (directory, prefix = '') => {
+    for (const entry of await readdir(directory, { withFileTypes: true })) {
+      const relative = prefix ? `${prefix}/${entry.name}` : entry.name
+      if (!expected.has(relative) || entry.isSymbolicLink()) throw new Error('技能目录有额外文件或链接；ANT 不会覆盖或删除。')
+      if (entry.isDirectory()) await walk(join(directory, entry.name), relative)
+      else if (!entry.isFile()) throw new Error('技能目录有无法识别的内容；ANT 不会覆盖或删除。')
+    }
+  }
+  await walk(target)
+}
+
+async function boundedBytes(response, maxBytes) {
+  if (!response.ok || !response.body) throw new Error(`团队服务无法提供技能文件（HTTP ${response.status}）。`)
+  const chunks = []
+  let total = 0
+  for await (const chunk of response.body) {
+    total += chunk.length
+    if (total > maxBytes) throw new Error('技能文件超过大小上限。')
+    chunks.push(chunk)
+  }
+  return Buffer.concat(chunks, total)
+}
+
+async function fetchJson(url, token) {
+  const response = await fetch(url, { headers: { authorization: `Bearer ${token}`, accept: 'application/json' }, redirect: 'manual', signal: AbortSignal.timeout(20_000) })
+  const bytes = await boundedBytes(response, MAX_JSON_BYTES)
+  try { return JSON.parse(bytes.toString('utf8')) } catch { throw new Error('团队技能目录格式无效。') }
+}
+
+export async function listSkills(connection, registry) {
+  const skills = await fetchJson(new URL('/api/me/skills', connection.serviceUrl), connection.token)
+  if (!Array.isArray(skills)) throw new Error('团队技能目录格式无效。')
+  const { root, conflicts } = await safeRoot()
+  return Promise.all(skills.map(async (skill) => {
+    if (!safeName(skill.dsh_name) || !validHash(skill.content_sha256)) throw new Error('团队技能目录含无效条目。')
+    let local_status = conflicts.has(skill.dsh_name) ? 'conflict' : 'not-installed'
+    if (local_status === 'conflict') return { ...skill, local_status }
+    try {
+      const marker = await readManaged(root, skill.dsh_name)
+      if (marker) {
+        await verifyManagedTree(root, skill.dsh_name, marker)
+        if (marker.service_url !== connection.serviceUrl) throw new Error('该目录属于另一个 ANT 服务。')
+        local_status = marker.content_sha256 === skill.content_sha256 ? 'installed' : 'update-available'
+      }
+    } catch { local_status = 'conflict' }
+    if (local_status === 'installed' || local_status === 'update-available') {
+      try { await assertDiscovered(registry, root, skill.dsh_name) }
+      catch { local_status = 'not-discovered' }
+    }
+    return { ...skill, local_status }
+  }))
+}
+
+function validateManifest(manifest, skillId) {
+  if (manifest?.skill_id !== skillId || !safeName(manifest.dsh_name) || !validHash(manifest.content_sha256)
+    || !validHash(manifest.package_sha256) || !Number.isInteger(manifest.package_size)
+    || manifest.package_size < 1 || manifest.package_size > MAX_PACKAGE_BYTES
+    || !Array.isArray(manifest.files) || manifest.files.length < 1 || manifest.files.length > MAX_FILES) {
+    throw new Error('团队技能文件清单无效。')
+  }
+  const seen = new Set()
+  let total = 0
+  for (const file of manifest.files) {
+    if (!safePath(file.path) || !validHash(file.sha256) || !Number.isInteger(file.file_size)
+      || file.file_size < 0 || file.file_size > MAX_FILE_BYTES || typeof file.executable !== 'boolean'
+      || seen.has(file.path)) throw new Error('团队技能文件清单无效。')
+    seen.add(file.path)
+    total += file.file_size
+    if (total > MAX_TOTAL_BYTES) throw new Error('技能总大小超过上限。')
+  }
+  if (!seen.has('SKILL.md')) throw new Error('技能目录缺少 SKILL.md。')
+}
+
+function contentDigest(files) {
+  const digest = createHash('sha256')
+  for (const file of [...files].sort((left, right) => Buffer.compare(Buffer.from(left.path), Buffer.from(right.path)))) {
+    const pathBytes = Buffer.from(file.path)
+    const length = Buffer.alloc(8)
+    length.writeBigUInt64BE(BigInt(pathBytes.length)); digest.update(length); digest.update(pathBytes)
+    length.writeBigUInt64BE(BigInt(file.content.length)); digest.update(length)
+    digest.update(Buffer.from([Number(file.executable)])); digest.update(file.content)
+  }
+  return digest.digest('hex')
+}
+
+export async function installSkill(connection, skillId, registry) {
+  if (typeof skillId !== 'string' || !/^[0-9a-f-]{36}$/iu.test(skillId)) throw new Error('技能编号无效。')
+  const manifest = await fetchJson(new URL(`/api/me/skills/${skillId}/files`, connection.serviceUrl), connection.token)
+  validateManifest(manifest, skillId)
+  const { root, conflicts } = await safeRoot()
+  if (conflicts.has(manifest.dsh_name)) throw new Error('本机技能备份已损坏；请联系管理员处理，ANT 不会覆盖。')
+  if (activeSkills.has(manifest.dsh_name)) throw new Error('这个技能正在安装或卸载，请稍后重试。')
+  activeSkills.add(manifest.dsh_name)
+  try { return await installValidatedSkill(connection, skillId, manifest, root, registry) }
+  finally { activeSkills.delete(manifest.dsh_name) }
+}
+
+async function installValidatedSkill(connection, skillId, manifest, root, registry) {
+  const target = join(root, manifest.dsh_name)
+  const oldMarker = await readManaged(root, manifest.dsh_name)
+  if (oldMarker) {
+    if (oldMarker.service_url !== connection.serviceUrl) throw new Error('同名技能属于另一个 ANT 服务，无法覆盖。')
+    await verifyManagedTree(root, manifest.dsh_name, oldMarker)
+    if (oldMarker.content_sha256 === manifest.content_sha256) {
+      await assertDiscovered(registry, root, manifest.dsh_name)
+      return { status: 'installed', dsh_name: manifest.dsh_name }
+    }
+  }
+
+  const packageUrl = new URL(`/api/me/skills/${skillId}/package`, connection.serviceUrl)
+  const packageResponse = await fetch(packageUrl, { headers: { authorization: `Bearer ${connection.token}` }, redirect: 'manual', signal: AbortSignal.timeout(120_000) })
+  const packageBytes = await boundedBytes(packageResponse, manifest.package_size)
+  if (packageBytes.length !== manifest.package_size || hash(packageBytes) !== manifest.package_sha256) {
+    throw new Error('技能包校验失败，未安装。')
+  }
+  let unpacked
+  try { unpacked = gunzipSync(packageBytes, { maxOutputLength: MAX_TOTAL_BYTES }) }
+  catch { throw new Error('技能包解压失败或超过大小上限，未安装。') }
+  const files = []
+  let offset = 0
+  for (const file of manifest.files) {
+    const content = unpacked.subarray(offset, offset + file.file_size)
+    if (content.length !== file.file_size || hash(content) !== file.sha256) throw new Error('技能文件校验失败，未安装。')
+    files.push({ ...file, content })
+    offset += file.file_size
+  }
+  if (offset !== unpacked.length) throw new Error('技能包文件数量与清单不符，未安装。')
+  if (contentDigest(files) !== manifest.content_sha256) throw new Error('技能整体校验失败，未安装。')
+
+  const stagingRoot = join(dirname(root), '.ant-skill-staging')
+  const stagingStat = await isPresent(stagingRoot)
+  if (stagingStat && (!stagingStat.isDirectory() || stagingStat.isSymbolicLink())) throw new Error('ANT 暂存目录不是普通目录。')
+  await mkdir(stagingRoot, { recursive: true, mode: 0o700 })
+  const staging = join(stagingRoot, `new-${randomUUID()}`)
+  const backup = join(stagingRoot, `old-${manifest.dsh_name}-${randomUUID()}`)
+  await mkdir(staging, { mode: 0o700 })
+  let backedUp = false
+  let installedNew = false
+  try {
+    for (const file of files) {
+      const destination = join(staging, ...file.path.split('/'))
+      await mkdir(dirname(destination), { recursive: true, mode: 0o700 })
+      await writeFile(destination, file.content, { flag: 'wx', mode: file.executable ? 0o700 : 0o600 })
+      if (file.executable && process.platform !== 'win32') await chmod(destination, 0o700)
+    }
+    await writeFile(join(staging, MARKER), JSON.stringify({
+      dsh_name: manifest.dsh_name, skill_id: skillId, service_url: connection.serviceUrl,
+      content_sha256: manifest.content_sha256,
+      files: manifest.files.map(({ path, sha256, executable }) => ({ path, sha256, executable })),
+    }), { flag: 'wx', mode: 0o600 })
+    if (oldMarker) { await verifyManagedTree(root, manifest.dsh_name, oldMarker); await rename(target, backup); backedUp = true }
+    else if (await isPresent(target)) throw new Error('同名技能已经存在，ANT 不会覆盖。')
+    await rename(staging, target)
+    installedNew = true
+    await assertDiscovered(registry, root, manifest.dsh_name)
+    if (backedUp) await rm(backup, { recursive: true }).catch(() => {})
+    return { status: oldMarker ? 'updated' : 'installed', dsh_name: manifest.dsh_name }
+  } catch (error) {
+    if (backedUp && await isPresent(backup)) {
+      if (await isPresent(target)) {
+        await verifyManagedTree(root, manifest.dsh_name, {
+          dsh_name: manifest.dsh_name,
+          files: manifest.files.map(({ path, sha256, executable }) => ({ path, sha256, executable })),
+        }).then(() => rename(target, staging)).catch(() => {})
+      }
+      if (!(await isPresent(target))) await rename(backup, target).catch(() => {})
+    } else if (installedNew) {
+      await verifyManagedTree(root, manifest.dsh_name, {
+        dsh_name: manifest.dsh_name,
+        files: manifest.files.map(({ path, sha256, executable }) => ({ path, sha256, executable })),
+      }).then(() => rm(target, { recursive: true })).catch(() => {})
+    }
+    throw error
+  } finally { await rm(staging, { recursive: true, force: true }).catch(() => {}) }
+}
+
+export async function uninstallSkill(name) {
+  if (!safeName(name)) throw new Error('技能名称无效。')
+  const { root, conflicts } = await safeRoot()
+  if (conflicts.has(name)) throw new Error('本机技能备份已损坏；请联系管理员处理，ANT 不会删除。')
+  if (activeSkills.has(name)) throw new Error('这个技能正在安装或卸载，请稍后重试。')
+  activeSkills.add(name)
+  try { return await uninstallManagedSkill(root, name) }
+  finally { activeSkills.delete(name) }
+}
+
+async function uninstallManagedSkill(root, name) {
+  const marker = await readManaged(root, name)
+  if (!marker) return { status: 'not-installed', dsh_name: name }
+  await verifyManagedTree(root, name, marker)
+  const stagingRoot = join(dirname(root), '.ant-skill-staging')
+  const stagingStat = await isPresent(stagingRoot)
+  if (stagingStat && (!stagingStat.isDirectory() || stagingStat.isSymbolicLink())) throw new Error('ANT 暂存目录不是普通目录。')
+  await mkdir(stagingRoot, { recursive: true, mode: 0o700 })
+  const removed = join(stagingRoot, `removed-${name}-${randomUUID()}`)
+  await rename(join(root, name), removed)
+  try { await rm(removed, { recursive: true }) }
+  catch { throw new Error('技能已从 DSH 目录移出，但暂存文件清理失败；请联系管理员处理。') }
+  return { status: 'uninstalled', dsh_name: name }
+}