dsh-plugin-dynamic-competition-four-images 1.1.0 → 1.2.0

package/README.md

@@ -2,86 +2,77 @@
 
 基于动态竞争理论构建的 DSH（DeepSeek Harness）插件，经过以「四象模型」为框架的改进，提供六维动态竞争评分能力。
 
-**自 1.1.0 起，技能以「工作区技能」交付，不再写入全局技能目录。**
+**自 1.2.0 起：插件全局安装，插件内的技能由用户按工作区选择性添加**（设置 → 插件 → 四象模型），技能只写入被选择的工作区，不会成为全局技能。
 
 ## ✨ 核心能力
 
 - 六维动态竞争评分（主 / 环 / 位 / 行 / 才 / 心）。
 - AMC 张力分析、多点克制逻辑与十三项自检机制。
-- 技能正文：`.dsh/skills/dynamic-competition-analysis-four-images-model/SKILL.md`。
+- 技能正文：包内 `skills/dynamic-competition-analysis-four-images-model/SKILL.md`。
 
-## 🗂️ 工作区技能的分层
-
-DSH 的技能来自两级目录，本插件只使用工作区一级：
-
-| 层级 | 目录 | 来源标记 | 本插件的做法 |
-|---|---|---|---|
-| 全局技能 | `<DSH_HOME>/skills`（如 `~/.dsh/skills`） | `user-dsh` | **不再写入**，也不注册全局技能 |
-| 工作区技能 | `<项目根>/.dsh/skills` 或 `<项目根>/.agents/skills` | `project-dsh` / `project-agents` | 技能本体随包发布于此；插件也只在配置的工作区提供它 |
-
-项目根 = 最近的含 `.git` 的祖先目录；没有 `.git` 时取会话工作目录。
-
-## 🚀 安装与配置
+## 🚀 安装
 
 ### 方式一：通过包名安装（推荐）
 
-1. 在 DSH 插件页面点击 **「+ 添加插件」**，输入包名 `dsh-plugin-dynamic-competition-four-images` 并安装、启用。
-2. 在 profile 的 `cordis.patch.yml` 中把插件行限制到指定工作区：
-
-```yaml
-- id: dynamic-competition-four-images
-  config:
-    workspaces:
-      - D:\Path\To\Your\Workspace          # 绝对路径；可写多条
-      # - D:\Another\Workspace
-```
-
-3. 重启 DSH 生效。未配置 `workspaces` 时插件不提供技能（工作区里自带的 `.dsh/skills` 副本仍会被 DSH 原生发现）。
+1. 在 DSH 插件页面点击 **「+ 添加插件」**，输入包名 `dsh-plugin-dynamic-competition-four-images`，安装并启用。
+2. 退出并重启 DSH（宿主半边的技能桥在启动时注册）。
+3. 安装插件**不会**把技能放进任何工作区，需要按下一节手动添加。
 
 ### 方式二：通过自定义插件市场安装
 
-1. 在 DSH 中开启「自定义插件市场」。
-2. 进入「发现」页面，添加索引源 URL：
+1. 开启「自定义插件市场」，添加索引源 URL：
    `https://rootandsource.github.io/dsh-plugin-dynamic-competition-four-images/plugin-index/index.json`
-3. 搜索「动态竞争」或「四象」，点击卡片安装，再按方式一的第 2、3 步配置工作区。
+2. 搜索「动态竞争」或「四象」，点击卡片安装并启用，然后重启 DSH。
 
-### 配置项
+## 🧩 把技能添加到工作区（UI）
 
-| 字段 | 类型 | 默认 | 说明 |
-|---|---|---|---|
-| `workspaces` | `string[]` | `[]` | 允许使用该技能的工作区绝对路径。会话工作目录位于其中时，插件才提供技能；相对路径与空值会被忽略。 |
+打开 **设置 → 插件 → 四象模型** 页签：
 
-## 🔁 从旧版（全局技能）迁移
+1. 在「目标工作区」里选择一个已有工作区，或点「选择其他目录…」挑一个目录；
+   - 状态徽标会显示：未安装 / 有更新可用 / 已是最新。
+2. 点 **「添加到工作区」**。
+3. 成功后会提示写入的文件数，以及安装位置：
+   `<工作区>/.dsh/skills/dynamic-competition-analysis-four-images-model/`。
 
-旧版本把整包复制到 `~/.dsh/skills/dynamic-competition-analysis-four-images-model`，导致技能在每个工作区都可见。迁移只需删除这份全局副本（技能本体已随插件/工作区提供）：
+写入后由 DSH 原生 filesystem provider 以 source `project-dsh` 发现，即成为该工作区的工作区技能；其它工作区与全局技能列表都不受影响。
 
-```powershell
-Remove-Item -Recurse -Force "$env:USERPROFILE\.dsh\skills\dynamic-competition-analysis-four-images-model"
-```
+- **更新**：插件升级后再次点击「添加到工作区」，只会覆盖有变化的文件（内容一致的会跳过）。
+- **移除**：删除该工作区里的 `.dsh/skills/dynamic-competition-analysis-four-images-model/` 目录即可。
+
+## 🔁 从旧版（全局技能）迁移
 
-删除后，`~/.dsh/skills` 目录本身保留，不再出现 `dynamic-competition-analysis-four-images-model`。
+1.1.x 及更早版本把技能复制到 `~/.dsh/skills/`，或按工作区路径自动提供技能。升级到 1.2.0 后：
 
-## 🧪 校验
+- 删除旧全局副本（如果还在）：
+  ```powershell
+  Remove-Item -Recurse -Force "$env:USERPROFILE\.dsh\skills\dynamic-competition-analysis-four-images-model"
+  ```
+- 旧版 `workspaces` 配置项已废弃，`cordis.patch.yml` 里针对本插件的 `config.workspaces` 可以删掉。
+- 需要在某个工作区使用技能时，用上面的 UI 重新添加。
 
-在仓库会话中，该技能应显示为工作区技能（来源 `project-dsh`）：
+## 🧪 校验与开发
 
 ```powershell
-node --test test/            # 或在受限沙箱中：node test/workspace-gate.test.mjs
-npm pack --dry-run           # 确认 .dsh/skills 随包发布
+node test/skill-installer.test.mjs   # 受限沙箱下请直接运行单文件（node --test test/ 会因 spawn EPERM 失败）
+npm pack --dry-run                   # 确认 index.js / client.js / skills / locale / icon 随包发布
 ```
 
-单元测试覆盖：frontmatter 解析、工作区路径匹配（含 Windows 大小写）、未配置工作区时不注册、工作区外不可见、工作区已有原生副本时不重复提供。
+测试覆盖：frontmatter 解析、技能发现（目录名与 name 一致）、工作区路径校验、文件复制/状态判定（缺失、过期、最新、保留工作区额外文件）、桥路由的 loopback 与只读校验、错误码。
 
 ## 📁 目录结构
 
 ```
 dsh-plugin-dynamic-competition-four-images/
-├── index.js                  # 按 workspaces 门控的技能提供者（不注册全局技能）
-├── cordis.patch.yml          # bundle 行：workspaces 默认空
-├── package.json              # dsh.bundle 清单与 files
-├── test/workspace-gate.test.mjs
+├── index.js                  # 宿主：技能发现 + loopback 桥（describe / install）
+├── client.js                 # 客户端：设置 → 插件 → 四象模型 页签
+├── cordis.patch.yml          # bundle 行
+├── locale/{zh,en}.json       # 插件显示名与描述
+├── icon.svg                  # 插件图标
+├── package.json              # dsh.bundle.patch + dsh.client
+├── test/skill-installer.test.mjs
+├── release/                  # 打包产物（当前 + 历史版本 tarball）
 ├── plugin-index/             # 自定义插件市场索引
-└── .dsh/skills/dynamic-competition-analysis-four-images-model/
+├── skills/dynamic-competition-analysis-four-images-model/
     ├── SKILL.md
     ├── reference/four-images-model-governance.md
     ├── references/full-spec.md

package/client.js

@@ -0,0 +1,441 @@
+/**
+ * dsh-plugin-dynamic-competition-four-images — Client 半边
+ *
+ * 在「设置 → 插件」里增加一个页签：列出插件内的技能，允许用户把它们
+ * 添加到指定工作区（写入 <workspace>/.dsh/skills/<name>/）。数据层走宿主
+ * 的 loopback 桥（见 index.js），不依赖任何 @Remote 命名空间。
+ *
+ * 本文件由 dsh.client 加载，注册工厂 id 必须等于包名。
+ */
+
+window.__ModuleLoader__.load({
+  id: 'dsh-plugin-dynamic-competition-four-images',
+  factory(require) {
+    const React = require('react')
+    const h = React.createElement
+
+    const NS = 'dsh-plugin-dynamic-competition-four-images'
+    const BRIDGE = '/api/dsh-plugin-dynamic-competition-four-images'
+    const SLOT = 'settings.plugins.tab'
+
+    const ZH = {
+      'tab.label': '四象模型',
+      title: '四象模型分析技能',
+      lead: '把插件内携带的技能安装到指定工作区。安装后技能写入该工作区的 .dsh/skills/，只在该工作区生效，不会成为全局技能。',
+      'workspace.label': '目标工作区',
+      'workspace.placeholder': '选择工作区…',
+      'workspace.pick': '选择其他目录…',
+      'workspace.picking': '选择中…',
+      'workspace.none': '还没有选择工作区',
+      'workspace.custom': '自定义目录',
+      install: '添加到工作区',
+      installing: '正在添加…',
+      'skills.empty': '插件内没有找到可用技能。',
+      'status.unselected': '未选择工作区',
+      'status.missing': '未安装',
+      'status.outdated': '有更新可用',
+      'status.up-to-date': '已是最新',
+      'result.installed': '已添加到工作区',
+      'result.updated': '已更新',
+      'result.unchanged': '内容一致，无需更新',
+      'result.written': '写入 {written} 个文件，共 {total} 个',
+      'result.target': '安装位置：{path}',
+      'error.prefix': '操作失败：',
+      'error.describe': '无法读取插件技能列表',
+      'error.noWorkspace': '请先选择一个工作区',
+      'error.bridge': '宿主桥不可用，请重启 DSH 后重试',
+      version: '版本 {version}',
+      note: '重复添加只会覆盖有变化的文件；删除工作区里的该目录即可移除技能。',
+    }
+
+    const EN = {
+      'tab.label': 'Four Images',
+      title: 'Four Images analysis skill',
+      lead: 'Install the skill shipped with this plugin into a workspace. It is written to that workspace’s .dsh/skills/ and stays scoped to that workspace; it never becomes a global skill.',
+      'workspace.label': 'Target workspace',
+      'workspace.placeholder': 'Choose a workspace…',
+      'workspace.pick': 'Choose another folder…',
+      'workspace.picking': 'Choosing…',
+      'workspace.none': 'No workspace selected yet',
+      'workspace.custom': 'Custom folder',
+      install: 'Add to workspace',
+      installing: 'Adding…',
+      'skills.empty': 'No skill found inside this plugin.',
+      'status.unselected': 'No workspace selected',
+      'status.missing': 'Not installed',
+      'status.outdated': 'Update available',
+      'status.up-to-date': 'Up to date',
+      'result.installed': 'Added to the workspace',
+      'result.updated': 'Updated',
+      'result.unchanged': 'Already up to date',
+      'result.written': '{written} of {total} files written',
+      'result.target': 'Installed at {path}',
+      'error.prefix': 'Failed: ',
+      'error.describe': 'Could not read the skill list',
+      'error.noWorkspace': 'Choose a workspace first',
+      'error.bridge': 'Host bridge unavailable; restart DSH and retry',
+      version: 'Version {version}',
+      note: 'Re-adding only overwrites files that changed; delete that folder in the workspace to remove the skill.',
+    }
+
+    const STATUS_TONE = {
+      missing: 'var(--dsw-alias-state-warn-primary)',
+      outdated: 'var(--dsw-alias-state-warn-primary)',
+      'up-to-date': 'var(--dsw-alias-state-success-primary)',
+      unselected: 'var(--dsw-alias-state-idle-primary)',
+    }
+
+    function format(template, params) {
+      return template.replace(/\{(\w+)\}/g, (whole, key) => (params && key in params ? String(params[key]) : whole))
+    }
+
+    /** 调宿主桥；返回 value，失败抛错。 */
+    async function call(op, body) {
+      const response = await fetch(`${BRIDGE}/${op}`, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify(body ?? {}),
+      })
+      let payload
+      try {
+        payload = await response.json()
+      } catch {
+        throw new Error(`HTTP ${response.status}`)
+      }
+      if (payload === null || typeof payload !== 'object') throw new Error(`HTTP ${response.status}`)
+      if (payload.ok !== true) throw new Error(payload.message || payload.code || `HTTP ${response.status}`)
+      return payload.value
+    }
+
+    function workspaceList(snapshot) {
+      const raw = snapshot && (snapshot.workspaces ?? snapshot.items ?? snapshot)
+      const list = []
+      if (!Array.isArray(raw)) return list
+      for (const item of raw) {
+        if (item === null || typeof item !== 'object') continue
+        const path = typeof item.path === 'string' ? item.path : undefined
+        if (path === undefined || path === '') continue
+        const title = typeof item.title === 'string' && item.title !== '' ? item.title : path
+        list.push({ id: String(item.workspaceId ?? item.id ?? path), title, path })
+      }
+      return list
+    }
+
+    const cardStyle = {
+      border: '1px solid var(--dsw-alias-border-l1)',
+      borderRadius: 12,
+      background: 'var(--dsw-alias-bg-layer-1)',
+      padding: '16px 18px',
+      display: 'grid',
+      gap: 14,
+    }
+
+    const labelStyle = {
+      display: 'block',
+      fontSize: 12,
+      fontWeight: 600,
+      letterSpacing: '0.02em',
+      color: 'var(--dsw-alias-label-secondary)',
+      marginBottom: 6,
+    }
+
+    const boxStyle = {
+      width: '100%',
+      boxSizing: 'border-box',
+      minHeight: 34,
+      padding: '6px 10px',
+      borderRadius: 8,
+      border: '1px solid var(--dsw-alias-border-l2)',
+      background: 'var(--dsw-alias-bg-base)',
+      color: 'var(--dsw-alias-label-primary)',
+      font: 'inherit',
+      fontSize: 13,
+    }
+
+    function buttonStyle(primary, disabled) {
+      return {
+        minHeight: 34,
+        padding: '6px 14px',
+        borderRadius: 8,
+        border: primary ? '1px solid transparent' : '1px solid var(--dsw-alias-border-l2)',
+        background: primary ? 'var(--dsw-alias-brand-primary)' : 'var(--dsw-alias-bg-base)',
+        color: primary ? 'var(--dsw-alias-bg-base)' : 'var(--dsw-alias-label-primary)',
+        font: 'inherit',
+        fontSize: 13,
+        fontWeight: 600,
+        cursor: disabled ? 'default' : 'pointer',
+        opacity: disabled ? 0.55 : 1,
+      }
+    }
+
+    function badgeStyle(tone) {
+      return {
+        display: 'inline-flex',
+        alignItems: 'center',
+        gap: 6,
+        padding: '2px 8px',
+        borderRadius: 999,
+        border: `1px solid ${tone}`,
+        color: tone,
+        fontSize: 12,
+        fontWeight: 600,
+      }
+    }
+
+    return {
+      name: NS,
+      inject: ['slots'],
+      apply(ctx) {
+        const getLocale = () => {
+          try {
+            return typeof ctx.get === 'function' ? ctx.get('locale') : undefined
+          } catch {
+            return undefined
+          }
+        }
+        const localeFace = () => {
+          const live = getLocale()
+          return live !== null && live !== undefined && typeof live.bind === 'function' ? live : null
+        }
+
+        // locale 服务是异步 install 的：apply 时可能还没就绪，所以每次用时再取，
+        // 词典只注册一次（HMR 重复注册会被运行时拒绝，这里静默忽略）。
+        let dictsRegistered = false
+        const ensureDicts = () => {
+          if (dictsRegistered) return
+          const live = localeFace()
+          if (live === null) return
+          dictsRegistered = true
+          try {
+            ctx.effect(() => live.register(NS, { zh: ZH, en: EN }))
+          } catch {
+            // 已有词典（例如插件热更新）时保持现状
+          }
+        }
+
+        const translate = (key, params) => {
+          const live = localeFace()
+          if (live !== null) {
+            try {
+              return format(live.bind(NS)(key, params), params)
+            } catch {
+              // 绑定失败时退回内置中文
+            }
+          }
+          return format(ZH[key] ?? key, params)
+        }
+
+        const uiWorkspace = () => {
+          try {
+            return typeof ctx.get === 'function' ? ctx.get('uiWorkspace') : undefined
+          } catch {
+            return undefined
+          }
+        }
+
+        ensureDicts()
+
+        function Installer(props) {
+          const t = typeof props?.t === 'function' ? (key, params) => format(props.t(key, params), params) : translate
+          const snapshot =
+            props !== null && typeof props?.useWorkspaces === 'function' ? props.useWorkspaces((value) => value) : undefined
+          const workspaces = workspaceList(snapshot)
+
+          const [path, setPath] = React.useState('')
+          const [skills, setSkills] = React.useState([])
+          const [version, setVersion] = React.useState('')
+          const [error, setError] = React.useState(null)
+          const [busy, setBusy] = React.useState(false)
+          const [picking, setPicking] = React.useState(false)
+          const [notice, setNotice] = React.useState(null)
+
+          const refresh = React.useCallback(async (workspacePath) => {
+            try {
+              const value = await call('describe', workspacePath === '' ? {} : { workspacePath })
+              setSkills(Array.isArray(value.skills) ? value.skills : [])
+              setVersion(typeof value.version === 'string' ? value.version : '')
+              setError(null)
+            } catch (failure) {
+              setSkills([])
+              setError(`${t('error.describe')}：${failure instanceof Error ? failure.message : String(failure)}`)
+            }
+          }, [t])
+
+          React.useEffect(() => {
+            let cancelled = false
+            refresh(path).catch(() => {
+              if (!cancelled) setError(t('error.bridge'))
+            })
+            return () => {
+              cancelled = true
+            }
+          }, [path, refresh, t])
+
+          const pickDirectory = async () => {
+            const service = uiWorkspace()
+            if (service === undefined || typeof service.pickDirectory !== 'function') return
+            setPicking(true)
+            try {
+              const picked = await service.pickDirectory()
+              if (typeof picked === 'string' && picked !== '') {
+                setPath(picked)
+                setNotice(null)
+              }
+            } catch (failure) {
+              setNotice({ kind: 'error', text: `${t('error.prefix')}${failure instanceof Error ? failure.message : String(failure)}` })
+            } finally {
+              setPicking(false)
+            }
+          }
+
+          const install = async () => {
+            if (path === '') {
+              setNotice({ kind: 'error', text: t('error.noWorkspace') })
+              return
+            }
+            setBusy(true)
+            setNotice(null)
+            try {
+              const value = await call('install', { workspacePath: path })
+              const tone = value.status === 'unchanged' ? 'warn' : 'ok'
+              const head = t(`result.${value.status}`)
+              const detail = format(t('result.written'), { written: value.written, total: value.total })
+              setNotice({ kind: tone, text: `${head} · ${detail}`, target: format(t('result.target'), { path: value.targetPath }) })
+              await refresh(path)
+            } catch (failure) {
+              setNotice({ kind: 'error', text: `${t('error.prefix')}${failure instanceof Error ? failure.message : String(failure)}` })
+            } finally {
+              setBusy(false)
+            }
+          }
+
+          const options = workspaces.map((workspace) => ({ value: workspace.path, label: `${workspace.title} — ${workspace.path}` }))
+          if (path !== '' && !options.some((option) => option.value === path)) {
+            options.push({ value: path, label: `${t('workspace.custom')} — ${path}` })
+          }
+
+          const noticeTone =
+            notice === null
+              ? 'var(--dsw-alias-label-secondary)'
+              : notice.kind === 'error'
+                ? 'var(--dsw-alias-state-error-primary)'
+                : notice.kind === 'warn'
+                  ? 'var(--dsw-alias-state-warn-primary)'
+                  : 'var(--dsw-alias-state-success-primary)'
+
+          return h('div', { style: { display: 'grid', gap: 16, padding: '8px 0', maxWidth: 760, color: 'var(--dsw-alias-label-primary)' } }, [
+            h('div', { key: 'head' }, [
+              h('div', { key: 'title', style: { fontSize: 16, fontWeight: 600 } }, t('title')),
+              h(
+                'p',
+                { key: 'lead', style: { margin: '6px 0 0', fontSize: 13, lineHeight: 1.6, color: 'var(--dsw-alias-label-secondary)' } },
+                t('lead'),
+              ),
+              version === ''
+                ? null
+                : h(
+                    'p',
+                    { key: 'version', style: { margin: '4px 0 0', fontSize: 12, color: 'var(--dsw-alias-state-idle-primary)' } },
+                    format(t('version'), { version }),
+                  ),
+            ]),
+
+            h('div', { key: 'card', style: cardStyle }, [
+              h('div', { key: 'skills', style: { display: 'grid', gap: 8 } }, [
+                skills.length === 0
+                  ? h('div', { key: 'empty', style: { fontSize: 13, color: 'var(--dsw-alias-label-secondary)' } }, error ?? t('skills.empty'))
+                  : null,
+                ...skills.map((skill) =>
+                  h('div', { key: skill.name, style: { display: 'grid', gap: 4 } }, [
+                    h('div', { key: 'line', style: { display: 'flex', alignItems: 'center', gap: 10, flexWrap: 'wrap' } }, [
+                      h('code', { key: 'name', style: { fontSize: 13, fontWeight: 600 } }, skill.name),
+                      h('span', { key: 'badge', style: badgeStyle(STATUS_TONE[skill.status] ?? STATUS_TONE.unselected) }, t(`status.${skill.status}`)),
+                    ]),
+                    h(
+                      'div',
+                      { key: 'desc', style: { fontSize: 12, lineHeight: 1.6, color: 'var(--dsw-alias-label-secondary)' } },
+                      skill.description,
+                    ),
+                  ]),
+                ),
+              ]),
+
+              h('div', { key: 'picker', style: { display: 'grid', gap: 8 } }, [
+                h('label', { key: 'label', style: labelStyle, htmlFor: `${NS}-workspace` }, t('workspace.label')),
+                h('div', { key: 'row', style: { display: 'flex', gap: 8, flexWrap: 'wrap' } }, [
+                  h(
+                    'select',
+                    {
+                      key: 'select',
+                      id: `${NS}-workspace`,
+                      value: path,
+                      style: { ...boxStyle, flex: '1 1 260px' },
+                      onChange: (event) => {
+                        setPath(event.target.value)
+                        setNotice(null)
+                      },
+                    },
+                    [
+                      h('option', { key: 'placeholder', value: '' }, t('workspace.placeholder')),
+                      ...options.map((option) => h('option', { key: option.value, value: option.value }, option.label)),
+                    ],
+                  ),
+                  h(
+                    'button',
+                    { key: 'pick', type: 'button', style: buttonStyle(false, picking), disabled: picking, onClick: pickDirectory },
+                    picking ? t('workspace.picking') : t('workspace.pick'),
+                  ),
+                ]),
+                path === ''
+                  ? h('div', { key: 'none', style: { fontSize: 12, color: 'var(--dsw-alias-label-secondary)' } }, t('workspace.none'))
+                  : h('div', { key: 'path', style: { fontSize: 12, color: 'var(--dsw-alias-label-secondary)', wordBreak: 'break-all' } }, path),
+              ]),
+
+              h('div', { key: 'actions', style: { display: 'flex', alignItems: 'center', gap: 12, flexWrap: 'wrap' } }, [
+                h(
+                  'button',
+                  {
+                    key: 'install',
+                    type: 'button',
+                    style: buttonStyle(true, busy || path === '' || skills.length === 0),
+                    disabled: busy || path === '' || skills.length === 0,
+                    onClick: install,
+                  },
+                  busy ? t('installing') : t('install'),
+                ),
+                notice === null
+                  ? null
+                  : h(
+                      'div',
+                      { key: 'notice', style: { fontSize: 12, lineHeight: 1.6, color: noticeTone, display: 'grid', gap: 2 } }, [
+                        h('div', { key: 'text' }, notice.text),
+                        notice.target === undefined ? null : h('div', { key: 'target', style: { color: 'var(--dsw-alias-label-secondary)', wordBreak: 'break-all' } }, notice.target),
+                      ],
+                    ),
+              ]),
+
+              h(
+                'p',
+                { key: 'note', style: { margin: 0, fontSize: 12, lineHeight: 1.6, color: 'var(--dsw-alias-label-secondary)' } },
+                t('note'),
+              ),
+            ]),
+          ])
+        }
+
+        ctx.slots.inject(SLOT, () => {
+          // 设置面板打开时 locale 一定已就绪：补充注册词典，并按现状决定 locale 席位
+          ensureDicts()
+          const registration = {
+            name: SLOT,
+            id: 'dynamic-competition-four-images',
+            order: 40,
+            label: () => translate('tab.label'),
+            ...(localeFace() === null ? {} : { locale: NS }),
+          }
+          return ctx.slots.register(registration, Installer)
+        })
+      },
+    }
+  },
+})

package/cordis.patch.yml

@@ -1,17 +1,8 @@
 # dsh-plugin-dynamic-competition-four-images bundle patch.
 #
-# 该插件只按 config.workspaces 指定的工作区提供「动态竞争·四象模型」技能，
-# 不注册全局技能。
-#
-# 在 profile 的 cordis.patch.yml 里覆盖本行的 config 即可启用指定工作区：
-#
-#   - id: dynamic-competition-four-images
-#     config:
-#       workspaces:
-#         - D:\Path\To\Your\Workspace
-#
+# 插件本身全局安装；技能不会自动出现在任何工作区。
+# 用户在「设置 → 插件 → 四象模型」页签里选择目标工作区，点击“添加到工作区”，
+# 宿主才把技能写入 <workspace>/.dsh/skills/<name>/。
 - insert:
     - id: dynamic-competition-four-images
       name: dsh-plugin-dynamic-competition-four-images
-      config:
-        workspaces: []

package/icon.svg

@@ -0,0 +1,13 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" width="64" height="64" role="img" aria-label="Four Images">
+  <rect width="64" height="64" rx="14" fill="#0f172a"/>
+  <g fill="none" stroke="#e6edf7" stroke-width="2" opacity="0.85">
+    <rect x="14" y="14" width="16" height="16" rx="4"/>
+    <rect x="34" y="14" width="16" height="16" rx="4"/>
+    <rect x="14" y="34" width="16" height="16" rx="4"/>
+    <rect x="34" y="34" width="16" height="16" rx="4"/>
+  </g>
+  <path d="M22 22h.01" stroke="#7dd3fc" stroke-width="8" stroke-linecap="round"/>
+  <path d="M42 22h.01" stroke="#fbbf24" stroke-width="8" stroke-linecap="round"/>
+  <path d="M22 42h.01" stroke="#f87171" stroke-width="8" stroke-linecap="round"/>
+  <path d="M42 42h.01" stroke="#34d399" stroke-width="8" stroke-linecap="round"/>
+</svg>

package/index.js

@@ -1,332 +1,317 @@
 /**
- * dsh-plugin-dynamic-competition-four-images
+ * dsh-plugin-dynamic-competition-four-images — 宿主半边
  *
- * 把「动态竞争分析·四象模型」技能以 **工作区技能** 的方式交付。
+ * 插件本身安装在 DSH profile（全局）。它不注册任何全局技能，也不自动把技能
+ * 注入工作区；只提供两个 loopback 桥接口，供 Client 半边的设置页使用：
  *
- * 交付方式（二选一，互不冲突）：
- * 1. 技能本体随包发布在 `.dsh/skills/dynamic-competition-analysis-four-images-model/`，
- *    工作区中的会话由 DSH 原生 filesystem provider 以 source `project-dsh` 发现；
- * 2. 本插件按 `config.workspaces` 指定的工作区提供同一份技能，供未把技能文件
- *    放进工作区、但已安装本插件的场景使用。
+ *   POST /api/dsh-plugin-dynamic-competition-four-images/describe
+ *   POST /api/dsh-plugin-dynamic-competition-four-images/install
  *
- * 本插件**不注册全局技能**：只有会话工作目录位于已配置的工作区内时才提供技能，
- * 因此不会出现在其他工作区或全局技能列表中。
+ * `install` 把包内 `.dsh/skills/<name>/` 复制到用户选择的工作区
+ * `<workspace>/.dsh/skills/<name>/`，此后由 DSH 原生 filesystem provider 以
+ * source `project-dsh` 发现，即成为该工作区的工作区技能。
  *
  * @module dsh-plugin-dynamic-competition-four-images
  */
 
-import { readFile, stat } from 'node:fs/promises'
-import { dirname, isAbsolute, join, relative, resolve, sep } from 'node:path'
+import { mkdir, readdir, readFile, stat, writeFile } from 'node:fs/promises'
+import { dirname, isAbsolute, join, resolve } from 'node:path'
 import { fileURLToPath } from 'node:url'
 
 /** Cordis 插件名。 */
 export const name = 'dynamic-competition-four-images'
 
-/** 技能注册表是本插件唯一的 Service 依赖。 */
-export const inject = ['skills']
-
-/** 技能名，与 SKILL.md frontmatter 的 `name` 一致。 */
-const SKILL_NAME = 'dynamic-competition-analysis-four-images-model'
-const SKILLS_ROOT = fileURLToPath(new URL('./.dsh/skills/', import.meta.url))
-const SKILL_DIR = join(SKILLS_ROOT, SKILL_NAME)
-const SKILL_FILE = join(SKILL_DIR, 'SKILL.md')
-const PROVIDER_NAME = 'dynamic-competition-four-images'
-/** 工作区技能的优先级：低于原生 project-dsh（100），与 bundled（600）区分。 */
-const PROJECT_SKILL_RANK = 700
-/** 以工作区技能来源上报，使界面把它当工作区技能而非全局技能。 */
-const SKILL_SOURCE = 'project-dsh'
+const PACKAGE_ROOT = fileURLToPath(new URL('./', import.meta.url))
+/** 包内技能源目录：随包发布的技能本体（普通目录，避免依赖 .dsh 路径）。 */
+export const SKILLS_ROOT = join(PACKAGE_ROOT, 'skills')
+const BRIDGE_PREFIX = '/api/dsh-plugin-dynamic-competition-four-images'
+const MAX_JSON_BODY_BYTES = 64 * 1024
 const NAME_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/
 
-/**
- * 注册技能提供者。仅在存在已配置工作区时注册，避免产生任何全局技能。
- * @param {import('@deepseek-ai/cordis').Context} ctx
- * @param {{ workspaces?: unknown }} [config]
- */
-export function apply(ctx, config) {
-  const { workspaces, ignored } = normalizeWorkspaces(config)
-  if (ignored.length > 0) {
-    warn(ctx, `忽略 ${ignored.length} 条无效的 workspaces 配置（只接受非空绝对路径）：${ignored.join('，')}`)
-  }
-  if (workspaces.length === 0) {
-    warn(ctx, '未配置 workspaces，本插件不提供技能；工作区 .dsh/skills 下的副本仍由 DSH 原生发现。')
-    return
+/** 业务错误：桥接口把它翻译成 4xx + code。 */
+export class BridgeError extends Error {
+  constructor(code, message) {
+    super(message)
+    this.name = 'BridgeError'
+    this.code = code
   }
+}
 
-  return ctx.skills.registerProvider(() => ({
-    name: PROVIDER_NAME,
+/** 注册 loopback 路由；webServer 缺席时静默不启用。 */
+export function apply(ctx) {
+  ctx.inject(['webServer'], (sctx) => {
+    sctx.effect(() => {
+      const disposers = createBridgeRoutes().map((route) => sctx.webServer.register(route))
+      return () => {
+        for (const dispose of disposers) dispose()
+      }
+    }, 'dynamic-competition-four-images: skill bridge')
+  })
+}
 
-    async list(options) {
-      const candidate = await workspaceCandidate(options, workspaces, ctx)
-      return candidate === undefined ? [] : [candidate]
-    },
+/** 组出桥路由（供 webServer.register 与单测使用）。 */
+export function createBridgeRoutes(options = {}) {
+  const skillsRoot = options.skillsRoot ?? SKILLS_ROOT
+  return [
+    defineRoute('/describe', async (body) => {
+      const skills = await readSkills(skillsRoot)
+      let workspacePath
+      if (typeof body?.workspacePath === 'string' && body.workspacePath.trim() !== '') {
+        workspacePath = await resolveWorkspace(body.workspacePath)
+      }
+      const list = []
+      for (const skill of skills) {
+        list.push({
+          name: skill.name,
+          description: skill.description,
+          status: workspacePath === undefined ? 'unselected' : await skillStatus(skill, workspacePath),
+        })
+      }
+      return { version: await packageVersion(), workspacePath: workspacePath ?? null, skills: list }
+    }),
 
-    async get(candidate, options) {
-      options?.signal?.throwIfAborted()
-      if (candidate === undefined || candidate.name !== SKILL_NAME) return undefined
-      const skill = await loadSkill(options?.signal)
-      return skill === undefined ? undefined : toDefinition(skill)
-    },
-  }))
+    defineRoute('/install', async (body) => {
+      const workspacePath = await resolveWorkspace(body?.workspacePath)
+      const skills = await readSkills(skillsRoot)
+      const wanted = typeof body?.skillName === 'string' ? body.skillName : skills[0]?.name
+      const skill = skills.find((entry) => entry.name === wanted)
+      if (skill === undefined) {
+        throw new BridgeError('skill-not-found', `插件内没有名为 ${String(wanted)} 的技能`)
+      }
+      const before = await skillStatus(skill, workspacePath)
+      const copied = await installSkill(skill, workspacePath)
+      return {
+        skillName: skill.name,
+        workspacePath,
+        targetPath: copied.target,
+        status: copied.written === 0 ? 'unchanged' : before === 'missing' ? 'installed' : 'updated',
+        written: copied.written,
+        unchanged: copied.unchanged,
+        total: copied.total,
+      }
+    }),
+  ]
 }
 
-/**
- * 归一化 `workspaces` 配置：只接受非空绝对路径，去重并保持顺序。
- * @param {{ workspaces?: unknown }} [config]
- * @returns {{ workspaces: string[], ignored: string[] }}
- */
-export function normalizeWorkspaces(config) {
-  const raw = config?.workspaces
-  const entries = Array.isArray(raw) ? raw : []
-  const workspaces = []
-  const ignored = []
-  const seen = new Set()
+/** 读取包内全部技能（目录名必须与 frontmatter name 一致）。 */
+export async function readSkills(root = SKILLS_ROOT) {
+  const entries = await readdir(root, { withFileTypes: true }).catch(() => [])
+  const skills = []
   for (const entry of entries) {
-    if (typeof entry !== 'string') {
-      ignored.push(String(entry))
+    if (!entry.isDirectory() && !entry.isSymbolicLink()) continue
+    const directory = join(root, entry.name)
+    let raw
+    try {
+      raw = await readFile(join(directory, 'SKILL.md'), 'utf8')
+    } catch {
       continue
     }
-    const trimmed = entry.trim()
-    if (trimmed === '' || !isAbsolute(trimmed)) {
-      ignored.push(trimmed === '' ? '(空字符串)' : trimmed)
-      continue
-    }
-    const resolved = resolve(trimmed)
-    const key = normalizeForCompare(resolved)
-    if (seen.has(key)) continue
-    seen.add(key)
-    workspaces.push(resolved)
+    const parsed = parseSkillMarkdown(raw)
+    if (parsed === undefined || parsed.name !== entry.name) continue
+    skills.push({ name: parsed.name, description: parsed.description, directory })
   }
-  return { workspaces, ignored }
+  return skills.sort((left, right) => left.name.localeCompare(right.name))
 }
 
-/**
- * 判断 `inner` 是否等于 `outer` 或位于其下（大小写不敏感地适配 Windows）。
- * @param {string} inner
- * @param {string} outer
- */
-export function isInside(inner, outer) {
-  const from = normalizeForCompare(resolve(outer))
-  const to = normalizeForCompare(resolve(inner))
-  const rel = relative(from, to)
-  if (rel === '') return true
-  if (rel === '..' || rel.startsWith(`..${sep}`)) return false
-  return !isAbsolute(rel)
+/** 目标工作区里该技能的状态：missing / outdated / up-to-date。 */
+export async function skillStatus(skill, workspacePath) {
+  return skillStatusAt(skill, targetDirectory(skill.name, workspacePath))
 }
 
-/**
- * 解析一份技能 Markdown（frontmatter + 正文），不做文件 IO，便于单测。
- * @param {string} raw
- * @returns {{ name: string, description: string, whenToUse?: string, invocation: { modelInvocable: boolean, userInvocable: boolean }, content: string } | undefined}
- */
-export function parseSkill(raw) {
-  const parts = splitFrontmatter(raw)
-  if (parts === undefined) return undefined
-  const data = parseFrontmatter(parts.yaml)
-  const skillName = scalarField(data.name)
-  const description = scalarField(data.description)
-  const whenToUse = scalarField(data.whenToUse)
-  if (skillName === undefined || description === undefined) return undefined
-  if (!NAME_PATTERN.test(skillName)) return undefined
-
-  const disableModelInvocation = parseBooleanFlag(data['disable-model-invocation'])
-  const userInvocable = parseBooleanFlag(data['user-invocable'])
-  // 缺省合法（undefined），非法拼写按 DSH 约定整条丢弃。
-  if (disableModelInvocation === null || userInvocable === null) return undefined
-
-  return {
-    name: skillName,
-    description,
-    ...(whenToUse === undefined ? {} : { whenToUse }),
-    invocation: {
-      modelInvocable: !(disableModelInvocation ?? false),
-      userInvocable: userInvocable ?? true,
-    },
-    content: parts.body.trim(),
+/** 目标目录里该技能的状态（测试与复用入口）。 */
+export async function skillStatusAt(skill, target) {
+  const exists = await directoryExists(target)
+  if (!exists) return 'missing'
+  let differing = 0
+  for (const file of await walkFiles(skill.directory)) {
+    const source = await readFile(file.absolute).catch(() => undefined)
+    const current = await readFile(join(target, file.relative)).catch(() => undefined)
+    if (source === undefined || current === undefined || !source.equals(current)) differing += 1
   }
+  return differing === 0 ? 'up-to-date' : 'outdated'
 }
 
-/** 技能文件路径，测试与诊断用。 */
-export const skillFile = SKILL_FILE
-
-/** 读取技能文件；缺失或不可读时返回 undefined。 */
-async function loadSkill(signal) {
-  signal?.throwIfAborted()
-  let raw
-  try {
-    raw = await readFile(SKILL_FILE, 'utf8')
-  } catch {
-    return undefined
-  }
-  signal?.throwIfAborted()
-  return parseSkill(raw)
+/** 把技能复制进工作区；返回写入/未变/总数。 */
+export async function installSkill(skill, workspacePath) {
+  return copySkillTo(skill, targetDirectory(skill.name, workspacePath))
 }
 
-/**
- * 判断当前会话是否应拿到技能候选：
- * 工作目录必须在已配置工作区内，且该工作区的 `.dsh/skills` 里没有原生副本
- * （有副本时交给 DSH 原生 provider，避免同名重复）。
- */
-async function workspaceCandidate(options, workspaces, ctx) {
-  const cwd = options?.cwd
-  if (typeof cwd !== 'string' || cwd.trim() === '') return undefined
-  const directory = resolve(cwd)
-  if (!workspaces.some((root) => isInside(directory, root))) return undefined
-  if (await hasNativeSkill(directory)) return undefined
-
-  const skill = await loadSkill(options?.signal)
-  if (skill === undefined) {
-    warn(ctx, `无法读取技能文件：${SKILL_FILE}`)
-    return undefined
+/** 把技能复制到目标目录（测试与复用入口）；只覆盖有变化的文件。 */
+export async function copySkillTo(skill, target) {
+  const files = await walkFiles(skill.directory)
+  let written = 0
+  let unchanged = 0
+  for (const file of files) {
+    const destination = join(target, file.relative)
+    const source = await readFile(file.absolute)
+    const current = await readFile(destination).catch(() => undefined)
+    if (current !== undefined && current.equals(source)) {
+      unchanged += 1
+      continue
+    }
+    await mkdir(dirname(destination), { recursive: true })
+    await writeFile(destination, source)
+    written += 1
   }
-  return toCandidate(skill)
+  return { target, written, unchanged, total: files.length }
 }
 
-/** 工作区（项目根）里是否已有该技能的原生副本。 */
-async function hasNativeSkill(directory) {
-  const root = await projectRootOf(directory)
-  const skillsRoot = join(root, '.dsh', 'skills')
-  return (
-    (await fileExists(join(skillsRoot, SKILL_NAME, 'SKILL.md'))) ||
-    (await fileExists(join(skillsRoot, `${SKILL_NAME}.md`)))
-  )
+/** 工作区技能目标目录：<workspace>/.dsh/skills/<name>。 */
+function targetDirectory(skillName, workspacePath) {
+  return join(workspacePath, '.dsh', 'skills', skillName)
 }
 
-/** 最近的含 `.git` 的祖先目录；没有则回退为当前目录。 */
-async function projectRootOf(directory) {
-  let current = directory
-  for (;;) {
-    if (await fileExists(join(current, '.git'))) return current
-    const parent = dirname(current)
-    if (parent === current) return directory
-    current = parent
+/** 校验并规范化用户给出的工作区路径。 */
+export async function resolveWorkspace(input) {
+  if (typeof input !== 'string' || input.trim() === '') {
+    throw new BridgeError('workspace-required', '缺少工作区路径')
+  }
+  const trimmed = input.trim()
+  if (!isAbsolute(trimmed)) {
+    throw new BridgeError('workspace-not-absolute', '工作区路径必须是绝对路径')
+  }
+  const path = resolve(trimmed)
+  const info = await stat(path).catch(() => undefined)
+  if (info === undefined || !info.isDirectory()) {
+    throw new BridgeError('workspace-not-found', '工作区目录不存在或不是目录')
   }
+  return path
 }
 
-async function fileExists(path) {
+async function packageVersion() {
   try {
-    await stat(path)
-    return true
+    const raw = await readFile(join(PACKAGE_ROOT, 'package.json'), 'utf8')
+    const parsed = JSON.parse(raw)
+    return typeof parsed.version === 'string' ? parsed.version : '0.0.0'
   } catch {
-    return false
-  }
-}
-
-function toCandidate(skill) {
-  return {
-    name: skill.name,
-    description: skill.description,
-    ...(skill.whenToUse === undefined ? {} : { whenToUse: skill.whenToUse }),
-    invocation: skill.invocation,
-    provider: PROVIDER_NAME,
-    source: SKILL_SOURCE,
-    resourceBase: { kind: 'directory', path: SKILL_DIR },
-    rank: PROJECT_SKILL_RANK,
-    locator: { skillFile: SKILL_FILE },
-    path: SKILL_FILE,
+    return '0.0.0'
   }
 }
 
-function toDefinition(skill) {
-  return {
-    name: skill.name,
-    description: skill.description,
-    ...(skill.whenToUse === undefined ? {} : { whenToUse: skill.whenToUse }),
-    invocation: skill.invocation,
-    provider: PROVIDER_NAME,
-    source: SKILL_SOURCE,
-    resourceBase: { kind: 'directory', path: SKILL_DIR },
-    path: SKILL_FILE,
-    content: skill.content,
+async function walkFiles(directory, prefix = '') {
+  const entries = await readdir(join(directory, prefix), { withFileTypes: true })
+  const files = []
+  for (const entry of entries) {
+    const relative = prefix === '' ? entry.name : `${prefix}/${entry.name}`
+    if (entry.isDirectory()) {
+      files.push(...(await walkFiles(directory, relative)))
+      continue
+    }
+    if (entry.isFile() || entry.isSymbolicLink()) files.push({ relative, absolute: join(directory, relative) })
   }
+  return files
 }
 
-const BOOLEAN_TRUE = new Set(['true', 'yes', 'on', '1'])
-const BOOLEAN_FALSE = new Set(['false', 'no', 'off', '0'])
-
-/** 解析 YAML 风格布尔值；缺省返回 undefined（调用方决定默认值），非法拼写返回 null。 */
-function parseBooleanFlag(value) {
-  if (value === undefined) return undefined
-  const normalized = String(value).trim().toLowerCase()
-  if (BOOLEAN_TRUE.has(normalized)) return true
-  if (BOOLEAN_FALSE.has(normalized)) return false
-  return null
+async function directoryExists(path) {
+  const info = await stat(path).catch(() => undefined)
+  return info !== undefined && info.isDirectory()
 }
 
-function normalizeForCompare(path) {
-  return process.platform === 'win32' ? path.toLowerCase() : path
+/** loopback 守卫：只接受本机同源 POST。 */
+export function isLoopbackRequest(request) {
+  const address = request?.socket?.remoteAddress
+  if (address !== '127.0.0.1' && address !== '::1' && address !== '::ffff:127.0.0.1') return false
+  const host = request.headers?.host
+  if (typeof host !== 'string') return false
+  let hostUrl
+  try {
+    hostUrl = new URL(`http://${host}`)
+  } catch {
+    return false
+  }
+  if (hostUrl.hostname !== '127.0.0.1' && hostUrl.hostname !== 'localhost' && hostUrl.hostname !== '[::1]') return false
+  if (request.headers['sec-fetch-site'] === 'cross-site') return false
+  const origin = request.headers.origin
+  if (origin === undefined) return true
+  try {
+    return new URL(origin).host === hostUrl.host
+  } catch {
+    return false
+  }
 }
 
-/** 拆出 frontmatter 行与正文；无合法 frontmatter 时返回 undefined。 */
-function splitFrontmatter(raw) {
+/** 解析技能 Markdown 的 frontmatter（本插件只需 name/description）。 */
+export function parseSkillMarkdown(raw) {
   const text = raw.replace(/^\uFEFF/, '')
   const lines = text.split(/\r?\n/)
   if (lines[0]?.trim() !== '---') return undefined
+  let end = -1
   for (let index = 1; index < lines.length; index += 1) {
-    if (lines[index].trim() !== '---') continue
-    return {
-      yaml: lines.slice(1, index),
-      body: lines.slice(index + 1).join('\n'),
+    if (lines[index].trim() === '---') {
+      end = index
+      break
     }
   }
-  return undefined
-}
-
-/** 只解析本技能需要的 YAML 子集：标量、引号、块标量，其余行忽略。 */
-function parseFrontmatter(lines) {
+  if (end < 0) return undefined
   const data = {}
-  let index = 0
-  while (index < lines.length) {
-    const line = lines[index]
-    if (line.trim() === '' || /^\s*#/.test(line)) {
-      index += 1
-      continue
-    }
-    const match = /^([A-Za-z0-9_-]+):(.*)$/.exec(line)
-    if (match === null) {
-      index += 1
-      continue
-    }
-    const key = match[1]
-    const rest = match[2].trim()
-    if (rest === '|' || rest === '>' || rest === '|-' || rest === '>-' || rest === '|+' || rest === '>+') {
-      const block = []
-      index += 1
-      while (index < lines.length && (lines[index].startsWith(' ') || lines[index].startsWith('\t'))) {
-        block.push(lines[index].trim())
-        index += 1
-      }
-      data[key] = rest.startsWith('|') ? block.join('\n') : block.join(' ').replace(/\s+/g, ' ')
-      continue
-    }
-    data[key] = unquote(rest)
-    index += 1
+  for (let index = 1; index < end; index += 1) {
+    const match = /^([A-Za-z0-9_-]+):(.*)$/.exec(lines[index])
+    if (match === null) continue
+    let value = match[2].trim()
+    if (value.startsWith("'") && value.endsWith("'") && value.length >= 2) value = value.slice(1, -1).replaceAll("''", "'")
+    else if (value.startsWith('"') && value.endsWith('"') && value.length >= 2) value = value.slice(1, -1)
+    data[match[1]] = value
   }
-  return data
+  const skillName = typeof data.name === 'string' ? data.name.trim() : ''
+  const description = typeof data.description === 'string' ? data.description.trim() : ''
+  if (skillName === '' || description === '' || !NAME_PATTERN.test(skillName)) return undefined
+  return { name: skillName, description }
 }
 
-function unquote(value) {
-  if (value.length >= 2) {
-    const first = value[0]
-    const last = value[value.length - 1]
-    if (first === last && (first === "'" || first === '"')) {
-      const inner = value.slice(1, -1)
-      return first === "'" ? inner.replaceAll("''", "'") : inner.replaceAll('\\"', '"').replaceAll('\\\\', '\\')
-    }
+function defineRoute(operation, handle) {
+  return {
+    kind: 'exact',
+    path: `${BRIDGE_PREFIX}${operation}`,
+    handler: async (req, res) => {
+      if (!isLoopbackRequest(req)) {
+        writeJson(res, 403, { ok: false, code: 'forbidden', message: 'loopback requests only' })
+        return
+      }
+      if (req.method !== 'POST') {
+        writeJson(res, 405, { ok: false, code: 'method-not-allowed', message: 'POST only' })
+        return
+      }
+      let body
+      try {
+        body = await readJsonBody(req)
+      } catch {
+        writeJson(res, 400, { ok: false, code: 'body-too-large', message: 'JSON body too large' })
+        return
+      }
+      if (body === undefined) {
+        writeJson(res, 400, { ok: false, code: 'bad-json', message: 'JSON body required' })
+        return
+      }
+      try {
+        writeJson(res, 200, { ok: true, value: await handle(body ?? {}) })
+      } catch (error) {
+        const known = error instanceof BridgeError
+        writeJson(res, known ? 400 : 500, {
+          ok: false,
+          code: known ? error.code : 'internal',
+          message: error instanceof Error ? error.message : String(error),
+        })
+      }
+    },
   }
-  return value
 }
 
-function scalarField(value) {
-  if (typeof value !== 'string') return undefined
-  const trimmed = value.trim()
-  return trimmed === '' ? undefined : trimmed
+function writeJson(res, status, body) {
+  res.writeHead(status, { 'content-type': 'application/json; charset=utf-8', 'referrer-policy': 'no-referrer' })
+  res.end(JSON.stringify(body))
 }
 
-function warn(ctx, message) {
+async function readJsonBody(req) {
+  const chunks = []
+  let size = 0
+  for await (const chunk of req) {
+    size += chunk.length
+    if (size > MAX_JSON_BODY_BYTES) throw new Error('body too large')
+    chunks.push(chunk)
+  }
   try {
-    const logger = typeof ctx?.logger === 'function' ? ctx.logger('dynamic-competition-four-images') : undefined
-    logger?.warn?.(message)
+    return JSON.parse(Buffer.concat(chunks).toString('utf8'))
   } catch {
-    // 日志服务不可用时保持静默，不影响技能提供。
+    return undefined
   }
 }

package/locale/en.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "Dynamic Competition · Four Images",
+    "description": "Install the Four Images analysis skill into the workspaces you choose: the plugin is installed globally, while the skill takes effect only where you add it."
+  }
+}

package/locale/zh.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "动态竞争·四象模型",
+    "description": "把四象模型分析技能按需安装到指定工作区：插件全局安装，技能只在你选择添加的工作区生效。"
+  }
+}

package/package.json

@@ -1,18 +1,24 @@
 {
   "name": "dsh-plugin-dynamic-competition-four-images",
-  "version": "1.1.0",
-  "description": "动态竞争·四象模型技能的工作区交付插件：按 config.workspaces 配置，仅在指定工作区提供该技能，不再写入全局技能目录。",
+  "version": "1.2.0",
+  "description": "动态竞争·四象模型技能插件：插件全局安装，技能在「设置 → 插件」里按工作区选择性添加，只写入你选择的工作区。",
   "type": "module",
   "main": "index.js",
   "exports": {
     ".": "./index.js",
+    "./client": "./client.js",
     "./cordis.patch.yml": "./cordis.patch.yml",
+    "./locale/*.json": "./locale/*.json",
+    "./icon": "./icon.svg",
     "./package.json": "./package.json"
   },
   "files": [
     "index.js",
+    "client.js",
     "cordis.patch.yml",
-    ".dsh",
+    "skills",
+    "locale/*.json",
+    "icon.svg",
     "README.md",
     "LICENSE"
   ],
@@ -34,6 +40,10 @@
   "dsh": {
     "bundle": {
       "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "immediately": true
     }
   },
   "author": "",