ygc-dsh-sync 1.2.1 → 1.3.0

package/lib/skill-scope.js

@@ -0,0 +1,288 @@
+/**
+ * 技能归属判定：哪些技能归本插件管（可共享、可优化），哪些不归。
+ *
+ * 用户定的规矩（2026-11-15）：
+ *   来自技能市场的第三方技能**不管理、不同步、不优化**（例如记忆插件
+ *   dsh-mnemon 自带的技能市场）；只对本机自己总结 / 编写的技能做优化与共享。
+ *
+ * 为什么单独一层：这条规矩要同时被三个入口遵守——共享备份、跨机拉取、
+ * 本机优化。写在三个地方必然走形，所以判定只在这里做一次，别处一律消费结论。
+ *
+ * 判据顺序（强证据优先，宁可少管也不要动第三方）：
+ *   1. 人工覆盖（state.skills.share.scope[name]）        → 说了算
+ *   2. 市场安装台账 `~/.mnemon/skills/ledger.json` 的 installs[]
+ *                                                       → 第三方（最硬的一条：
+ *                                                         这是市场自己写的记录）
+ *   3. 市场官方目录 `market/official.json` 同名 + 目录里有 LICENSE*
+ *                                                       → 第三方（台账被清掉时兜底）
+ *   4. 母版 / 技能库同名                                 → 自己的
+ *   5. 其余                                              → 按「自己的」处理，
+ *                                                          但证据记为 weak，
+ *                                                          面板上能一眼看出来
+ *
+ * 母版要废弃这件事（用户 2026-11-15）在这里的处置：
+ *   masterRoot 只作为**加分证据**，不是必要条件。只要判定过一次，结论就写进
+ *   `state.skills.share.scope`（本机持久化），母版删掉之后既有判定不丢；
+ *   新出现的技能按第 5 条默认归自己——新建技能本来就写在 ~/.agents/skills 里。
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+
+/** 市场台账（记忆插件的技能市场用它记录「装了什么、从哪来」）。 */
+export const MNEMON_LEDGER = process.env.DSH_SYNC_MNEMON_LEDGER
+  ? path.resolve(process.env.DSH_SYNC_MNEMON_LEDGER)
+  : path.join(os.homedir(), '.mnemon', 'skills', 'ledger.json');
+
+/** 记忆插件自带的官方精选市场目录（39 条）。 */
+export const MARKET_OFFICIAL = path.join(
+  os.homedir(),
+  '.dsh',
+  'profiles',
+  'desktop',
+  'node_modules',
+  'dsh-mnemon-source-skills',
+  'market',
+  'official.json',
+);
+
+/** 市场安装会附带这类许可证文件，作为「不是我写的」的弱证据。 */
+const LICENSE_RE = /^(LICEN[CS]E|COPYING)(\.[A-Za-z0-9]+)?$/i;
+
+export const SCOPE = Object.freeze({
+  OWN: 'own',
+  THIRD_PARTY: 'third-party',
+});
+
+/* -------------------------------------------------------------- 读证据 */
+
+function readJson(file) {
+  try {
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * 读市场安装台账：技能名集合 + 细节。
+ *
+ * 台账里的 `installs[]` 每条长这样：
+ *   { skillKey, registryId, name, source: { type:'github', repo, path, ref }, hash, files, installedAt }
+ * 只要 `name` 命中，就算市场装的。
+ */
+export function readMarketInstalls(file = MNEMON_LEDGER) {
+  const doc = readJson(file);
+  const out = new Map();
+  if (!doc || !Array.isArray(doc.installs)) return { file, ok: false, installs: out };
+  for (const it of doc.installs) {
+    const name = typeof it?.name === 'string' ? it.name.trim() : '';
+    if (!name) continue;
+    const prev = out.get(name);
+    const at = typeof it.installedAt === 'string' ? it.installedAt : '';
+    // 同一个技能可能被装过多次：保留最新一次
+    if (!prev || at > prev.installedAt) {
+      out.set(name, {
+        name,
+        skillKey: typeof it.skillKey === 'string' ? it.skillKey : '',
+        registryId: typeof it.registryId === 'string' ? it.registryId : '',
+        repo: it?.source?.repo || '',
+        ref: it?.source?.ref || '',
+        srcPath: it?.source?.path || '',
+        hash: typeof it.hash === 'string' ? it.hash : '',
+        installedAt: at,
+      });
+    }
+  }
+  return { file, ok: true, installs: out };
+}
+
+/** 读官方精选目录里的技能名集合（离线文件，不是联网查）。 */
+export function readMarketCatalog(file = MARKET_OFFICIAL) {
+  const doc = readJson(file);
+  const names = new Set();
+  if (!doc || !Array.isArray(doc.skills)) return { file, ok: false, names };
+  for (const s of doc.skills) {
+    const name = typeof s?.name === 'string' ? s.name.trim() : '';
+    if (name) names.add(name);
+  }
+  return { file, ok: true, names, id: typeof doc.id === 'string' ? doc.id : '' };
+}
+
+/** 目录里有没有许可证文件（市场技能的常见特征，只作弱证据）。 */
+export function hasLicenseFile(dir) {
+  let entries = [];
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return false;
+  }
+  return entries.some((e) => e.isFile() && LICENSE_RE.test(e.name));
+}
+
+/** 扫本机技能根：只认含 SKILL.md 的目录，跳过备份残留。 */
+export function listLocalSkillDirs(root) {
+  const out = [];
+  let entries = [];
+  try {
+    entries = fs.readdirSync(root, { withFileTypes: true });
+  } catch {
+    return out;
+  }
+  for (const e of entries) {
+    if (!e.isDirectory()) continue;
+    if (e.name.startsWith('.') || e.name.startsWith('_')) continue;
+    const dir = path.join(root, e.name);
+    if (!fs.existsSync(path.join(dir, 'SKILL.md'))) continue;
+    out.push({ name: e.name, dir });
+  }
+  return out.sort((a, b) => a.name.localeCompare(b.name));
+}
+
+/* ------------------------------------------------------------ 判定 */
+
+/**
+ * 判定全部本机技能的归属。
+ *
+ * @param {object} input
+ * @param {string} input.localRoot               本机技能根
+ * @param {string} [input.masterRoot]            母版 / 技能库（可空；只作加分证据）
+ * @param {Record<string,string>} [input.overrides] 人工覆盖：name → 'own' | 'third-party'
+ * @param {string} [input.ledgerFile]            市场安装台账
+ * @param {string} [input.catalogFile]           市场官方目录
+ * @returns {{items:Array, own:Array, thirdParty:Array, weak:Array, evidence:{}}}
+ */
+export function classifySkills({
+  localRoot,
+  masterRoot = '',
+  overrides = {},
+  ledgerFile = MNEMON_LEDGER,
+  catalogFile = MARKET_OFFICIAL,
+}) {
+  const installs = readMarketInstalls(ledgerFile);
+  const catalog = readMarketCatalog(catalogFile);
+  const dirs = listLocalSkillDirs(localRoot);
+  const masterSet = new Set();
+  if (masterRoot) {
+    let entries = [];
+    try {
+      entries = fs.readdirSync(masterRoot, { withFileTypes: true });
+    } catch {
+      entries = [];
+    }
+    for (const e of entries) {
+      if (!e.isDirectory() || e.name.startsWith('_') || e.name.startsWith('.')) continue;
+      if (fs.existsSync(path.join(masterRoot, e.name, 'SKILL.md'))) masterSet.add(e.name);
+    }
+  }
+
+  const items = [];
+  for (const { name, dir } of dirs) {
+    const evidence = [];
+    let scope = '';
+    let by = '';
+
+    const override = overrides && typeof overrides === 'object' ? overrides[name] : undefined;
+    if (override === SCOPE.OWN || override === SCOPE.THIRD_PARTY) {
+      scope = override;
+      by = 'manual';
+      evidence.push(`人工指定为 ${override === SCOPE.OWN ? '自己编写' : '第三方'}（面板上改的）`);
+    }
+
+    if (!scope && installs.installs.has(name)) {
+      const rec = installs.installs.get(name);
+      scope = SCOPE.THIRD_PARTY;
+      by = 'market-ledger';
+      evidence.push(
+        `市场安装台账有记录（${rec.registryId || 'market'} · ${rec.repo || '来源未记'}${rec.installedAt ? ` · ${rec.installedAt}` : ''}）`,
+      );
+    }
+
+    if (!scope && catalog.names.has(name) && hasLicenseFile(dir)) {
+      scope = SCOPE.THIRD_PARTY;
+      by = 'market-catalog';
+      evidence.push('官方精选目录里有同名技能，且目录带许可证文件（台账可能已被清理）');
+    }
+
+    if (!scope && masterSet.has(name)) {
+      scope = SCOPE.OWN;
+      by = 'master';
+      evidence.push('母版 / 技能库里同名（自己维护的那一份）');
+    }
+
+    if (!scope) {
+      scope = SCOPE.OWN;
+      // 母版存在时，「默认归自己」只是没有反证；母版取消之后这就是正常判定，不算弱。
+      by = masterSet.size ? 'default' : 'own-by-default';
+      evidence.push(
+        masterSet.size
+          ? '没有市场安装记录，也不在技能库里，按「自己编写」处理（可在面板上改）'
+          : '没有市场安装记录，按「自己编写」处理（母版已取消，这就是正常路径）',
+      );
+    }
+
+    items.push({
+      name,
+      dir,
+      scope,
+      by,
+      evidence,
+      // weak 只标「本机确实有个技能库、但这个技能不在里面」这种需要人看一眼的情况；
+      // 没有母版时不产生 weak。
+      weak: by === 'default',
+      license: hasLicenseFile(dir),
+    });
+  }
+
+  const own = items.filter((x) => x.scope === SCOPE.OWN);
+  const thirdParty = items.filter((x) => x.scope === SCOPE.THIRD_PARTY);
+  return {
+    items,
+    own,
+    thirdParty,
+    weak: items.filter((x) => x.weak),
+    evidence: {
+      ledger: { file: installs.file, ok: installs.ok, count: installs.installs.size },
+      catalog: { file: catalog.file, ok: catalog.ok, count: catalog.names.size },
+      master: { root: masterRoot || '', ok: Boolean(masterRoot), count: masterSet.size },
+    },
+  };
+}
+
+/**
+ * 只取「归本插件管」的名字集合（共享 / 拉取 / 优化三个入口都用它）。
+ *
+ * 做成 Set 而不是函数式判断，是为了让调用处能一次算完、反复查，避免每处理
+ * 一个技能就重读一次台账（140 个技能 × 每轮多次 = 慢性卡顿）。
+ */
+export function ownNames({ localRoot, masterRoot = '', overrides = {}, ledgerFile, catalogFile }) {
+  const r = classifySkills({ localRoot, masterRoot, overrides, ledgerFile, catalogFile });
+  const set = new Set(r.own.map((x) => x.name));
+  return {
+    names: set,
+    own: r.own,
+    thirdParty: r.thirdParty,
+    weak: r.weak,
+    evidence: r.evidence,
+    isOwn: (name) => set.has(name),
+  };
+}
+
+/** 面板摘要：只给计数与名字，别把 140 条明细塞进快照。 */
+export function scopeSnapshot(input) {
+  const r = classifySkills(input);
+  return {
+    counts: {
+      total: r.items.length,
+      own: r.own.length,
+      thirdParty: r.thirdParty.length,
+      weak: r.weak.length,
+    },
+    thirdParty: r.thirdParty.map((x) => ({ name: x.name, by: x.by, evidence: x.evidence.slice(0, 1) })),
+    weak: r.weak.map((x) => x.name),
+    evidence: r.evidence,
+    note:
+      '第三方（技能市场装的）不同步、不优化；自己编写或总结的才归本插件管。' +
+      '判定不看母版是否存在：母版废弃后，已有判定与人工指定都不受影响。',
+  };
+}

package/lib/skill-share-run.js

@@ -0,0 +1,388 @@
+/**
+ * 技能共享一轮：备份本机 → 扫别人 → 拉缺失 → 评估差异 → 记台账。
+ *
+ * 这一层只做编排，判定规则全在 skillshare.js（谁有什么、差在哪）与
+ * skill-learn.js（差异怎么处理）。分开的理由：判定要能被单测直接打，
+ * 而编排要能整体跳步（比如关掉学习、或宿主没有模型）。
+ *
+ * **写边界**：本文件只调用两个写入口——
+ *   syncMySkills / applySkillPull   → 写本机那一格与本机技能根
+ *   landLearningDraft / recordLearning → 写本机那一格的台账与草稿
+ * 别人的特征文件夹从头到尾只被读（readdirSync / readFileSync）。
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+
+import {
+  DRAFTS_DIR,
+  LEARNINGS_INDEX,
+  applySkillPull,
+  collectSharedSkills,
+  makeStamp,
+  mySkillsRoot,
+  recordOrigin,
+  syncMySkills,
+} from './skillshare.js';
+import { ownNames } from './skill-scope.js';
+import {
+  approveLearning,
+  findRedundantPairs,
+  learnOneDiff,
+  recordLearning,
+  writeLearningsMd,
+} from './skill-learn.js';
+import { scanSkills } from './skills.js';
+
+/** 一轮里「差异评估」最多用掉的模型调用（含重试），防止一次同步拖太久。 */
+const MAX_LEARN_MODEL_CALLS = 10;
+
+/**
+ * @param {object} input
+ * @param {object} input.config           { libraryRoot }
+ * @param {string} input.machineId        本机标识
+ * @param {string} [input.machineHash]
+ * @param {string} [input.machineName]
+ * @param {string} input.localRoot        本机技能根（~/.agents/skills）
+ * @param {string} [input.masterRoot]     母版根，仅用于名片上标「来源：母版 / 本机独属」
+ * @param {object} [input.modes]          单机属性表
+ * @param {boolean} [input.learn=true]    差异是否调模型评估
+ * @param {number} [input.learnPerRound=4]
+ * @param {boolean} [input.autoApply=false] 评估结论是否直接落到本机
+ * @param {Function|null} [input.generate] 宿主模型
+ * @param {boolean} [input.dryRun=false]
+ * @param {Function} [input.log]
+ * @param {string} [input.stamp]
+ * @param {string} [input.reason]         触发原因（开机 / 定时 / 手动 / 技能同步）
+ */
+export async function runSkillShare({
+  config,
+  machineId,
+  machineHash = '',
+  machineName = '',
+  localRoot,
+  masterRoot = '',
+  modes = {},
+  learn = true,
+  learnPerRound = 4,
+  autoApply = false,
+  generate = null,
+  dryRun = false,
+  log,
+  stamp,
+  reason = '定时',
+  scopeOverrides = {},
+}) {
+  const started = Date.now();
+  const feature = String(machineId || '').trim();
+  if (!feature) return { ok: false, error: '本机标识还没生成' };
+
+  // 归属判定先跑：市场装的第三方技能不备份、不拉取、不优化。
+  // 母版废弃后，这个集合只依赖「市场台账 + 人工指定 + 默认归自己」。
+  let scope = { names: null, thirdParty: [], weak: [], evidence: {} };
+  try {
+    scope = ownNames({ localRoot, masterRoot, overrides: scopeOverrides || {} });
+  } catch (err) {
+    log?.(`技能归属判定失败，本轮按「全部归自己」处理：${String((err && err.message) || err)}`);
+  }
+  const only = scope.names;
+
+  const report = {
+    ok: true,
+    feature,
+    reason,
+    scope: {
+      own: only ? only.size : null,
+      thirdParty: scope.thirdParty.map((x) => x.name),
+      weak: scope.weak.map((x) => x.name),
+    },
+    stamp: stamp || makeStamp(),
+    ms: 0,
+    backup: null,
+    peers: [],
+    missing: { found: 0, pulled: 0, errors: [] },
+    differ: { found: 0, evaluated: 0, byAction: {} },
+    learnings: null,
+    pending: 0,
+    applied: [],
+    autoApplyErrors: [],
+    errors: [],
+    skipped: '',
+  };
+
+  // ── 1. 先把本机技能备份出去（整棵目录 + 名片 + 索引）
+  if (!dryRun) {
+    try {
+      report.backup = syncMySkills({
+        config,
+        machineId: feature,
+        machineHash,
+        machineName,
+        localRoot,
+        masterRoot,
+        modes,
+        only,
+        log,
+        stamp: report.stamp,
+      });
+    } catch (err) {
+      report.ok = false;
+      report.errors.push(`备份本机技能失败：${String((err && err.message) || err)}`);
+      report.ms = Date.now() - started;
+      return report;
+    }
+  }
+
+  // ── 2. 扫别人的格子（只读）
+  // 市场上装过的技能名：别人的格子里就算有，本机也不拉（避免市场技能顺着共享盘扩散）。
+  // 直接用上面算好的 scope，不再重扫一遍——140 个技能重扫一次要几十毫秒，没必要。
+  const thirdPartyNames = new Set(scope.thirdParty.map((x) => x.name));
+  // 拉取之后集合会被刷新，所以提前声明成可变 Set 供下面复用。
+  const collected = collectSharedSkills({ config, machineId: feature, localRoot, masterRoot, only, thirdParty: thirdPartyNames });
+  report.peers = collected.sources;
+  report.missing.found = collected.missing.length;
+  report.differ.found = collected.differ.length;
+  report.thirdPartyFound = collected.thirdParty.length;
+  report.sameCount = collected.same.length;
+  // 面板要逐条列出来的三组预览（只给名字与来源，不塞整份索引）
+  report.missingPreview = collected.missing.map((x) => ({
+    name: x.name,
+    from: (x.peers[0] && x.peers[0].feature) || '',
+    version: x.version || '',
+  }));
+  report.differPreview = collected.differ.map((x) => ({
+    name: x.name,
+    peers: x.peers.map((p) => p.feature),
+    distinctHashes: x.counts.distinctHashes,
+  }));
+  report.thirdPartyPreview = collected.thirdParty.map((x) => ({
+    name: x.name,
+    peers: x.peers.map((p) => p.feature),
+  }));
+  for (const w of collected.warnings) report.errors.push(w);
+
+  // ── 3. 本机没有的：直接拉（不覆盖任何已有技能）
+  if (!dryRun && collected.missing.length) {
+    const pulled = applySkillPull({
+      items: collected.missing,
+      localRoot,
+      config,
+      machineId: feature,
+      stamp: report.stamp,
+    });
+    report.missing.pulled = pulled.pulled.length;
+    report.missing.errors = pulled.errors;
+    // 拉进来的技能归谁？新技能不在市场台账里，按「自己编写」处理。
+    // 所以这里必须重算一次归属，否则同一轮的差异评估与后续优化还会把它当外人。
+    if (pulled.pulled.length) {
+      try {
+        const after = ownNames({ localRoot, masterRoot, overrides: scopeOverrides || {} });
+        report.scope.own = after.names.size;
+        report.scope.thirdParty = after.thirdParty.map((x) => x.name);
+        report.scope.weak = after.weak.map((x) => x.name);
+        report.scope.pulledIn = pulled.pulled.map((x) => x.name);
+        thirdPartyNames.clear();
+        for (const x of after.thirdParty) thirdPartyNames.add(x.name);
+      } catch (err) {
+        report.errors.push(`拉取后重算归属失败：${String((err && err.message) || err)}`);
+      }
+    }
+    if (pulled.pulled.length) {
+      log?.(
+        `技能共享：从别的机器拉来 ${pulled.pulled.length} 个技能（` +
+          `${pulled.pulled.map((x) => `${x.name}←${x.from}`).join('、')}）`,
+      );
+    }
+    for (const e of pulled.errors) report.errors.push(`${e.name}：拉取失败 ${e.message}`);
+  }
+
+  // ── 4. 同名不同内容：能机械定就机械定，判不了才叫模型
+  const pendingItems = collected.differ.slice(0, Math.max(0, Math.min(Number(learnPerRound) || 0, 24)));
+  if (collected.differ.length && !learn) {
+    report.skipped = '学习评估已关闭（skills.share.learn = false）';
+  }
+
+  // 冗余候选：不调模型，纯词面相似度，作为「合并精炼」的线索记进台账
+  let redundantPairs = [];
+  try {
+    const localSkills = scanSkills(localRoot);
+    redundantPairs = findRedundantPairs(localSkills);
+  } catch (err) {
+    report.errors.push(`冗余技能扫描失败：${String((err && err.message) || err)}`);
+  }
+
+  let modelCalls = 0;
+  for (const item of pendingItems) {
+    if (!learn) break;
+    if (typeof generate !== 'function') {
+      // 没有模型也要留下记录，不然面板上永远是「差异 N 个」而看不到为什么
+      const rec = {
+        skill: item.name,
+        at: new Date().toISOString(),
+        mineHash: item.mineHash || '',
+        peerHash: (item.peers[0] && item.peers[0].mdHash) || '',
+        peerFeature: (item.peers[0] && item.peers[0].feature) || '',
+        peerMachine: (item.peers[0] && item.peers[0].machine) || '',
+        action: 'manual',
+        label: '等人工判断',
+        basis: 'manual',
+        confidence: 0,
+        reason: '宿主没有可用的默认模型，无法评估两份同名技能怎么合并；差异已记录，可人工比对后处理。',
+        evidence: [],
+        dropped: [],
+        draft: null,
+        modelCalls: 0,
+        error: '',
+      };
+      if (!dryRun) {
+        try {
+          recordLearning({ config, machineId: feature, record: rec, machineName });
+        } catch (err) {
+          report.errors.push(`${item.name}：写台账失败 ${String((err && err.message) || err)}`);
+        }
+      }
+      report.differ.evaluated += 1;
+      report.differ.byAction.manual = (report.differ.byAction.manual || 0) + 1;
+      continue;
+    }
+    if (modelCalls >= MAX_LEARN_MODEL_CALLS) {
+      report.errors.push(`本轮模型调用已达上限 ${MAX_LEARN_MODEL_CALLS}，剩下的差异下一轮再评估`);
+      break;
+    }
+
+    const peer = item.peers[0];
+    let mineText = '';
+    let peerText = '';
+    try {
+      mineText = fs.readFileSync(path.join(localRoot, item.name, 'SKILL.md'), 'utf8');
+    } catch {
+      mineText = '';
+    }
+    try {
+      peerText = fs.readFileSync(path.join(peer.dir, 'SKILL.md'), 'utf8');
+    } catch {
+      peerText = '';
+    }
+    if (!mineText || !peerText) {
+      report.errors.push(`${item.name}：读不到正文，跳过评估`);
+      continue;
+    }
+
+    let rec = null;
+    try {
+      rec = await learnOneDiff({
+        name: item.name,
+        mineText,
+        peerText,
+        peer,
+        mineAssets: {
+          scripts: fs.existsSync(path.join(localRoot, item.name, 'scripts')),
+          references: fs.existsSync(path.join(localRoot, item.name, 'references')),
+          evals: fs.existsSync(path.join(localRoot, item.name, 'evals')),
+        },
+        generate,
+        dryRun,
+        redundant: redundantPairs.filter((p) => p.a === item.name || p.b === item.name),
+        config,
+        machineId: feature,
+      });
+      modelCalls += rec.modelCalls || 0;
+    } catch (err) {
+      report.errors.push(`${item.name}：评估失败 ${String((err && err.message) || err)}`);
+      continue;
+    }
+
+    report.differ.evaluated += 1;
+    report.differ.byAction[rec.action] = (report.differ.byAction[rec.action] || 0) + 1;
+
+    if (!dryRun) {
+      try {
+        recordLearning({ config, machineId: feature, record: rec, machineName });
+      } catch (err) {
+        report.errors.push(`${item.name}：写台账失败 ${String((err && err.message) || err)}`);
+      }
+      if (rec.action === 'adopt' && rec.peerFeature) {
+        try {
+          recordOrigin(config, feature, item.name, { learnedFrom: [rec.peerFeature] });
+        } catch {
+          /* 来源写不进去不影响主流程 */
+        }
+      }
+    }
+  }
+
+  // ── 5. 冗余候选也进台账（同一对技能只记一次，替换旧记录）
+  if (!dryRun && learn && redundantPairs.length) {
+    for (const pair of redundantPairs.slice(0, 8)) {
+      const rec = {
+        skill: pair.a,
+        at: new Date().toISOString(),
+        mineHash: '',
+        peerHash: '',
+        peerFeature: '',
+        peerMachine: '',
+        action: 'merge',
+        label: '合并精炼（候选）',
+        basis: 'deterministic',
+        confidence: pair.similarity,
+        reason: `与本机 \`${pair.b}\` 描述重合理度 ${pair.similarity}：${pair.reason}。两侧都在本机，判据是「先人工比对再合并」，不做自动合并。`,
+        evidence: [`\`${pair.a}\` ${pair.lines[0]} 行 / \`${pair.b}\` ${pair.lines[1]} 行`],
+        dropped: [],
+        draft: null,
+        modelCalls: 0,
+        error: '',
+        pair: [pair.a, pair.b],
+      };
+      try {
+        recordLearning({ config, machineId: feature, record: rec, machineName });
+      } catch {
+        /* 台账写失败不影响本轮 */
+      }
+    }
+  }
+
+  // ── 6. autoApply：只对「本轮刚出的、过了审核的」草稿动手
+  if (!dryRun && autoApply) {
+    let pendingList = [];
+    try {
+      const file = path.join(mySkillsRoot(config, feature), LEARNINGS_INDEX);
+      pendingList = (JSON.parse(fs.readFileSync(file, 'utf8')).items || []).filter(
+        (x) => x.draft && !x.appliedAt && !x.rejectedAt && x.action !== 'manual' && (!x.audit || x.audit.ok),
+      );
+    } catch {
+      pendingList = [];
+    }
+    for (const x of pendingList.slice(0, 8)) {
+      const r = approveLearning({ config, machineId: feature, localRoot, name: x.skill, log });
+      if (r.ok) report.applied.push(x.skill);
+      else report.autoApplyErrors.push(`${x.skill}：${r.message}`);
+    }
+  }
+
+  // ── 7. 人读版台账（也是给别的机器参考的那一份）
+  if (!dryRun) {
+    try {
+      const md = writeLearningsMd({ config, machineId: feature, log });
+      report.learnings = { file: md.file, mdFile: md.mdFile };
+      const doc = md.doc || {};
+      report.pending = (doc.items || []).filter((x) => x.draft && !x.appliedAt && !x.rejectedAt).length;
+    } catch (err) {
+      report.errors.push(`写学习台账失败：${String((err && err.message) || err)}`);
+    }
+  }
+
+  report.learn = Boolean(learn);
+  report.redundant = redundantPairs.length;
+  report.ms = Date.now() - started;
+  log?.(
+    `技能共享完成（${reason}）：备份 ${report.backup ? report.backup.counts.total : '-'} 个、` +
+      `他人 ${report.peers.length} 台、缺失 ${report.missing.found}（拉 ${report.missing.pulled}）、` +
+      `差异 ${report.differ.found}（评估 ${report.differ.evaluated}）、待批 ${report.pending}` +
+      (report.errors.length ? `、错误 ${report.errors.length}` : ''),
+  );
+  return report;
+}
+
+/** 草稿目录（面板要展示「合并稿就在这」）。 */
+export function draftsDirOf(config, machineId) {
+  return path.join(mySkillsRoot(config, machineId), DRAFTS_DIR);
+}