ygc-dsh-sync 1.2.0 → 1.2.1

package/lib/features.js

@@ -1,23 +1,25 @@
 /**
- * 本机特征文件夹（`<工作区>/.dsh-sync/sessions/<本机标识>/`）的采纳、撤销与「谁参与」判定。
+ * 本机特征文件夹（`<工作区>/.dsh-sync/sessions/<本机标识>/`）的采纳、撤销与巡检判据。
  *
- * 用户 2026-11-14 定的规矩（这一层是这套规矩的唯一实现）：
+ * 判据只有一条：**磁盘上有没有那三个东西** —— 别人的特征文件夹、我的特征文件夹、
+ * 对应的工作区（DSH 的 workspaceRegistry 注册）。
+ * 用户 2026-11-14 定的巡检矩阵（这一层就是它的唯一实现）：
  *
- *   1. **检测到的匹配目录要人点**：巡检扫出「符合插件结构、但本机还没建特征文件夹」
- *      的目录时，只列出来问人，绝不自己建。人点了同意 → 建格子 + 注册成工作区
- *      （进侧边栏，参与备份与拉取），一次做完。
- *   2. **新建的保持原样**：本机新建的共享工作区默认就带特征文件夹
- *      （1.1.0 之前一直是这个行为，升级不能把它改成必须点一下）。
- *   3. **外部删掉会自愈**：曾经建过、现在磁盘上没有 → 巡检自动补建，不进人工队列。
- *   4. **删工作区就删格**：本机把某个工作区从侧边栏删掉后，它的特征文件夹跟着删。
- *      只删本机那一格，别人的格子一个字节都不动。
- *   5. **没格子的不干活**：备份、拉取、自动备份、自动拉取、补登记，
- *      一律只对「特征文件夹存在」的工作区生效。
+ * | 别人的格子 | 我的格子 | 工作区 | 动作 |
+ * |---|---|---|---|
+ * | 有 | 没有 | 没有 | **问人**：要不要在本机建特征文件夹（建了就顺带注册工作区） |
+ * | — | 有 | 有 | 正常，参与备份与拉取 |
+ * | — | 有 | 没有 | **补工作区**：把目录注册回侧边栏（不建也不删文件） |
+ * | — | 没有 | 有 | **补文件夹**：给这个工作区建本机特征文件夹 |
  *
- * 判据永远是磁盘：「特征文件夹存在」= 已参与。state 里只记三样辅助信息：
- *   initialized  1.2.0 首次运行是否已经把「存量工作区」归过档
- *   decisions    人对某个路径的表态（adopt / decline），防止反复骚扰
- *   known        已经采纳过的工作区（id → 路径），用来判「被删除」与「被外部删除」
+ * 删除的语义（同样是用户定的）：
+ *
+ * - 删工作区时，**先看有没有别人的格子**：
+ *   - 只有本机这一格 → 连 `.dsh-sync/` 一起收掉，巡检**再也扫不到**它（不留痕、不追问）。
+ *   - 还有别人的格子 → 只删我这一格（连同格里备份的对话记录），`.dsh-sync/` 留着，
+ *     巡检据此认为「本机没有这个共享工作区」，进人工队列问要不要重建。
+ * - 插件**不提供**「只删格子、留着工作区」的入口：那会让工作区变成
+ *   「已注册但没格子」，下一轮必然被补回来，看起来就是「删了又冒出来」。
  */
 import fs from 'node:fs';
 import path from 'node:path';
@@ -30,12 +32,34 @@ export function featurePath(workspacePath, machineId) {
   return ownRoot(workspacePath, machineId);
 }
 
-/** 特征文件夹是否已存在（必须真的是目录）。 */
+/** 本机特征文件夹是否已存在（必须真的是目录）。 */
 export function hasFeature(workspacePath, machineId) {
   const st = safeStat(featurePath(workspacePath, machineId));
   return !!st && st.isDirectory();
 }
 
+/** 这个工作区里，除了本机之外还有哪些机器的特征文件夹。 */
+export function otherFeatures(workspacePath, machineId) {
+  const sessions = path.join(normSlash(workspacePath), TARGET_DIR_NAME);
+  let names = [];
+  try {
+    names = fs
+      .readdirSync(sessions, { withFileTypes: true })
+      .filter((d) => d.isDirectory())
+      .map((d) => d.name);
+  } catch {
+    return [];
+  }
+  const me = String(machineId || '');
+  return names.filter((n) => n !== me);
+}
+
+/** 目录里是否还有 `.dsh-sync/` 这套结构（含 sessions）。 */
+export function hasSyncStructure(workspacePath) {
+  const st = safeStat(path.join(normSlash(workspacePath), TARGET_DIR_NAME.split(path.sep)[0]));
+  return !!st && st.isDirectory();
+}
+
 /**
  * 建本机特征文件夹。
  *
@@ -54,12 +78,15 @@ export function adoptFeature(workspacePath, machineId) {
 }
 
 /**
- * 删本机特征文件夹（删工作区时调用）。
+ * 删本机特征文件夹（**连同格里备份的对话记录**）。
  *
  * 三条约束：
- *   - 只删本机那一格；
- *   - `sessions/` 里还有别人的备份时，`sessions/` 与 `.dsh-sync/` 一概不动；
+ *   - 只删本机那一格；别人的格子一个字节都不动；
+ *   - `sessions/` 空了才把 `sessions/` 与 `.dsh-sync/` 一起收掉 ——
+ *     全收掉之后巡检就再也扫不到这个目录，符合「只有本机格子时删干净」；
  *   - 目标不存在算成功（幂等）。
+ *
+ * @returns {{removed:boolean, target?:string, keptStructure?:boolean, others?:string[], reason?:string}}
  */
 export function dropFeature(workspacePath, machineId, { log = () => {} } = {}) {
   if (!machineId) return { removed: false, reason: '缺少本机标识' };
@@ -67,11 +94,14 @@ export function dropFeature(workspacePath, machineId, { log = () => {} } = {}) {
   if (path.basename(target) !== String(machineId)) {
     return { removed: false, reason: '目标不是本机特征文件夹' };
   }
+  const others = otherFeatures(workspacePath, machineId);
   const st = safeStat(target);
-  if (!st) return { removed: false, reason: '本来就没有' };
-  if (!st.isDirectory()) return { removed: false, reason: '不是目录' };
+  if (!st) {
+    return { removed: false, reason: '本来就没有', others, keptStructure: hasSyncStructure(workspacePath) };
+  }
+  if (!st.isDirectory()) return { removed: false, reason: '不是目录', others };
   fs.rmSync(target, { recursive: true, force: true });
-  log(`删除本机特征文件夹 ${target}`);
+  log(`删除本机特征文件夹（含其中备份的对话）：${target}`);
 
   // 收尾：空了才收，避免把别人的备份目录一起删掉
   const sessionsDir = path.join(normSlash(workspacePath), TARGET_DIR_NAME);
@@ -83,7 +113,12 @@ export function dropFeature(workspacePath, machineId, { log = () => {} } = {}) {
       /* 收尾失败不影响主结果 */
     }
   }
-  return { removed: true, target };
+  return {
+    removed: true,
+    target,
+    others,
+    keptStructure: hasSyncStructure(workspacePath),
+  };
 }
 
 /* ----------------------------------------------------------- 决策与基线 */
@@ -97,23 +132,19 @@ const keyOf = (p) => {
   }
 };
 
-/** 人为某个路径表过态吗？返回 'adopt' | 'decline' | 'ask' | null。 */
+/** 人为某个路径表过态吗？返回 'adopt' | 'decline' | null。 */
 export function decisionOf(state, workspacePath) {
   const bag = (state && state.features && state.features.decisions) || {};
   const hit = bag[keyOf(workspacePath)];
   if (!hit) return null;
-  if (hit.action === 'decline') return 'decline';
-  if (hit.action === 'ask') return 'ask';
-  return 'adopt';
+  return hit.action === 'decline' ? 'decline' : 'adopt';
 }
 
 /**
- * 记一次表态。
+ * 记一次人为表态。
  *
  *   adopt    人点了「建格子」（之后缺了就自动补）
  *   decline  人点了「不要」（之后只列出来，不自动建）
- *   ask      已经在面板上问过人、还等回话 —— 不写这一条，下一轮巡检
- *            会把「等待表态」误当成「本机新建」，直接替人建了格子。
  */
 export function rememberDecision(state, workspacePath, action) {
   if (!state.features || typeof state.features !== 'object') {
@@ -122,16 +153,15 @@ export function rememberDecision(state, workspacePath, action) {
   if (!state.features.decisions || typeof state.features.decisions !== 'object') {
     state.features.decisions = {};
   }
-  const normalized = action === 'decline' ? 'decline' : action === 'ask' ? 'ask' : 'adopt';
   state.features.decisions[keyOf(workspacePath)] = {
-    action: normalized,
+    action: action === 'decline' ? 'decline' : 'adopt',
     path: normSlash(workspacePath),
     at: Date.now(),
   };
   return state;
 }
 
-/** 清掉某路径的表态（人后来又把格子建回来时用）。 */
+/** 清掉某路径的表态。 */
 export function forgetDecision(state, workspacePath) {
   const bag = (state.features && state.features.decisions) || null;
   if (!bag) return state;
@@ -142,22 +172,22 @@ export function forgetDecision(state, workspacePath) {
 /* --------------------------------------------------------------- 巡检计划 */
 
 /**
- * 算本轮该对特征文件夹做什么。**纯函数：不落盘、不改任何文件。**
+ * 算本轮该对特征文件夹做什么。**纯函数：不落盘、不改任何文件、不注册工作区。**
  *
  * 输入：
  *   folders     特定文件夹前缀
  *   workspaces  当前工作区清单（id/path/title）
- *   discover    巡检扫出、但还没注册成工作区的目录（{path,title,folder}）
- *   state       插件状态（读 features.initialized / known / decisions）
+ *   discover    巡检扫出、「有 .dsh-sync 结构但没注册成工作区」的目录
+ *   state       插件状态（读 features.known / decisions）
  *   machineId   本机标识
  *
- * 输出：
- *   active   已有格子、正常参与备份与拉取的工作区
- *   adopt    本机新建的工作区 → **默认建格子**（保持 1.1.0 原有设置）
- *   restore  曾经建过、现在磁盘上没有 → 自动补建（被外部删掉的自愈）
- *   drop     本机已删除的工作区 → 跟着删格子
- *   pending  必须人工表态的：未注册的匹配目录，以及升级时检出的存量工作区
- *   seed     首次运行需要把「已有格子」的存量工作区记进基线（不改任何文件）
+ * 输出（正好对上那张矩阵）：
+ *   active         有我的格子 + 有工作区 → 正常
+ *   createFolder   有工作区 + 没我的格子 → 补文件夹
+ *   restoreWorkspace  有我的格子 + 没工作区 → 补工作区
+ *   ask            没我的格子 + 没工作区 + 目录有 .dsh-sync → 问人
+ *   drop           基线里有、现在清单里没有 → 工作区被删了，格子要跟着删
+ *   seed           有格子的工作区（进基线，之后靠它判「被删除」）
  */
 export function planFeatures({
   folders = [],
@@ -168,13 +198,12 @@ export function planFeatures({
 } = {}) {
   const features = (state && state.features) || {};
   const known = features.known || {};
-  const initialized = features.initialized === true;
   const seenNow = {};
-  const adopt = [];
-  const restore = [];
-  const drop = [];
-  const pending = [];
   const active = [];
+  const createFolder = [];
+  const restoreWorkspace = [];
+  const ask = [];
+  const drop = [];
   const seed = [];
 
   const underFolders = (p) => {
@@ -184,6 +213,7 @@ export function planFeatures({
       return key === fk || key.startsWith(fk + path.sep) || key.startsWith(fk + '/');
     });
   };
+  const alreadyAsk = (p) => ask.some((x) => keyOf(x.path) === keyOf(p));
 
   for (const ws of workspaces || []) {
     if (!ws || !ws.path) continue;
@@ -192,49 +222,55 @@ export function planFeatures({
     const entry = { id, path: ws.path, title: ws.title || path.basename(ws.path) };
 
     if (hasFeature(ws.path, machineId)) {
+      // 有我的格子 + 有工作区 → 正常
       active.push(entry);
-      // 已有格子的一律进基线：首次运行靠它建档，之后靠它判「被删除」
       seed.push(entry);
       continue;
     }
 
-    // 缺格子：不在特定文件夹里的本来就不归本插件管，不建也不问
+    // 不在特定文件夹里的本来就不归本插件管
     if (!underFolders(ws.path)) continue;
 
-    const wasKnown = Object.prototype.hasOwnProperty.call(known, id);
-    const said = decisionOf(state, ws.path);
-    if (said === 'decline') {
-      // 人说过不要 → 仍然列出来（可以改主意），但不自己建
-      pending.push({ ...entry, why: 'declined' });
-    } else if (said === 'ask') {
-      // 已经在面板上问过、还没回话 → 继续等着，别替人决定
-      pending.push({ ...entry, why: 'awaiting' });
-    } else if (said === 'adopt' || wasKnown) {
-      // 人点过同意 / 曾经建过又没了 → 自动补
-      restore.push({ ...entry, why: wasKnown ? 'vanished' : 'adopted' });
-    } else if (!initialized) {
-      // 1.2.0 首次运行：存量工作区，交给人决定
-      pending.push({ ...entry, why: 'existing' });
-    } else {
-      // 基线建档之后才出现 = 本机新建的，默认建格子
-      adopt.push({ ...entry, why: 'new' });
+    if (decisionOf(state, ws.path) === 'decline') {
+      // 人明确说过这个目录不要建 → 只列出来，不自作主张
+      ask.push({ ...entry, why: 'declined' });
+      continue;
     }
+
+    // 有工作区 + 没我的格子 → 补文件夹
+    createFolder.push({ ...entry, why: 'workspace-without-folder' });
   }
 
-  // 匹配目录里还没注册成工作区的：必须人工选择（同意后建格子 + 注册一起做）
+  // 有 .dsh-sync 结构、但没注册成工作区的目录
+  const knownWorkspacePaths = new Set(Object.values(seenNow).map((p) => keyOf(p)));
   for (const d of discover || []) {
     if (!d || !d.path) continue;
-    if (decisionOf(state, d.path) === 'decline') continue;
-    if (hasFeature(d.path, machineId)) continue;
-    pending.push({
+    if (alreadyAsk(d.path)) continue;
+    // 已经在「工作区清单」里的，前面那一轮已经按「有工作区没格子 → 补文件夹」处理过了，
+    // 这里必须跳过：同一个目录不能既补文件夹又问人（scanFolders 会把它同时扫进 discover）。
+    if (knownWorkspacePaths.has(keyOf(d.path))) continue;
+    const title = d.title || path.basename(d.path);
+    if (decisionOf(state, d.path) === 'decline') {
+      ask.push({ id: null, path: d.path, title, why: 'declined' });
+      continue;
+    }
+    if (hasFeature(d.path, machineId)) {
+      // 有我的格子 + 没工作区 → 补工作区
+      restoreWorkspace.push({ id: null, path: d.path, title, why: 'folder-without-workspace' });
+      continue;
+    }
+    // 没我的格子 + 没工作区 + 目录有结构 → 问人
+    const others = otherFeatures(d.path, machineId);
+    ask.push({
       id: null,
       path: d.path,
-      title: d.title || path.basename(d.path),
-      why: 'unregistered',
+      title,
+      why: others.length ? 'others-only' : 'structure-only',
+      others,
     });
   }
 
-  // 基线里、这一轮清单里没有的 = 本机删了工作区 → 跟着删格子
+  // 基线里有、这一轮清单里没有 = 工作区被删了 → 格子跟着删
   for (const [id, p] of Object.entries(known)) {
     if (Object.prototype.hasOwnProperty.call(seenNow, id)) continue;
     if (!p) continue;
@@ -242,53 +278,24 @@ export function planFeatures({
     drop.push({ id, path: p, title: path.basename(p) });
   }
 
-  return { active, adopt, restore, drop, pending, seed, seenNow };
+  return { active, createFolder, restoreWorkspace, ask, drop, seed, seenNow };
 }
 
 /**
- * 把「本轮列进 pending 问人的」记成 ask，避免下一轮被当成「本机新建」。
+ * 执行计划里「不需要人点头」的部分：补文件夹、删格子，并回写基线。
  *
- * 只对「已注册工作区缺格子」这一类记（why = existing / awaiting），
- * 未注册的匹配目录本来就不会自动处理，不必额外打标。
- */
-export function markAsked(state, plan) {
-  if (!state.features) state.features = { initialized: false, decisions: {}, known: {} };
-  let n = 0;
-  for (const item of (plan && plan.pending) || []) {
-    if (item.why !== 'existing' && item.why !== 'awaiting') continue;
-    if (decisionOf(state, item.path) === 'ask') continue;
-    rememberDecision(state, item.path, 'ask');
-    n++;
-  }
-  return n;
-}
-
-/**
- * 执行计划里「不需要人点头」的部分（adopt / restore / drop + 基线），
- * 并把首次运行标记打上。
- *
- * `pending` 不在这里处理：那一档必须由人显式调用 /features/adopt 才动。
+ * **不处理 `restoreWorkspace`**：注册工作区要走宿主接口（async），由调用方做。
+ * `ask` 更不能在这里动。
  */
 export function applyFeaturePlan({ plan, state, machineId, log = () => {} } = {}) {
-  const adopted = [];
-  const restored = [];
+  const created = [];
   const dropped = [];
   const errors = [];
 
-  for (const item of plan.adopt || []) {
-    try {
-      adoptFeature(item.path, machineId);
-      adopted.push(item);
-    } catch (err) {
-      errors.push({ path: item.path, message: String((err && err.message) || err) });
-    }
-  }
-  for (const item of plan.restore || []) {
+  for (const item of plan.createFolder || []) {
     try {
       adoptFeature(item.path, machineId);
-      restored.push(item);
-      forgetDecision(state, item.path);
-      log(`补建本机特征文件夹 ${item.path}`);
+      created.push(item);
     } catch (err) {
       errors.push({ path: item.path, message: String((err && err.message) || err) });
     }
@@ -296,62 +303,33 @@ export function applyFeaturePlan({ plan, state, machineId, log = () => {} } = {}
   for (const item of plan.drop || []) {
     try {
       const out = dropFeature(item.path, machineId, { log });
-      if (out.removed) dropped.push(item);
+      if (out.removed) dropped.push({ ...item, others: out.others, keptStructure: out.keptStructure });
+      // 删干净之后不能再留任何记录，否则巡检会「记住」一个已经不该存在的目录
+      forgetDecision(state, item.path);
     } catch (err) {
       errors.push({ path: item.path, message: String((err && err.message) || err) });
     }
   }
 
-  // 基线：只记「这一轮真的在清单里」且「现在有格子」的工作区
   if (!state.features || typeof state.features !== 'object') {
     state.features = { initialized: false, decisions: {}, known: {} };
   }
-  // 这一轮问过人的，打上 ask 标记——否则下一轮 initialized 已是 true，
-  // 会被当成「本机新建」直接建格子，等于替人做了决定。
-  markAsked(state, plan);
   const keep = {};
-  const live = new Set((plan.seenNow ? Object.keys(plan.seenNow) : []).map(String));
   for (const item of plan.seed || []) keep[item.id] = item.path;
-  for (const item of adopted) keep[item.id] = item.path;
-  for (const item of restored) keep[item.id] = item.path;
+  for (const item of created) keep[item.id] = item.path;
   // 已有但本轮没扫到的（前缀被改掉等）保留，避免误判成「被删除」
+  const live = new Set(Object.keys(plan.seenNow || {}).map(String));
   for (const [id, p] of Object.entries(state.features.known || {})) {
     if (keep[id]) continue;
     if (live.has(String(id))) continue;
-    if (plan.drop && plan.drop.some((d) => String(d.id) === String(id))) continue;
+    if ((plan.drop || []).some((d) => String(d.id) === String(id))) continue;
     keep[id] = p;
   }
   state.features.known = keep;
   state.features.initialized = true;
   state.features.lastPlanAt = Date.now();
 
-  return { adopted, restored, dropped, errors };
-}
-
-/**
- * 只做「删掉的工作区 → 删格子」这一件事。
- *
- * 供 30 秒一次的轻量巡检用：不扫盘、不建目录，只按给定 id 清单清格子。
- * `confirmedIds` 由 pickRemovedIds 选出来（已经过二次确认）。
- */
-export function reconcileRemoved(state, machineId, confirmedIds, { log = () => {} } = {}) {
-  const dropped = [];
-  const errors = [];
-  if (!state.features || typeof state.features !== 'object') return { dropped, errors };
-  const known = state.features.known || {};
-  for (const id of confirmedIds || []) {
-    const key = String(id);
-    const p = known[key];
-    if (!p) continue;
-    try {
-      const out = dropFeature(p, machineId, { log });
-      if (out.removed) dropped.push({ id: key, path: p });
-      delete known[key];
-    } catch (err) {
-      errors.push({ id: key, path: p, message: String((err && err.message) || err) });
-    }
-  }
-  return { dropped, errors };
+  return { created, dropped, errors };
 }
 
 /**
@@ -362,10 +340,6 @@ export function reconcileRemoved(state, machineId, confirmedIds, { log = () => {
  * 等于把这个工作区的同步历史一把抹掉。规矩：
  *   - 清单为空 → 本轮什么都不确认（清除计时）；
  *   - 同一个 id 连续两轮都不在，且间隔 ≥ minAgeMs，才确认删除。
- *
- * @param {{known:Object<string,string>, liveIds:string[], missingSince:Map<string,number>,
- *          now:number, minAgeMs:number}} input
- * @returns {{confirmed:string[], missingSince:Map<string,number>}}
  */
 export function pickRemovedIds({ known = {}, liveIds = [], missingSince, now = Date.now(), minAgeMs = 30000 }) {
   const next = missingSince instanceof Map ? missingSince : new Map();
@@ -377,7 +351,6 @@ export function pickRemovedIds({ known = {}, liveIds = [], missingSince, now = D
     return { confirmed, missingSince: next };
   }
 
-  // 又回来了 / 基线里已经没有它了 → 清掉计时
   for (const id of [...next.keys()]) {
     if (live.has(id) || !Object.prototype.hasOwnProperty.call(known, id)) next.delete(id);
   }
@@ -396,7 +369,34 @@ export function pickRemovedIds({ known = {}, liveIds = [], missingSince, now = D
   return { confirmed, missingSince: next };
 }
 
-/** 过滤：只留下「特征文件夹存在」的工作区。备份/拉取/展示都用它。 */
+/**
+ * 删掉「被删除的工作区」对应的本机格子（连同格里备份的对话），并清掉基线。
+ *
+ * 只做这一件事，不碰别人的格子；`.dsh-sync/` 是否被一起收掉由 dropFeature 判断。
+ * 删完不再留任何记录 —— 只有本机格子时巡检必须再也看不到它。
+ */
+export function reconcileRemoved(state, machineId, confirmedIds, { log = () => {} } = {}) {
+  const dropped = [];
+  const errors = [];
+  if (!state.features || typeof state.features !== 'object') return { dropped, errors };
+  const known = state.features.known || {};
+  for (const id of confirmedIds || []) {
+    const key = String(id);
+    const p = known[key];
+    if (!p) continue;
+    try {
+      const out = dropFeature(p, machineId, { log });
+      dropped.push({ id: key, path: p, others: out.others, keptStructure: out.keptStructure });
+      delete known[key];
+      forgetDecision(state, p);
+    } catch (err) {
+      errors.push({ id: key, path: p, message: String((err && err.message) || err) });
+    }
+  }
+  return { dropped, errors };
+}
+
+/** 过滤：只留下「有本机特征文件夹」的工作区。备份/拉取/展示都用它。 */
 export function onlyActive(list, machineId) {
   return (list || []).filter((ws) => ws && ws.path && hasFeature(ws.path, machineId));
 }
@@ -405,5 +405,5 @@ export function onlyActive(list, machineId) {
 export function inactiveReason(workspacePath, machineId, state) {
   if (hasFeature(workspacePath, machineId)) return '';
   if (decisionOf(state, workspacePath) === 'decline') return '你选了不在这个文件夹建本机特征文件夹';
-  return '还没有建本机特征文件夹（未参与备份与拉取）';
+  return '还没有建本机特征文件夹（下次巡检会自动补上）';
 }

package/package.json

@@ -1,62 +1,62 @@
-{
-  "name": "ygc-dsh-sync",
-  "version": "1.2.0",
-  "type": "module",
-  "description": "DSH 同步插件：会话按工作区落地、按机器隔离的跨机备份与拉取；技能本机↔母版双向同步（含记忆插件技能优化闭环）；插件清单共享（只存清单与来源，不存源码，只能联网装）。",
-  "icon": "icon.svg",
-  "keywords": [
-    "dsh",
-    "deepseek-harness",
-    "dsh-plugin",
-    "session",
-    "sync",
-    "backup",
-    "plugin-manifest"
-  ],
-  "license": "MIT",
-  "exports": {
-    ".": "./index.js",
-    "./client": "./client.js",
-    "./locale/*.json": "./locale/*.json",
-    "./icon": "./icon.svg"
-  },
-  "files": [
-    "index.js",
-    "client.js",
-    "lib/core.js",
-    "lib/features.js",
-    "lib/plugins.js",
-    "lib/backup.js",
-    "lib/attach.js",
-    "lib/api.js",
-    "lib/patrol.js",
-    "lib/skills.js",
-    "lib/mnemon.js",
-    "lib/mnemon-optimize.js",
-    "lib/changelog.js",
-    "lib/zstd-frame.js",
-    "cordis.patch.yml",
-    "locale/*.json",
-    "icon.svg",
-    "README.md",
-    "tools/*.mjs",
-    "lib/mnemon-pipeline.js",
-    "lib/mnemon-drafter.js"
-  ],
-  "publishConfig": {
-    "registry": "https://registry.npmjs.org/",
-    "access": "public"
-  },
-  "dsh": {
-    "bundle": {
-      "patch": "./cordis.patch.yml"
-    },
-    "client": {
-      "platform": "web",
-      "immediately": true,
-      "inject": [
-        "@deepseek-ai/dsh-client-ui-conversation"
-      ]
-    }
-  }
-}
+{
+  "name": "ygc-dsh-sync",
+  "version": "1.2.1",
+  "type": "module",
+  "description": "DSH 同步插件：会话按工作区落地、按机器隔离的跨机备份与拉取；技能本机↔母版双向同步（含记忆插件技能优化闭环）；插件清单共享（只存清单与来源，不存源码，只能联网装）。",
+  "icon": "icon.svg",
+  "keywords": [
+    "dsh",
+    "deepseek-harness",
+    "dsh-plugin",
+    "session",
+    "sync",
+    "backup",
+    "plugin-manifest"
+  ],
+  "license": "MIT",
+  "exports": {
+    ".": "./index.js",
+    "./client": "./client.js",
+    "./locale/*.json": "./locale/*.json",
+    "./icon": "./icon.svg"
+  },
+  "files": [
+    "index.js",
+    "client.js",
+    "lib/core.js",
+    "lib/features.js",
+    "lib/plugins.js",
+    "lib/backup.js",
+    "lib/attach.js",
+    "lib/api.js",
+    "lib/patrol.js",
+    "lib/skills.js",
+    "lib/mnemon.js",
+    "lib/mnemon-optimize.js",
+    "lib/changelog.js",
+    "lib/zstd-frame.js",
+    "cordis.patch.yml",
+    "locale/*.json",
+    "icon.svg",
+    "README.md",
+    "tools/*.mjs",
+    "lib/mnemon-pipeline.js",
+    "lib/mnemon-drafter.js"
+  ],
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "immediately": true,
+      "inject": [
+        "@deepseek-ai/dsh-client-ui-conversation"
+      ]
+    }
+  }
+}