ygc-dsh-plugin-autoupdate 0.9.5 → 0.9.6

package/README.md

@@ -278,17 +278,19 @@ Electron 的 main / gpu-process / renderer / utility，以及以 `ELECTRON_RUN_A
 ```
 D:\Ai工作空间\插件库\          ← 共享文件夹，两台机器都能读写
 ├─ <本机标识>\                  ← 我的格子，例 DSH-7e6b1bb7e052
-│  ├─ PLUGINS.json             我的插件清单（含副本指纹表）
+│  ├─ PLUGINS.json             我的插件清单（**只有清单，没有任何插件文件**）
 │  ├─ FEATURE.json             我的身份说明
 │  ├─ OTHERS-PLUGINS.json      我的汇总（本机自用）
-│  ├─ OTHERS-PLUGINS.md        同一份的人读版
-│  └─ local\                  本地 / Git 来源插件的 .tgz 副本
+│  └─ OTHERS-PLUGINS.md        同一份的人读版
 └─ <别人的标识>\               ← 别人写，我只读
    ├─ PLUGINS.json
-   ├─ FEATURE.json
-   └─ local\
+   └─ FEATURE.json
 ```
 
+> **0.9.6 起：特征文件夹只存清单，不存插件副本。** 以前这里还有 `local/` 放 .tgz，
+> 现在没有了，而且会自动清掉老版本留下的 `local/` 与散落 tgz。
+> 安装一律按清单里的「安装坐标」去 registry 联网拉取，不存在本地副本安装这条路。
+
 **没有公共分区。** 早先版本在插件库下分出「特征 / 汇集」两级子目录，那是错的：
 插件库是多人共享的盘，公共目录等于公共广场，所有人的东西往一处堆，谁的产出分不清，
 而且「汇集」会成为多方争写的热点。现在改成：
@@ -323,31 +325,45 @@ D:\Ai工作空间\插件库\          ← 共享文件夹，两台机器都能
 `POST /settings { shareResetHash: true }`——这是唯一的重算入口，其它情况一律沿用旧值。
 
 
-### 清单里写什么
+### 清单里写什么（只有清单，没有文件）
+
+每一项只有五个字段：`name` / `version` / `kind` / `installSpec` / `installable`。
 
-| 插件来源 | 清单里写什么 | 要不要打副本 |
+| 插件来源 | 安装坐标 `installSpec` | 能装吗 |
 |---|---|---|
-| `registry`（能联网更新） | 名称 + 版本 | **不打**，对方自己从 registry 拉 |
-| `local`（`file:` 本地路径） | 名称 + 版本 + 来源说明 | **打**，`local/<name>-<version>.tgz` |
-| `git`（GitHub 等） | 名称 + 版本 | **打**，同上 |
-| `installation`（随 DSH 安装提供） | **不写** | 别人本来就有，也没版本号可装 |
+| `registry`（能联网更新） | `<name>@<version>` | 能，registry 拉 |
+| `git`（GitHub 等） | 原 git 写法（`github:o/r#ref`） | 能，联网拉 |
+| `local`（`file:` 本地路径） | 空 | **不能**：未发布的东西没地方拉 |
+| `installation`（随 DSH 安装提供） | — | **不写进清单**：别人本来就有 |
+
+`PLUGINS.json` 里的 `policy` 段把这条规矩写死，别人一看就知道这份清单不含文件：
+
+```json
+{
+  "schemaVersion": 2,
+  "policy": {
+    "manifestOnly": true,
+    "storesBundles": false,
+    "installVia": "registry",
+    "note": "特征文件夹只存清单；安装一律按 installSpec 联网拉取，不使用本地副本。"
+  },
+  "plugins": [
+    { "name": "dsh-tavern", "version": "2.8.1", "kind": "registry",
+      "installSpec": "dsh-tavern@2.8.1", "installable": true }
+  ]
+}
+```
+
+历史遗留的 `local/` 与根上散落的 `*.tgz` 会在每轮同步时被删掉（删除记录写进
+`PLUGINS.json` 的 `legacyPurged`，便于排查「我的 local/ 怎么没了」）。
 
-副本是 npm 标准 tgz（`package/` 前缀），排除 `node_modules`、`.git`、`__pycache__`、`*.bak-*`。
-单包上限 96 MB，单个特征的副本总量上限 512 MB，同名插件只留最近 2 个版本。
-`link:` 装的包在 `node_modules` 下是符号链接，打包时按 `realpath` 追到真实目录。
 
-### 什么时候跑
 
 **每次巡检跑一次**——巡检 = 自动更新的那一轮定时检查（间隔见「检查频率」）。
 顺序是先查更新、再同步共享；更新失败不影响共享同步。面板上也有「立即同步一次」。
 
 每次同步都幂等：
 
-- 清单内容（除 `generatedAt` / `lastSyncAt` 这类时间字段）没变 → 不重写文件
-- 源目录指纹（文件数 + 最大 mtime + 总字节）没变 → 不重压 `.tgz`，直接复用
-- 本机标识第一次同步时固定进 state，之后每轮原样传回，不做任何重算
-
-所以几百 MB 的本地插件不会把每轮巡检拖慢。
 
 ### 拉别人的清单
 
@@ -361,28 +377,31 @@ D:\Ai工作空间\插件库\          ← 共享文件夹，两台机器都能
 
 合并去重规则：
 
-- 去重键是包名；多本特征都有同一插件时，版本取**更高**的那份（按语义版本比，不看文件时间）
-- 副本跟着最高版本走；`features` 里记下它出现在哪几本
-- 「本机有没有」按 profile 的 `dsh.profile.bundles` 判断，不看 `node_modules`（那里塞满传递依赖）
+- 去重键是包名；多本特征都有同一插件时，版本与安装坐标都取**更高**的那份（按语义版本比，不看文件时间）
+- `features` 里记下它出现在哪几本；老清单里的 `bundles` 数组一律忽略
 - 没 `PLUGINS.json` 的目录只记一条提示，不报错
 
-### 装的时候走哪条路
+### 装的时候走哪条路（只有一条：联网）
+
+| 清单里的 `installSpec` | 用的 spec | 结果 |
+|---|---|---|
+| `<name>@<version>` | 原样 | 从 registry 拉 |
+| `github:o/r#ref` 这类 git 写法 | 原样 | 联网拉 |
+| 空（`local` 来源） | — | **拒绝**，说明「对方未发布到 registry」 |
+| `file:` / `link:` 开头 | — | **拒绝**：只走 registry 联网拉取 |
+
+就算对方是老版本写的清单、里面还带着 `bundles` 数组，也一律忽略：
+拿别人打包过的旧代码装上，版本号写着新的、行为是老的那份，比装不上更难查。
 
-| 对方特征里有 | 用的 spec |
-|---|---|
-| `.tgz` 副本 | `file:<对方副本的绝对路径>`（正斜杠） |
-| 只有名称（registry 来源） | `<name>@<version>` |
-| 既没副本又不是 registry | 拒绝，说明原因 |
 
-装完自动把包名补进 profile 的 `dsh.profile.bundles`——不补的话插件装下来但不会加载。
 装之前同样会快照 profile 三个清单文件，出问题用 `/restore` 回滚。**装完必须完全退出 DSH 再重开。**
 
 ### 共享相关接口
 
 | 方法 | 路径 | 作用 |
 |---|---|---|
-| GET | `/share` | 我的特征现状 + 他人清单（含每项是否已装、有没有副本） |
-| POST | `/share/sync` | 立即同步一次（我的清单 + 副本 + 他人汇集） |
+| GET | `/share` | 我的特征现状 + 他人清单（含每项是否已装、能不能装、安装坐标） |
+| POST | `/share/sync` | 立即同步一次（我的清单 + 他人汇集；不打包任何文件） |
 | POST | `/share/install` | 安装他人清单里的一个插件（body: `{ name }`） |
 
 设置项（走 `/settings`）：`shareEnabled`、`shareLibraryRoot`、`shareFeatureName`、`shareResetHash`。
@@ -408,7 +427,7 @@ $node = "C:\DeepSeekHarness\resources\runtime\primary-runtime\dependencies\node\
 | `update-guard.test.mjs` | 只向上更新、来源判定、发布年龄门槛 |
 | `git-source.test.mjs` | Git 来源的 commit 比较与安装 spec |
 | `machine.test.mjs` | 本机标识：继承会话同步的 machineId、固定后不漂移、改名不换特征值、卸载会话同步后旧值仍有效、写边界（别人的格 / `../` 逃逸 / 前缀相近） |
-| `share.test.mjs` | 特征文件夹：清单分类（registry 只写名 / 本地打副本 / 宿主自带不写）、tgz 结构、同步幂等与副本复用、他人清单合并去重、安装路径选择、特征名防上跳 |
+| `share.test.mjs` | 特征文件夹：清单只写元数据、**目录里不允许出现任何插件文件**、历史 `local/` 被清理、同步幂等、他人清单合并去重（忽略老清单 bundles）、安装只走 registry（有副本也拒绝、`file:` 坐标也拒绝）、特征名防上跳 |
 | `schedule.test.mjs` | 定时排期：更新与共享同步各自独立开关 |
 | `system-plugins.test.mjs` | **本体插件隐藏契约**（源码级）：`isBuiltinPlugin` 判据只有一处定义、listPlugins 出口过滤并缓存隐藏名单、runCheck 不查、snapshot 再兜一层并透出 `builtin.count`、策略/更新接口对本体插件一律 400、共享清单同一判据、面板整组隐藏只留一行说明 |
 | `system-plugins.behavior.test.mjs` | **本体插件隐藏行为**（真执行 + 假宿主 + 假 profile）：`@deepseek-ai/*` 一行都不出现、第三方插件照常可写策略、`builtin.count` 数对、`pluginManager` 缺失 / 抛错 / 脏数据三种降级都不让 `/state` 失败 |
@@ -549,7 +568,7 @@ POST /api/local/plugin-autoupdate/plugin-policy  {"name":"@deepseek-ai/dsh-base"
   版本跟桌面端走，`registry` 上的同名包与它无关；策略/更新接口对它们一律 400
 - 更新失败只记历史，不自动回滚（避免把用户自己手改的清单吞掉）；要回滚用 `/restore`
 - DSH 关闭期间不检查（进程内定时器的固有限制）；重开后会立刻按上游发布时间重新判定
-- 共享只**同步清单与副本**，不自动安装别人的插件；安装必须人工点选
+- 共享只**同步清单**（不存任何插件文件），不自动安装别人的插件；安装必须人工点选，且只走 registry 联网拉取
 - 只写 `插件库\<本机标识>\` 那一格，别人的格子只读（写入口有守卫）
 - 不在插件库根下留任何公共文件或公共目录
 - **重启只认显式 pid**：任何「按映像名清场」的写法都是回归，`restart-safety.test.mjs` 会红

package/client.js

@@ -692,7 +692,7 @@ function makePanel(React) {
       h(
         'div',
         { className: 'pau-card-h' },
-        h('h3', { className: 'pau-card-t' }, '插件共享（特征文件夹）'),
+        h('h3', { className: 'pau-card-t' }, '插件共享（特征文件夹 · 只存清单）'),
         h(
           'span',
           { className: share.enabled ? 'pau-tag pau-tag-ok' : 'pau-tag' },
@@ -702,7 +702,7 @@ function makePanel(React) {
       h(
         'p',
         { className: 'pau-sub' },
-        '插件库是共享文件夹，一个人一格：我的清单、本地插件副本、我自己的汇总全都写在「插件库\\<我的特征>」这一格里面。能联网更新的插件只写名称，本地/Git 来源的打成 .tgz 副本一起放过去。别人的格子只读，汇总也是各机扫一遍自己算，不放在公共位置。',
+        '插件库是共享文件夹，一个人一格：我的插件清单、我自己的汇总都写在「插件库\\<我的特征>」这一格里面，**只存清单，不存任何插件文件**。别人要装，按清单里的安装坐标去 registry 联网拉取，不使用本地副本。别人的格子只读，汇总也是各机扫一遍自己算，不放在公共位置。',
       ),
       h(
         'label',
@@ -766,7 +766,7 @@ function makePanel(React) {
         { className: 'pau-row-d', style: { marginTop: 6 } },
         `上次同步：${fmtAgo(share.lastSyncAt)}${
           share.lastResult
-            ? ` · 本机 ${share.lastResult.total} 个插件（副本 ${share.lastResult.bundled}，${share.lastResult.totalMb} MB） · 他人 ${share.lastResult.others} 个，可装 ${share.lastResult.installable}`
+            ? ` · 本机 ${share.lastResult.total} 个插件（可联网装 ${share.lastResult.localInstallable ?? '-'}，装不了 ${share.lastResult.localUninstallable ?? '-'}） · 他人 ${share.lastResult.others} 个，可装 ${share.lastResult.installable}`
             : ''
         }`,
       ),
@@ -791,7 +791,7 @@ function makePanel(React) {
                   const counts = (result.mine && result.mine.counts) || {};
                   const others2 = (result.aggregate && result.aggregate.counts) || {};
                   setNote(
-                    `同步完成：本机 ${counts.total || 0} 个插件（副本 ${counts.bundled || 0}），他人 ${others2.othersTotal || 0} 个，可装 ${others2.installable || 0} 个`,
+                    `同步完成：本机 ${counts.total || 0} 个插件（可联网装 ${counts.installable || 0}，装不了 ${counts.uninstallable || 0}），他人 ${others2.othersTotal || 0} 个，可装 ${others2.installable || 0} 个`,
                   );
                 }
                 if (next.share && next.share.detail) setShareDetail(next.share.detail);
@@ -843,16 +843,13 @@ function makePanel(React) {
                     h(
                       'span',
                       {
-                        className:
-                          plugin.bundle || plugin.kind === 'registry'
-                            ? 'pau-tag pau-tag-ok'
-                            : 'pau-tag pau-tag-warn',
+                        className: plugin.installable ? 'pau-tag pau-tag-ok' : 'pau-tag pau-tag-warn',
                       },
-                      plugin.bundle
-                        ? '含副本，可离线装'
-                        : plugin.kind === 'registry'
-                          ? '需联网拉取'
-                          : '无副本，装不了',
+                      plugin.installable
+                        ? plugin.kind === 'git'
+                          ? 'Git 联网拉取'
+                          : '联网拉取'
+                        : '无安装坐标，装不了',
                     ),
                     h('span', { className: 'pau-tag pau-tag-mine' }, plugin.features.join(' / ')),
                   ),
@@ -864,8 +861,10 @@ function makePanel(React) {
                   'button',
                   {
                     className: 'pau-btn pau-btn-sm pau-btn-primary',
-                    disabled: !!busy || (!plugin.bundle && plugin.kind !== 'registry'),
-                    title: plugin.bundle ? `安装对方特征里的副本` : '从 registry 安装该版本',
+                    disabled: !!busy || !plugin.installable,
+                    title: plugin.installable
+                      ? `从 registry 联网安装 ${plugin.installSpec || plugin.name}`
+                      : '这个插件没有可联网的安装坐标（对方未发布到 registry）',
                     onClick: () =>
                       run(`share-install:${plugin.name}`, async () => {
                         const next = await call('/share/install', { name: plugin.name });

package/index.js

@@ -325,9 +325,14 @@ export function apply(ctx, config = {}) {
         feature: mine.feature,
         root: mine.root,
         total: mine.counts.total,
-        bundled: mine.counts.bundled,
-        skipped: mine.counts.skipped,
-        totalMb: mine.totalMb,
+        // 只存清单：bundled / totalMb 恒为 0，保留字段是为了旧面板与旧历史记录不炸
+        bundled: 0,
+        skipped: 0,
+        totalMb: 0,
+        // 新口径：本机清单里「能联网装」与「装不了」各多少
+        localInstallable: mine.counts.installable,
+        localUninstallable: mine.counts.uninstallable,
+        legacyPurged: mine.legacyPurged?.removed?.length || 0,
         others: aggregate.doc.counts.othersTotal,
         installable: aggregate.doc.counts.installable,
         sources: aggregate.doc.counts.sources,
@@ -337,7 +342,10 @@ export function apply(ctx, config = {}) {
       pushHistory(next, {
         kind: 'share',
         reason: reason || '定时',
-        text: `共享同步：本机 ${mine.counts.total} 个插件 / 副本 ${mine.counts.bundled}；他人 ${aggregate.doc.counts.othersTotal} 个，可装 ${aggregate.doc.counts.installable}`,
+        text:
+          `共享同步：本机 ${mine.counts.total} 个插件（可联网装 ${mine.counts.installable}，装不了 ${mine.counts.uninstallable}）；` +
+          `他人 ${aggregate.doc.counts.othersTotal} 个，可装 ${aggregate.doc.counts.installable}` +
+          (mine.legacyPurged?.removed?.length ? `；清理历史副本 ${mine.legacyPurged.removed.length} 个` : ''),
       });
       saveState(next);
       return { ok: true, mine, aggregate: { counts: aggregate.doc.counts }, root: libraryRoot(config) };

package/lib/api.js

@@ -22,7 +22,7 @@ import {
 } from './core.js';
 import { normalizeRegistry, queryLatest } from './registry.js';
 import { restoreBackup, listBackups } from './backup.js';
-import { libraryRoot, myFeatureName } from './share.js';
+import { SHARE_POLICY, libraryRoot, myFeatureName } from './share.js';
 
 export const API_PREFIX = '/api/local/plugin-autoupdate';
 
@@ -165,6 +165,8 @@ function snapshot(deps) {
         featureName: state.shareFeatureName,
         machineHash: state.shareMachineHash,
       }),
+      // 口径声明：特征文件夹只存清单、安装走 registry。面板据此显示，不再提「副本」
+      policy: SHARE_POLICY,
     },
     limits: {
       minIntervalMinutes: MIN_INTERVAL_MINUTES,

package/lib/share.js

@@ -1,32 +1,33 @@
 /**
  * 插件共享（特征文件夹）——本机插件清单的对外沉淀与汇集。
  *
- * 目录约定（都在「插件库」根下，根目录由设置决定）：
+ * 目录约定（一个人一格，直接摆在「插件库」根下，根目录由设置决定）：
  *
  *   插件库\
- *   └─ 特征\
- *      └─ <我的特征名>\
- *         ├─ FEATURE.json          本机特征说明（谁、哪台机、什么时候巡检、插件数）
- *         ├─ PLUGINS.json          本机插件清单（可联网更新的只写名称+版本，不打包）
- *         └─ local\               本机插件副本（本地路径 / Git 来源的 .tgz）
- *            └─ <name>-<version>.tgz
+ *   └─ <我的特征名>\
+ *      ├─ FEATURE.json          本机特征说明（谁、哪台机、什么时候巡检、插件数）
+ *      ├─ PLUGINS.json          本机插件清单（**只有清单，没有任何插件文件**）
+ *      ├─ OTHERS-PLUGINS.json   我自己算出来的「他人插件汇总」
+ *      └─ OTHERS-PLUGINS.md     同一份的人读版本
  *
- * 汇集他人的特征：
+ * ── 为什么不再存插件副本（0.9.6 起的硬规矩）─────────────────────────
+ * 特征文件夹**只放清单**，不放 .tgz。理由三条，都是实打实的：
+ *   1. 副本会过期。对方打包时的代码和 registry 上的产物不是一回事，
+ *      拿旧副本装出来的插件版本号写着新的、行为是旧的，排查时最坑。
+ *   2. 副本会膨胀。共享盘上每台机器各存一份几十 MB 的 tgz，谁也说不清哪份是对的。
+ *   3. 安装只该有一个来源：registry。**联网拉取是唯一安装通道**，
+ *      不提供、也不接受 file: 本地副本安装。
  *
- *   插件库\
- *   └─ 汇集\
- *      ├─ OTHERS-PLUGINS.json     他人插件总清单（合并 + 去重，标记本机是否已有）
- *      └─ OTHERS-PLUGINS.md       同一份的人读版本
+ * 因此安装他人清单里的插件时：只按「包名@版本」去 registry 拉。
+ * 对方的插件没发布到 registry 的，就直接说明「无法安装」，不做任何本地兜底。
  *
- * 三条硬规则：
- *   1. 可联网更新（registry 来源）的插件**只写名称**，副本一律不打——它们本来就能拉。
- *   2. 本地来源（file:/link:/git）的插件打包成 .tgz 同步过来，否则别人装上跑不起来。
- *   3. 每次巡检（自动更新轮询）跑一次同步；同一份内容重复跑不产生新改动（幂等）。
+ * 两条硬规则：
+ *   1. 清单里只写名称 + 版本 + 来源类型 + 安装坐标，绝不写文件、绝不打包。
+ *   2. 每次巡检（自动更新轮询）跑一次同步；同一份内容重复跑不产生新改动（幂等）。
  */
 import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
-import { spawn } from 'node:child_process';
 import {
   installedMeta,
   installedVersion,
@@ -44,14 +45,20 @@ import { assertOwnFeaturePath, resolveIdentity } from './machine.js';
 /** 插件库默认根：D 盘 ai 工作空间下的「插件库」。 */
 export const DEFAULT_LIBRARY_ROOT = 'D:\\Ai工作空间\\插件库';
 
-/** 单个插件的副本上限（MB）：超过就只留条目、不打包，避免一个包拖垮整个同步。 */
-export const MAX_BUNDLE_MB = 96;
-/** 单个特征文件夹的副本总上限（MB）。 */
-export const MAX_FEATURE_MB = 512;
-/** 副本保留份数：同名插件只留最新的 N 个版本。 */
-export const KEEP_BUNDLES = 2;
-
-const TAR = process.env.SystemRoot ? path.join(process.env.SystemRoot, 'System32', 'tar.exe') : 'tar';
+/**
+ * 共享清单的存放策略（给面板与文档用，也是 0.9.6 的行为声明）。
+ *
+ * 这里不再有 MAX_BUNDLE_MB / KEEP_BUNDLES 这类「副本上限」：
+ * 特征文件夹已经不存副本，没有体积可管，也没有份数可留。
+ */
+export const SHARE_POLICY = Object.freeze({
+  /** 清单里允许出现的字段：名称、版本、来源类型、安装坐标。 */
+  manifestOnly: true,
+  /** 是否允许把插件文件写进特征文件夹。恒为 false。 */
+  storesBundles: false,
+  /** 安装通道：只有 registry。 */
+  installVia: 'registry',
+});
 
 export function libraryRoot(config) {
   const value = typeof config?.libraryRoot === 'string' ? config.libraryRoot.trim() : '';
@@ -71,7 +78,7 @@ export function featuresDir(config) {
 
 /**
  * 我自己的目录：`插件库/<本机标识>/`。
- * 清单、副本、以及我自己那份「他人插件汇总」全都在这一格里面。
+ * 清单、以及我自己那份「他人插件汇总」全都在这一格里面——**不含任何插件文件**。
  */
 export function myFeatureDir(config) {
   return path.join(featuresDir(config), myFeatureName(config));
@@ -141,7 +148,9 @@ function readJson(file) {
  * 但 generatedAt 每次都不同，直接比字节会把每轮巡检都变成「有改动」，
  * 白写盘、白触发下游。所以先剔掉易变字段再比。
  */
-const VOLATILE_KEYS = ['generatedAt', 'lastSyncAt', 'pruned', 'reused', 'ms'];
+// legacyPurged 也算易变：历史副本只清一次，清完下一轮就是空数组。
+// 把它算进比较会导致「每次巡检都重写 PLUGINS.json」，而且会把清理记录抹掉。
+const VOLATILE_KEYS = ['generatedAt', 'lastSyncAt', 'pruned', 'reused', 'ms', 'legacyPurged'];
 
 function stableValue(value) {
   if (Array.isArray(value)) return value.map(stableValue);
@@ -210,10 +219,9 @@ const SKIP_DIRS = new Set(['node_modules', '.git', '.pnpm', '__pycache__', '.cac
 /**
  * 源目录指纹：文件数 + 最大 mtime + 总字节（排除 node_modules 等）。
  *
- * 用来判断「这个副本还能不能直接复用」。巡检每轮都会跑一次同步，
- * 如果每次都重新压一遍 .tgz，几百 MB 的插件会把每轮巡检拖成几分钟，
- * 而且压出来的字节每次略有不同，看起来像「清单变了」。
- * 指纹没变就跳过打包，直接沿用上次的副本。
+ * 0.9.6 起不再打包副本，这个函数只作为**诊断用**保留：
+ * 需要判断「某个插件目录到底有没有被动过」时（例如排查来源混淆），
+ * 它能给一个稳定的短指纹。同步流程不再调用它。
  */
 export function sourceSignature(sourceDir) {
   let count = 0;
@@ -304,10 +312,18 @@ function realSource(sourceDir) {
 }
 
 /**
- * 枚举本机 profile 里的插件，并判定每个插件在共享里怎么表达。
+ * 枚举本机 profile 里的插件，产出一份**纯清单**。
+ *
+ * 返回的每一项只有「名称 / 版本 / 来源类型 / 安装坐标 / 说明」，没有目录、没有文件。
+ * 这是 0.9.6 的硬约束：特征文件夹只存清单，任何插件文件都不往里写。
+ *
+ * `installSpec` 是对方要装它时的唯一坐标：
+ *   - registry → `name@version`（联网拉取）
+ *   - git      → 原 git 写法（仍然联网）
+ *   - local    → 空：本机 file: 来源的插件别人装不了，清单里明说
  *
  * @param {{publishedNames?: string[]}} [options]
- * @returns {Array<{name,version,kind,spec,description,homepage,share:'name-only'|'bundle',sourceDir?,reason?}>}
+ * @returns {Array<{name,version,kind,spec,installSpec,installable,description,homepage,reason}>}
  */
 export function collectLocalPlugins(options) {
   const publishedNames = Array.isArray(options?.publishedNames) ? options.publishedNames : [];
@@ -319,23 +335,29 @@ export function collectLocalPlugins(options) {
       const version = installedVersion(name) || null;
       const spec = typeof specs[name] === 'string' ? specs[name] : null;
       const meta = installedMeta(name);
-      const sourceDir = realSource(path.join(profileDir(), 'node_modules', ...String(name).split('/')));
       const registryLike = kind === 'registry' || kind === 'installation';
+      // 安装坐标：只有能联网拉到的来源才给；file:/link: 给了也是假的
+      const installSpec = registryLike
+        ? version
+          ? `${name}@${version}`
+          : name
+        : kind === 'git'
+          ? spec || ''
+          : '';
       return {
         name,
         version,
         kind,
         spec,
+        installSpec,
+        installable: Boolean(installSpec),
         description: meta.description || '',
         homepage: meta.homepage || '',
-        // registry 来源：只写名称（版本照写，便于别人判断新旧），不打包
-        share: registryLike ? 'name-only' : 'bundle',
-        sourceDir,
         reason: registryLike
-          ? '可联网更新，只登记名称'
+          ? 'registry 来源，按名称+版本联网拉取'
           : kind === 'git'
-            ? 'Git 来源，打包副本'
-            : '本地路径来源，打包副本',
+            ? 'Git 来源，按仓库地址联网拉取'
+            : '本地路径来源，未发布到 registry，别人装不了',
       };
     })
     .sort((a, b) => a.name.localeCompare(b.name));
@@ -353,159 +375,15 @@ export function shareablePlugins(plugins) {
   return plugins.filter((p) => p && !isBuiltinPlugin(p) && p.kind !== 'installation');
 }
 
-/* ------------------------------------------------------------ 打包副本 */
-
-/** 读包内 package.json 的 files 字段，决定打包哪些路径；没有就整目录（仍排除 node_modules）。 */
-function packableManifest(sourceDir) {
-  const manifest = readJson(path.join(sourceDir, 'package.json'));
-  const files = Array.isArray(manifest?.files) ? manifest.files.filter((f) => typeof f === 'string') : [];
-  return { manifest, files };
-}
-
-/**
- * 把一个本地插件目录打成 npm 标准 .tgz（package/ 前缀），排除 node_modules 与常见垃圾。
- *
- * 为什么不用 `npm pack`：宿主的 node 旁边不一定有 npm-cli.js，且 npm pack 会跑
- * prepack 脚本、写 packument 日志；这里只要一个能 `pnpm add file:` 的包。
- * Windows 自带 bsdtar 支持 --exclude，够用。
- *
- * @returns {Promise<{ok:boolean, file?:string, bytes?:number, message?:string}>}
- */
-export async function packLocalPlugin({ sourceDir, name, version, outDir }) {
-  const manifestPath = path.join(sourceDir, 'package.json');
-  if (!fs.existsSync(manifestPath)) {
-    return { ok: false, message: '源目录里没有 package.json' };
-  }
-  if (!fs.existsSync(TAR)) {
-    return { ok: false, message: `找不到 tar.exe（${TAR}）` };
-  }
-  fs.mkdirSync(outDir, { recursive: true });
-  const file = path.join(outDir, `${fileStem(name)}-${version || '0.0.0'}.tgz`);
-  const tmp = `${file}.tmp`;
-  try {
-    fs.rmSync(tmp, { force: true });
-  } catch {
-    /* ignore */
-  }
-
-  const parent = path.dirname(sourceDir);
-  const leaf = path.basename(sourceDir);
-  const args = [
-    '-czf',
-    tmp,
-    '--exclude',
-    'node_modules',
-    '--exclude',
-    '.git',
-    '--exclude',
-    '.pnpm',
-    '--exclude',
-    '__pycache__',
-    '--exclude',
-    '*.bak-*',
-    '--exclude',
-    '.DS_Store',
-    '-C',
-    parent,
-    leaf,
-  ];
-  const result = await run(TAR, args, { timeoutMs: 10 * 60 * 1000 });
-  if (result.code !== 0 || !fs.existsSync(tmp)) {
-    return { ok: false, message: `tar 打包失败：${result.output || `退出码 ${result.code}`}` };
-  }
-
-  // bsdtar 打出来是 <leaf>/... 前缀；npm 标准要的是 package/...
-  // 直接按 --strip-components=1 解到一个叫 package 的空目录再压，比「解包后改名」稳：
-  // 在 D: 盘上 rename 一个刚被 tar 写过的目录会拿到 EPERM（杀软/索引器短暂持有句柄）。
-  const staging = path.join(outDir, `.repack-${process.pid}-${Date.now()}`);
-  const inner = path.join(staging, 'package');
-  try {
-    fs.mkdirSync(inner, { recursive: true });
-    const extract = await run(TAR, ['-xzf', tmp, '-C', inner, '--strip-components=1'], {
-      timeoutMs: 10 * 60 * 1000,
-    });
-    if (extract.code !== 0) {
-      return { ok: false, message: `tar 解包失败：${extract.output || `退出码 ${extract.code}`}` };
-    }
-    // 解出来的东西里必须真有 package.json，否则压出来的包装上也不认
-    if (!fs.existsSync(path.join(inner, 'package.json'))) {
-      return { ok: false, message: '解包后没有 package.json，源目录结构异常' };
-    }
-    const finalTmp = `${tmp}.final`;
-    fs.rmSync(finalTmp, { force: true });
-    const repack = await run(TAR, ['-czf', finalTmp, '-C', staging, 'package'], {
-      timeoutMs: 10 * 60 * 1000,
-    });
-    if (repack.code !== 0 || !fs.existsSync(finalTmp)) {
-      return { ok: false, message: `tar 重新打包失败：${repack.output || `退出码 ${repack.code}`}` };
-    }
-    fs.rmSync(file, { force: true });
-    fs.renameSync(finalTmp, file);
-  } finally {
-    try {
-      fs.rmSync(staging, { recursive: true, force: true, maxRetries: 3 });
-    } catch {
-      /* 残留目录不影响结果，下次同名会覆盖 */
-    }
-    try {
-      fs.rmSync(tmp, { force: true });
-    } catch {
-      /* ignore */
-    }
-  }
-  return { ok: true, file, bytes: bytesOf(file) };
-}
-
-/** 远端特征带来的 .tgz 副本：直接按名字判断是否已在 local/ 里。 */
-function listLocalBundles(dir) {
-  const out = [];
-  try {
-    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-      if (!entry.isFile() || !/\.tgz$/i.test(entry.name)) continue;
-      const file = path.join(dir, entry.name);
-      out.push({ file: entry.name, bytes: bytesOf(file) });
-    }
-  } catch {
-    /* 目录不存在就是空 */
-  }
-  return out.sort((a, b) => a.file.localeCompare(b.file));
-}
-
-/** 只保留同名插件的最近 KEEP_BUNDLES 份（按版本号排序，不按文件时间）。 */
-function pruneBundles(dir) {
-  let removed = [];
-  try {
-    const groups = new Map();
-    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-      if (!entry.isFile() || !/\.tgz$/i.test(entry.name)) continue;
-      const match = /^(.+)-(\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?)\.tgz$/i.exec(entry.name);
-      const key = match ? match[1] : entry.name;
-      const version = match ? match[2] : '0.0.0';
-      if (!groups.has(key)) groups.set(key, []);
-      groups.get(key).push({ name: entry.name, version });
-    }
-    for (const list of groups.values()) {
-      if (list.length <= KEEP_BUNDLES) continue;
-      list.sort((a, b) => (isNewerVersion(a.version, b.version) ? 1 : -1));
-      for (const item of list.slice(KEEP_BUNDLES)) {
-        try {
-          fs.rmSync(path.join(dir, item.name), { force: true });
-          removed.push(item.name);
-        } catch {
-          /* ignore */
-        }
-      }
-    }
-  } catch {
-    return removed;
-  }
-  return removed;
-}
-
 /* --------------------------------------------------------- 本机特征同步 */
 
 /**
- * 把本机插件清单写进我的特征文件夹，并把本地来源的插件副本同步过去。
+ * 把本机插件清单写进我的特征文件夹。
+ *
+ * **只写清单，不写插件文件。** 这是 0.9.6 的硬规矩：
+ *   - 特征文件夹里只有 PLUGINS.json / FEATURE.json / 汇总两份；
+ *   - 老版本留下的 local/ 目录会被主动清掉（不然共享盘上会一直躺着过期 tgz）；
+ *   - 别人要装，只能按清单里的 installSpec 去 registry 联网拉。
  *
  * @param {{config?: object, publishedNames?: string[], log?: Function}} input
  * @returns {Promise<object>} 同步结果（可直接返回给面板）
@@ -516,109 +394,21 @@ export async function syncMyFeature({ config, publishedNames, log }) {
   const feature = identity.machineId;
   const featuresRoot = featuresDir(config);
   const root = path.join(featuresRoot, feature);
-  const bundleDir = path.join(root, 'local');
 
   // 写之前先过守门：只允许写 <插件库>/<本机标识>/，别人的特征文件夹只读。
-  assertOwnFeaturePath(bundleDir, { featuresRoot, machineId: feature });
+  assertOwnFeaturePath(root, { featuresRoot, machineId: feature });
 
   const allPlugins = collectLocalPlugins({ publishedNames });
   // 随 DSH 安装提供的官方 bundle 不进清单：别人机器上本来就有，也没版本号可装
   const plugins = shareablePlugins(allPlugins);
-  const needBundle = plugins.filter((p) => p.share === 'bundle' && p.version);
-
-  const bundled = [];
-  const skipped = [];
-  const reused = [];
-  let bundleBytes = 0;
-
-  // 上一轮留下的副本索引：{ '<name>-<version>.tgz': {sig, bytes} }
-  const previous = fs.existsSync(path.join(root, 'PLUGINS.json'))
-    ? readJson(path.join(root, 'PLUGINS.json'))?.bundleIndex || {}
-    : {};
-  const bundleIndex = {};
-
-  for (const plugin of needBundle) {
-    if (bundleBytes > MAX_FEATURE_MB * 1048576) {
-      skipped.push({ name: plugin.name, reason: `副本总量已超过 ${MAX_FEATURE_MB} MB，本轮未打包` });
-      continue;
-    }
-    const expected = path.join(bundleDir, `${fileStem(plugin.name)}-${plugin.version}.tgz`);
-    const signature = sourceSignature(plugin.sourceDir);
-    const known = previous[path.basename(expected)];
-
-    // 源没改过、副本还在 → 直接沿用，不重压（几百 MB 的包重压一次要几十秒）
-    if (known && known.sig === signature && fs.existsSync(expected)) {
-      bundleBytes += bytesOf(expected);
-      bundled.push({
-        name: plugin.name,
-        version: plugin.version,
-        kind: plugin.kind,
-        file: path.relative(root, expected).replace(/\\/g, '/'),
-        bytes: bytesOf(expected),
-      });
-      bundleIndex[path.basename(expected)] = { sig: signature, bytes: bytesOf(expected) };
-      reused.push(plugin.name);
-      continue;
-    }
 
-    const packed = await packLocalPlugin({
-      sourceDir: plugin.sourceDir,
-      name: plugin.name,
-      version: plugin.version,
-      outDir: bundleDir,
-    });
-    if (!packed.ok) {
-      skipped.push({ name: plugin.name, reason: packed.message });
-      continue;
-    }
-    if (packed.bytes > MAX_BUNDLE_MB * 1048576) {
-      skipped.push({
-        name: plugin.name,
-        reason: `副本 ${mb(packed.bytes)} MB 超过单包上限 ${MAX_BUNDLE_MB} MB`,
-      });
-      try {
-        fs.rmSync(packed.file, { force: true });
-      } catch {
-        /* ignore */
-      }
-      continue;
-    }
-    bundleBytes += packed.bytes;
-    bundled.push({
-      name: plugin.name,
-      version: plugin.version,
-      kind: plugin.kind,
-      file: path.relative(root, packed.file).replace(/\\/g, '/'),
-      bytes: packed.bytes,
-    });
-    bundleIndex[path.basename(packed.file)] = { sig: signature, bytes: packed.bytes };
-  }
-
-  // 只清理本次没有打包、且不是本轮产出的旧副本（防止插件被删了副本还留着）
-  const produced = new Set(bundled.map((item) => path.basename(item.file)));
-  // 清理：本轮没有产出、也不在 KEEP_BUNDLES 保留范围内的旧副本一律删掉。
-  //
-  // 这里必须按**版本**判断，不能只看「同名的还有没有」——
-  // 插件升到 0.13.3 之后，0.13.2 那份副本同名前缀仍然匹配，会被一直留着，
-  // 越攒越多（实际踩过：目录里同时躺着 0.3.0 和 0.4.0 两个自己）。
-  const keepNames = new Set();
-  for (const item of bundled) keepNames.add(path.basename(item.file));
-  for (const name of Object.keys(bundleIndex)) keepNames.add(name);
-
-  for (const entry of listLocalBundles(bundleDir)) {
-    if (produced.has(entry.file) || keepNames.has(entry.file)) continue;
-    const stillReferenced = needBundle.some((p) => entry.file === `${fileStem(p.name)}-${p.version}.tgz`);
-    if (stillReferenced) continue;
-    try {
-      fs.rmSync(path.join(bundleDir, entry.file), { force: true });
-    } catch {
-      /* ignore */
-    }
-  }
-  const pruned = pruneBundles(bundleDir);
+  // ---- 清掉历史遗留的副本目录 ----
+  // 0.9.5 及以前会把本地/Git 来源的插件打成 .tgz 放在 local/ 下。
+  // 现在不存副本了，这个目录必须主动删：留着就是「共享盘上躺着一份别人可能拿去装的旧代码」。
+  const purged = purgeLegacyBundles(root);
 
   const manifest = {
-    schemaVersion: 1,
+    schemaVersion: 2,
     // 这份清单属于谁、在哪台机器上、什么时候写的
     feature,
     machine: identity.machineName,
@@ -629,28 +419,27 @@ export async function syncMyFeature({ config, publishedNames, log }) {
     generatedAt: new Date().toISOString(),
     counts: {
       total: plugins.length,
-      nameOnly: plugins.filter((p) => p.share === 'name-only').length,
-      bundled: bundled.length,
-      skipped: skipped.length,
+      // 能装 / 不能装，直接按清单里的 installSpec 算，不再有「有副本」这一档
+      installable: plugins.filter((p) => p.installable).length,
+      uninstallable: plugins.filter((p) => !p.installable).length,
       // 随宿主安装提供的包不共享（别人本来就有），只报个数便于对照
       hostProvided: allPlugins.length - plugins.length,
     },
-    bundlePolicy: {
-      registry: '只写名称与版本，不打副本（对方能自己从 registry 拉）',
-      localOrGit: `打包成 .tgz 放在 local/，单包上限 ${MAX_BUNDLE_MB} MB，同名保留 ${KEEP_BUNDLES} 份`,
+    /** 共享策略声明：写进清单里，别人一看就知道这份清单不含任何插件文件。 */
+    policy: {
+      manifestOnly: true,
+      storesBundles: false,
+      installVia: 'registry',
+      note: '特征文件夹只存清单；安装一律按 installSpec 联网拉取，不使用本地副本。',
     },
     plugins,
-    bundles: bundled,
-    /** 副本指纹表：源目录没变时下一轮直接复用，不重压。 */
-    bundleIndex,
-    skipped,
-    pruned,
-    reused,
+    /** 历史副本的清理记录（便于排查「我的 local/ 怎么没了」）。 */
+    legacyPurged: purged,
   };
 
   const pluginsChanged = writeJsonIfChanged(path.join(root, 'PLUGINS.json'), manifest);
   const featureChanged = writeJsonIfChanged(path.join(root, 'FEATURE.json'), {
-    schemaVersion: 1,
+    schemaVersion: 2,
     feature,
     machine: identity.machineName,
     machineId: identity.machineId,
@@ -662,11 +451,13 @@ export async function syncMyFeature({ config, publishedNames, log }) {
     dshProfile: profileDir(),
     lastSyncAt: manifest.generatedAt,
     counts: manifest.counts,
-    note: '本目录由 ygc-dsh-plugin-autoupdate 的「插件共享」自动生成；目录名即本机标识，与会话同步插件一致；删除后下次巡检会重建。',
+    policy: manifest.policy,
+    note: '本目录由 ygc-dsh-plugin-autoupdate 的「插件共享」自动生成；目录名即本机标识，与会话同步插件一致；只有清单，没有插件文件；删除后下次巡检会重建。',
   });
 
   log?.(
-    `共享同步完成：${feature} → ${plugins.length} 个插件（副本 ${bundled.length}，跳过 ${skipped.length}）`,
+    `共享同步完成：${feature} → ${plugins.length} 个插件（可联网装 ${manifest.counts.installable}，不可装 ${manifest.counts.uninstallable}）` +
+      (purged.removed.length ? `；清理历史副本 ${purged.removed.length} 个` : ''),
   );
 
   return {
@@ -677,15 +468,80 @@ export async function syncMyFeature({ config, publishedNames, log }) {
     pluginsChanged,
     featureChanged,
     counts: manifest.counts,
-    bundles: bundled,
-    skipped,
-    pruned,
-    reused,
-    totalBytes: bundleBytes,
-    totalMb: mb(bundleBytes),
+    // 老字段保留成空数组 / 0：面板与历史记录还在读它们，语义变成「没有副本」
+    bundles: [],
+    skipped: [],
+    reused: [],
+    totalBytes: 0,
+    totalMb: 0,
+    legacyPurged: purged,
+  };
+}
+
+/**
+ * 删掉特征文件夹里历史遗留的插件副本。
+ *
+ * 只删这两类，别的一律不碰：
+ *   - `local/` 目录本身（老版本打包进去的 .tgz 全在这里）
+ *   - 特征根目录下散落的 `*.tgz`（更早的版本直接扔在根上）
+ *
+ * 删之前先做一次「可删性」自检：只处理自己那一格，别顺着软链接跑到别人家去。
+ *
+ * @returns {{removed: string[], bytes: number, error: string}}
+ */
+function purgeLegacyBundles(root) {
+  const removed = [];
+  let bytes = 0;
+  let error = '';
+  const collect = (dir) => {
+    let entries = [];
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (!entry.isFile() || !/\.tgz$/i.test(entry.name)) continue;
+      const file = path.join(dir, entry.name);
+      bytes += bytesOf(file);
+      try {
+        fs.rmSync(file, { force: true });
+        removed.push(path.relative(root, file).replace(/\\/g, '/'));
+      } catch (e) {
+        error = String(e?.message || e);
+      }
+    }
   };
+
+  const legacyDir = path.join(root, 'local');
+  // 只认 root 下面的 local：realpath 之后再比前缀，防止 local 被换成指向别处的链接
+  let realRoot = root;
+  let realLegacy = legacyDir;
+  try {
+    realRoot = fs.realpathSync(root);
+  } catch {
+    /* root 还没建出来，等于没有历史副本 */
+  }
+  try {
+    realLegacy = fs.realpathSync(legacyDir);
+  } catch {
+    realLegacy = '';
+  }
+  if (realLegacy && (realLegacy === realRoot || realLegacy.startsWith(realRoot + path.sep))) {
+    collect(realLegacy);
+    try {
+      fs.rmSync(realLegacy, { recursive: true, force: true });
+    } catch (e) {
+      error = error || String(e?.message || e);
+    }
+  }
+  // 根目录上散落的 .tgz 也算历史残留
+  collect(root);
+
+  return { removed, bytes, error };
 }
 
+
 /* ------------------------------------------------------- 他人特征汇集 */
 
 /**
@@ -730,31 +586,36 @@ export function collectSharedPlugins({ config, publishedNames } = {}) {
       machine: manifest.machine || '',
       generatedAt: manifest.generatedAt || '',
       total: Array.isArray(manifest.plugins) ? manifest.plugins.length : 0,
-      bundles: Array.isArray(manifest.bundles) ? manifest.bundles.length : 0,
+      // 老清单里可能有 bundles，这里只报个数（提示用），安装不看它
+      legacyBundles: Array.isArray(manifest.bundles) ? manifest.bundles.length : 0,
     });
 
     for (const plugin of manifest.plugins) {
       if (!plugin || typeof plugin.name !== 'string' || !plugin.name) continue;
-      const bundle = (Array.isArray(manifest.bundles) ? manifest.bundles : []).find(
-        (item) => item && item.name === plugin.name,
-      );
+      // 安装坐标：清单里带的 installSpec 优先；老清单没这个字段就按「名称@版本」推
+      const version = typeof plugin.version === 'string' ? plugin.version : '';
+      const kind = typeof plugin.kind === 'string' ? plugin.kind : 'registry';
+      const installSpec =
+        typeof plugin.installSpec === 'string' && plugin.installSpec
+          ? plugin.installSpec
+          : kind === 'registry' || kind === 'installation'
+            ? version
+              ? `${plugin.name}@${version}`
+              : plugin.name
+            : kind === 'git' && typeof plugin.spec === 'string'
+              ? plugin.spec
+              : '';
       const record = {
         name: plugin.name,
-        version: typeof plugin.version === 'string' ? plugin.version : '',
-        kind: typeof plugin.kind === 'string' ? plugin.kind : 'registry',
+        version,
+        kind,
+        spec: typeof plugin.spec === 'string' ? plugin.spec : '',
+        installSpec,
+        installable: Boolean(installSpec),
         description: typeof plugin.description === 'string' ? plugin.description : '',
         homepage: typeof plugin.homepage === 'string' ? plugin.homepage : '',
-        share: plugin.share === 'bundle' ? 'bundle' : 'name-only',
         features: [feature],
         mine: isMine || Boolean(plugin.mine),
-        bundle: bundle
-          ? {
-              feature,
-              file: bundle.file,
-              path: path.join(dir, String(bundle.file).replace(/\//g, path.sep)),
-              bytes: Number(bundle.bytes) || 0,
-            }
-          : null,
       };
 
       const old = merged.get(record.name);
@@ -763,17 +624,20 @@ export function collectSharedPlugins({ config, publishedNames } = {}) {
         continue;
       }
       if (!old.features.includes(feature)) old.features.push(feature);
-      // 多本都有：取版本更高的那本的元数据与副本
+      // 多本都有：取版本更高的那本，安装坐标也跟着它走
       const newer = record.version && (!old.version || isNewerVersion(old.version, record.version));
       if (newer) {
         old.version = record.version;
         old.kind = record.kind;
-        old.share = record.share;
+        old.spec = record.spec || old.spec;
+        old.installSpec = record.installSpec || old.installSpec;
+        old.installable = Boolean(old.installSpec);
         old.description = record.description || old.description;
         old.homepage = record.homepage || old.homepage;
-        old.bundle = record.bundle;
-      } else if (!old.bundle && record.bundle) {
-        old.bundle = record.bundle;
+      } else if (!old.installSpec && record.installSpec) {
+        // 老的那本没坐标、新报上来的有，补一个能装的坐标
+        old.installSpec = record.installSpec;
+        old.installable = true;
       }
       // 别人也有、我也有 → 记成「本机已有」，但不改成 mine
       old.mine = old.mine && record.mine;
@@ -795,8 +659,9 @@ export function writeAggregate({ config, publishedNames, log } = {}) {
     ...plugin,
     installed: local.has(plugin.name),
     installedVersion: local.has(plugin.name) ? installedVersion(plugin.name) || '' : '',
-    // 能装的方式：有副本走 file:，没副本且是 registry 来源走 name@version
-    installKind: plugin.bundle ? 'bundle' : plugin.kind === 'registry' || plugin.kind === 'installation' ? 'registry' : 'none',
+    // 能装的方式只有一种：registry（联网拉）。装不了的明确标 none，不做本地兜底。
+    installKind: plugin.installable ? 'registry' : 'none',
+    installSpec: plugin.installSpec || '',
   }));
 
   const others = items.filter((item) => !item.mine);
@@ -814,7 +679,8 @@ export function writeAggregate({ config, publishedNames, log } = {}) {
       othersTotal: others.length,
       installable: installable.length,
       installedFromOthers: others.filter((item) => item.installed).length,
-      withBundle: others.filter((item) => item.bundle).length,
+      // 老字段保留为 0：清单里不再有副本，面板若还读它能拿到确定的「没有」
+      withBundle: 0,
     },
     plugins: items,
   };
@@ -828,28 +694,29 @@ export function writeAggregate({ config, publishedNames, log } = {}) {
     '> 由 ygc-dsh-plugin-autoupdate 的「插件共享」汇集。',
     '> **这份文件只给本机自己看**：每台机器各自扫一遍插件库里所有人的特征文件夹，',
     '> 在自己的格子里生成自己的汇总。插件库是共享盘，不能在里面放一份大家共写的总表。',
+    '> 清单里**没有插件文件**；安装一律按「安装坐标」联网拉取，不使用本地副本。',
     '> 扫描范围：' + featuresDir(config),
     `> 生成时间：${doc.generatedAt}`,
     `> 特征本 ${doc.counts.sources} 本 · 他人插件 ${doc.counts.othersTotal} 个 · 本机可装 ${doc.counts.installable} 个`,
     '',
     '## 来源特征',
     '',
-    '| 特征 | 机器 | 生成时间 | 插件数 | 副本数 |',
+    '| 特征 | 机器 | 生成时间 | 插件数 |（旧副本数）|',
     '|---|---|---|---|---|',
     ...collected.sources.map(
       (item) =>
-        `| ${item.feature}${item.mine ? '（本机）' : ''} | ${item.machine || '-'} | ${item.generatedAt || '-'} | ${item.total} | ${item.bundles} |`,
+        `| ${item.feature}${item.mine ? '（本机）' : ''} | ${item.machine || '-'} | ${item.generatedAt || '-'} | ${item.total} | ${item.legacyBundles || 0} |`,
     ),
     '',
     '## 他人插件',
     '',
-    '| 插件 | 版本 | 来源 | 本机 | 安装方式 | 副本 |',
+    '| 插件 | 版本 | 来源 | 本机 | 安装方式 | 安装坐标 |',
     '|---|---|---|---|---|---|',
     ...others.map(
       (item) =>
         `| \`${item.name}\` | ${item.version || '-'} | ${item.features.join(', ')} | ${
           item.installed ? `已装 ${item.installedVersion}` : '无'
-        } | ${item.installKind} | ${item.bundle ? `${mb(item.bundle.bytes)} MB` : '-'} |`,
+        } | ${item.installKind} | ${item.installSpec ? `\`${item.installSpec}\`` : '-'} |`,
     ),
     '',
   ];
@@ -878,7 +745,14 @@ export function writeAggregate({ config, publishedNames, log } = {}) {
 /**
  * 安装他人清单里的一个插件。人工点选后调用，不做自动批量装。
  *
- * 优先用对方特征里的 .tgz 副本（不联网也能装）；没有副本才走 registry 的 name@version。
+ * ── 唯一的安装通道：registry 联网拉取 ──────────────────────────────────
+ * 特征文件夹里没有插件文件，所以这里**不存在**「本地副本安装」这条路：
+ *   - registry 来源 → `name@version` 去 registry 拉
+ *   - git 来源      → 原 git 写法，仍然联网
+ *   - local 来源    → 直接拒绝并说明原因（未发布的东西没地方拉）
+ *
+ * 就算对方的清单是老版本写的、里面还带着 `bundles` 数组，也一律忽略：
+ * 拿别人打包的旧代码装上，版本号和行为对不上，比装不上更难查。
  *
  * @param {{ctx?: any, config?: object, publishedNames?: string[], name: string,
  *          installSpec?: Function, log?: Function}} input
@@ -896,20 +770,23 @@ export async function installSharedPlugin({ ctx, config, publishedNames, name, i
     return { ok: false, message: `${target} 本机已装（v${installedVersion(target) || '?'}），未重复安装` };
   }
 
-  let spec = '';
-  if (plugin.bundle && fs.existsSync(plugin.bundle.path)) {
-    // file: 路径必须用正斜杠，pnpm 在 Windows 上按反斜杠解析成转义
-    spec = `file:${plugin.bundle.path.replace(/\\/g, '/')}`;
-  } else if (plugin.kind === 'registry' || plugin.kind === 'installation') {
-    spec = plugin.version ? `${target}@${plugin.version}` : target;
-  } else {
+  // 安装坐标必须来自 registry/git 这种能联网拉到的写法，file:/link: 一律不受理
+  const spec = typeof plugin.installSpec === 'string' ? plugin.installSpec.trim() : '';
+  if (!spec) {
     return {
       ok: false,
-      message: `${target} 是 ${plugin.kind} 来源，对方特征里没有可用副本，无法安装`,
+      message:
+        `${target} 没有可联网的安装坐标（${plugin.kind} 来源，对方未发布到 registry）。` +
+        '特征文件夹只存清单，不提供本地副本安装，所以这个插件装不了——' +
+        '要么请对方发布到 npm，要么你手动从源仓库装。',
+    };
+  }
+  if (/^(file:|link:|workspace:|portal:)/i.test(spec)) {
+    return {
+      ok: false,
+      message: `${target} 的安装坐标是本地路径（${spec}），本插件只走 registry 联网拉取。`,
     };
   }
-
-  if (typeof installSpec !== 'function') return { ok: false, message: '安装通道不可用' };
   const result = await installSpec({ ctx, spec, log });
   if (!result?.ok) {
     return { ok: false, spec, message: result?.message || '安装失败' };
@@ -974,7 +851,7 @@ export function shareSnapshot({ config, publishedNames } = {}) {
     }))
     .sort((a, b) => {
       // 能装、没装的排前面，方便一眼看到要点什么
-      const rank = (item) => (item.installed ? 2 : item.bundle || item.kind === 'registry' ? 0 : 1);
+      const rank = (item) => (item.installed ? 2 : item.installable ? 0 : 1);
       const diff = rank(a) - rank(b);
       return diff !== 0 ? diff : a.name.localeCompare(b.name);
     });
@@ -1000,8 +877,11 @@ export function shareSnapshot({ config, publishedNames } = {}) {
       ? {
           generatedAt: manifest.generatedAt,
           counts: manifest.counts,
-          bundles: Array.isArray(manifest.bundles) ? manifest.bundles : [],
-          skipped: Array.isArray(manifest.skipped) ? manifest.skipped : [],
+          // 只存清单：这两个老字段固定为空，面板据此确认「没有副本」
+          bundles: [],
+          skipped: [],
+          policy: manifest.policy || SHARE_POLICY,
+          legacyPurged: manifest.legacyPurged || { removed: [], bytes: 0, error: '' },
         }
       : null,
     mine,
@@ -1015,6 +895,8 @@ export function shareSnapshot({ config, publishedNames } = {}) {
           file: aggregateFile,
         }
       : null,
-    limits: { maxBundleMb: MAX_BUNDLE_MB, maxFeatureMb: MAX_FEATURE_MB, keepBundles: KEEP_BUNDLES },
+    /** 共享策略：只存清单、安装走 registry。面板据此显示口径，不再有副本上限。 */
+    policy: SHARE_POLICY,
+    limits: { maxBundleMb: 0, maxFeatureMb: 0, keepBundles: 0 },
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ygc-dsh-plugin-autoupdate",
-  "version": "0.9.5",
+  "version": "0.9.6",
   "type": "module",
   "description": "DSH 插件自动更新器：定时检查已装插件的新版本并按策略升级；把自己的插件特征（清单+本地副本+本机汇总）同步到共享插件库自己那一格，本机标识与会话同步插件共用，并汇集他人清单供人工选用。",
   "icon": "icon.svg",