ygc-dsh-sync 1.2.1 → 1.3.0

package/lib/api.js

@@ -35,41 +35,11 @@ import {
   planFeatures,
   rememberDecision,
 } from './features.js';
-import {
-  LINEAGE_FILE,
-  LOCAL_SKILLS_ROOT,
-  applyModeChange,
-  applyPull,
-  applyPush,
-  buildHistoryIndex,
-  diffSummary,
-  judgeUpdate,
-  loadLineage,
-  makeStamp,
-  planSync,
-  readMnemonLedger,
-  recordLineage,
-  resolveMode,
-  saveLineage,
-  scanSkills,
-} from './skills.js';
-import {
-  appendMasterChanges,
-  changelogPath,
-  ensureChangelog,
-  readChangelog,
-  readChangelogTimes,
-} from './changelog.js';
-import { runMnemonPrepass } from './mnemon.js';
-import {
-  runOptimizationCycle,
-  readQueue,
-  triage,
-  discoverOptimizations,
-  auditDraft,
-  MNEMON_LEDGER,
-} from './mnemon-optimize.js';
-import { createHostDrafter } from './mnemon-drafter.js';
+// 1.3.0 起母版功能取消：技能只有「本机特征文件夹里的备份 + 别人格子里的备份」，
+// 所以 skills.js 里那套「母版 vs 本机」的比对/拉取/推送，以及记忆插件那套优化闭环，
+// 都不再从这里调用。模块本身留着（记忆插件的草稿落地走它自己的入口），
+// 但 api.js 不再 import 那些用不上的符号。
+import { LOCAL_SKILLS_ROOT } from './skills.js';
 import {
   SHARE_POLICY,
   installSharedPlugin,
@@ -149,77 +119,6 @@ export function createApi(deps) {
   /** 本机某工作区路径对应的 projectKey 集合。 */
   const projectKeysOf = (p) => projectKeysFor(p);
 
-  /**
-   * 判新旧要的三份只读证据。
-   *
-   * lineage      ：母版根目录的 `.skill-lineage.json`，同步插件自己的观测记录——
-   *                每侧内容何时变成现在这样、上次一致时的内容树是哪份。
-   * mnemonLedger：`~/.mnemon/skills/ledger.json`，记忆插件的技能账本，
-   *                里面每条 hash 就是 SKILL.md 的 sha256，reason='evolution'
-   *                就是它改的。只读，不写。
-   * history      ：母版 `_backup/`、本机 `.pre-pull-*`、记忆插件 `versions/`
-   *                里的历史全文，按内容哈希索引出「这份内容何时出现过」。
-   */
-  const judgeEvidence = (masterRoot) => ({
-    lineage: masterRoot ? loadLineage(path.join(masterRoot, LINEAGE_FILE)) : {},
-    mnemonLedger: readMnemonLedger(),
-    history: buildHistoryIndex({
-      masterRoot,
-      localRoot: LOCAL_SKILLS_ROOT,
-      changelogTimes: masterRoot ? readChangelogTimes(masterRoot) : null,
-    }),
-  });
-
-  /**
-   * 记录一次比对观测：两侧各自当前是什么内容、各自何时变成这样。
-   *
-   * 这是「内容修改时间」的唯一来源——不是 mtime（同步/NAS 搬运都会刷），
-   * 而是同步插件真正看到内容变化的那一刻。内容没变则时间保持不动。
-   *
-   * 两侧内容一致时顺手把 baseline 更新成这一份：基线就是「上次两侧一致的
-   * 内容树」，只有一致的时候才有意义。
-   */
-  const observeLineage = (masterRoot, plan, by) => {
-    if (!masterRoot) return 0;
-    const file = path.join(masterRoot, LINEAGE_FILE);
-    let map = loadLineage(file);
-    const now = Date.now();
-    let touched = 0;
-    for (const [name, m] of plan.master) {
-      const l = plan.local.get(name);
-      if (!l) continue; // 只有一侧有，没有可比性
-      const same = m.treeHash === l.treeHash;
-      map = recordLineage(map, {
-        name,
-        ...(same ? { baseline: m.treeHash } : {}),
-        master: m,
-        local: l,
-        by: by || '',
-        at: now,
-      });
-      touched++;
-    }
-    return saveLineage(file, map) ? touched : 0;
-  };
-
-  /** 同步真正落地之后，把两侧一致的内容登记成新基线。 */
-  const stampBaseline = (masterRoot, entries, by) => {
-    if (!masterRoot || !entries.length) return 0;
-    const file = path.join(masterRoot, LINEAGE_FILE);
-    let map = loadLineage(file);
-    for (const e of entries) {
-      if (!e) continue;
-      map = recordLineage(map, {
-        name: e.name,
-        baseline: e.treeHash,
-        master: e,
-        local: e,
-        by: by || '',
-      });
-    }
-    return saveLineage(file, map) ? entries.length : 0;
-  };
-
   const routes = {
     /** 全量状态：配置、匹配工作区、备份统计、其他机器。 */
     'GET /state': async (req, res) => {
@@ -292,13 +191,30 @@ export function createApi(deps) {
           initialized: state.features.initialized === true,
           pending: plan.ask,
           pendingCount: plan.ask.length,
+          // 你点过「跳过」的目录：不在 pending 里，但要能在面板上找回来（可改主意）
+          declined: plan.declined,
+          declinedCount: plan.declined.length,
           activeCount: active.length,
           inactiveCount: inactive.length,
           // 巡检会自动处理的（面板上只报个数）
           autoCreateFolder: plan.createFolder.length,
           autoRestoreWorkspace: plan.restoreWorkspace.length,
         },
-        skills: { ...state.skills, localRoot: LOCAL_SKILLS_ROOT },
+        skills: {
+          ...state.skills,
+          localRoot: LOCAL_SKILLS_ROOT,
+          // 面板要显示「备份到哪」：这里直接给出实际路径，别让前端自己拼
+          ...(typeof deps.draftsRoot === 'function'
+            ? { shareRoot: (() => {
+                try {
+                  const d = deps.draftsRoot();
+                  return d ? String(d).replace(/[\\/]learn-drafts.*$/, '') : '';
+                } catch {
+                  return '';
+                }
+              })() }
+            : {}),
+        },
         // 插件清单共享（1.0.0 从自动更新器迁来）：配置 + 运行态 + 口径声明
         plugins: {
           ...state.plugins,
@@ -933,721 +849,222 @@ export function createApi(deps) {
 
     /* ---------------- 技能同步 ---------------- */
 
-    /**
-     * 比对 + 自动同步。
+    /* ---------------- 技能共享与优化（1.3.0：母版功能已取消） ----------------
      *
-     * 语义（用户 2026-11-01 定）：同步属性的技能，比对时就把能定下来的更新做掉——
-     * 母版更新就拉下来，本机更新就推上去。只有**判不出谁新**的才留给用户裁决。
+     * 技能不再走「母版 → 本机」这一套。取而代之的是两份东西：
+     *   特征文件夹里的技能备份：`插件库/<本机标识>/skills/`（整棵目录 + 名片）
+     *   别人格子里的技能备份：只读，本机缺的拉过来，同名不同内容进学习评估
      *
-     * body.auto === false 时退化为纯比对（只报告，不动任何文件）。
+     * 归属规矩（用户 2026-11-15）：技能市场装的第三方技能不管理、不同步、不优化；
+     * 只对本机自己总结 / 编写的技能做共享与优化。判定在 lib/skill-scope.js。
+     */
+
+    /**
+     * 扫描：本机 vs 别人的技能格，不写任何文件（拉取与评估要人点「立即共享」）。
+     *
+     * 走 runShare 的 dryRun 分支，而不是另写一份只读扫描：两处各写一份必然走形，
+     * 而且 dryRun 本来就已经是「只算不写」。
      */
     'POST /skills/scan': async (req, res) => {
-      const body = await readJson(req).catch(() => ({}));
-      const auto = body && body.auto === false ? false : true;
-      const dryRunFlag = body?.dryRun === true;
-      const state = loadState();
-      const master = state.skills.masterRoot;
-      if (!master) {
-        json(res, 400, { ok: false, error: '尚未设置技能母版文件夹' });
+      if (typeof deps.runShare !== 'function') {
+        json(res, 500, { ok: false, error: '宿主未提供技能共享能力' });
         return;
       }
-      if (!fs.existsSync(master)) {
-        json(res, 400, { ok: false, error: `母版文件夹不存在或不可访问：${master}` });
+      const report = await deps.runShare({ reason: '扫描', dryRun: true });
+      if (!report || report.ok === false) {
+        json(res, 500, { ok: false, error: (report && report.error) || '扫描失败' });
         return;
       }
-
-      // ── 阶段 0：记忆插件技能优化闭环（发现 → 起草 → 审核 → 落地 → 结案）
-      // 0.8.0 起这一步会写账本（结案）并调模型起草；dryRun 时只报告。
-      const optimize = auto
-        ? await runOptimizationCycle({
-            localRoot: LOCAL_SKILLS_ROOT,
-            masterRoot: master,
-            stageDir: process.env.DSH_SYNC_STAGE_DIR || 'C:/DSH-Work/mnemon-drafts/stage',
-            minConfidence: Number(state.skills.mnemonMinConfidence) || 0.7,
-            enabled: state.skills.mnemonOptimize !== false,
-            // 比对/巡检必须自己把「生成草案」这一步走完。
-            //
-            // 历史：这里曾经写死 `draft: null`，理由是「比对是同步语义，起草要调模型会卡住」。
-            // 结果是任何走比对路径的巡检（面板点「比对」、开机首拉、每 120 分钟的定时轮）
-            // 都只发现建议、从不起草，建议永远停在 pending；只有单独点「立即优化」
-            // 或走定时器那条后台链路才会起草。用户要的是「巡检发现待处理就自己处理完」，
-            // 所以把起草器接回来，由 body 控制：
-            //   body.draft   === false → 只比对（显式要求纯比对时才这样）
-            //   body.dryRun  === true  → 不调模型（预演）
-            // 其余情况一律带起草器，让「发现 → 起草 → 审核 → 落地 → 结案」在一条路径里跑完。
-            draft: dryRunFlag || body?.draft === false ? null : drafter(),
-            maxDrafts: Number(state.skills.mnemonMaxDrafts) || 6,
-            onEvent: (kind, payload) => log(`优化闭环 ${kind}: ${JSON.stringify(payload)}`),
-          })
-        : { enabled: false, skipped: 'auto=false', discovered: { suggestions: 0, drafts: 0 }, todo: [], dropped: [], enqueued: [], audited: [], accepted: [], errors: [] };
-
-      // 记忆插件草稿预处理：auto 时先落地再比对，比对看到的就是落地后的内容
-      const prepass = auto
-        ? runMnemonPrepass({
-            masterRoot: master,
-            localRoot: LOCAL_SKILLS_ROOT,
-            modes: state.skills.modes || {},
-            machineId: state.machineId,
-            machineName: state.machineName,
-            enabled: state.skills.mnemonAuto !== false,
-          })
-        : { enabled: false, drafts: 0, apply: [], skipped: [], applied: [], pushed: [], errors: [] };
-
-      const plan = planSync({
-        masterRoot: master,
-        localRoot: LOCAL_SKILLS_ROOT,
-        modes: state.skills.modes || {},
-        ...judgeEvidence(master),
-      });
-
-      // 比对本身就是一次观测：记下两侧各自现在是什么内容、何时变成这样
-      const next = loadState();
-      const observed = observeLineage(master, plan, next.machineId);
-
-      const stamp = makeStamp();
-      let pulled = { pulled: [], errors: [] };
-      let pushed = { pushed: [], errors: [] };
-
-      if (auto && (plan.pull.length || plan.autoPush.length)) {
-        // 母版更新 → 拉到本机
-        if (plan.pull.length) {
-          pulled = applyPull({ items: plan.pull, localRoot: LOCAL_SKILLS_ROOT, stamp });
-        }
-        // 本机更新（同步属性）→ 推回母版，旧版先存档
-        if (plan.autoPush.length) {
-          const backRoot = path.join(master, '_backup');
-          pushed = applyPush({ items: plan.autoPush, masterRoot: master, backRoot, stamp });
-          const auditItems = pushed.pushed.map((p) => ({
-            skill: p.name,
-            operation: p.operation,
-            detail: `${p.operation === '覆盖' ? `旧版备份于 _backup/${p.name}.${stamp}` : '母版此前无此技能'}（自动：内容更新）`,
-          }));
-          if (auditItems.length) {
-            try {
-              appendMasterChanges(auditItems, {
-                masterRoot: master,
-                machineId: next.machineId,
-                machineName: next.machineName,
-                trigger: '自动同步',
-              });
-            } catch {
-              /* 记录写不进去不影响同步本身 */
-            }
-          }
-        }
-        // 同步过的内容现在两侧一致，登记成新基线
-        const aligned = [
-          ...plan.pull.map((x) => x.master),
-          ...plan.autoPush.map((x) => x.local),
-          ...plan.same.map((x) => x.master),
-        ].filter(Boolean);
-        if (aligned.length) {
-          let map = loadLineage(path.join(master, LINEAGE_FILE));
-          for (const e of aligned) {
-            map = recordLineage(map, { name: e.name, baseline: e.treeHash, master: e, local: e, by: next.machineId });
-          }
-          saveLineage(path.join(master, LINEAGE_FILE), map);
-        }
-      }
-
-      next.skills.lastRunAt = Date.now();
-      next.skills.lastResult = {
-        pull: plan.pull.length,
-        autoPush: plan.autoPush.length,
-        push: plan.push.length,
-        same: plan.same.length,
-        localOnly: plan.localOnly.length,
-        pulled: pulled.pulled.length,
-        pushed: pushed.pushed.length,
-        observed,
-        auto,
-        scannedAt: plan.scannedAt,
-        mnemon: {
-          drafts: prepass.drafts,
-          applied: prepass.applied.length,
-          pushed: prepass.pushed.length,
-          skipped: prepass.skipped.length,
-        },
-      };
-      if (auto && (pulled.pulled.length || pushed.pushed.length || prepass.applied.length)) {
-        pushHistory(
-          next,
-          'skills',
-          `技能自动同步：拉取 ${pulled.pulled.length}、推送 ${pushed.pushed.length}、待裁决 ${plan.push.length}${
-            prepass.applied.length ? `、记忆插件草稿落地 ${prepass.applied.length}` : ''
-          }`,
-        );
-      }
-      saveState(next);
-
-      const brief = (x) => ({
-        name: x.name,
-        action: x.action,
-        reason: x.reason || (x.action === 'new' ? '母版新增' : ''),
-        basis: x.basis || null,
-      });
-
-      const pulledNames = new Set(pulled.pulled.map((p) => p.name));
-      const pushedNames = new Set(pushed.pushed.map((p) => p.name));
-
       json(res, 200, {
         ok: true,
-        masterRoot: master,
-        localRoot: LOCAL_SKILLS_ROOT,
-        auto,
-        stamp,
-        // 母版更新：自动拉取
-        pull: plan.pull.map((x) => ({ ...brief(x), version: x.master.version, done: pulledNames.has(x.name) })),
-        // 本机更新（同步属性）：自动推送
-        autoPush: plan.autoPush.map((x) => ({
-          ...brief(x),
-          masterVersion: x.master.version,
-          localVersion: x.local.version,
-          done: pushedNames.has(x.name),
-        })),
-        // 判不出来的：只报告，等用户裁决（附差异摘要，方便一眼决定）
-        push: plan.push.map((x) => ({
-          ...brief(x),
-          masterVersion: x.master.version,
-          localVersion: x.local.version,
-          diff: x.diff || null,
-        })),
-        same: plan.same.map((x) => x.name),
-        localOnly: plan.localOnly.map((x) => x.name),
-        // 优化闭环：发现了什么、判断结果、入队、审核、通过
-        optimize,
-        // 记忆插件草稿：这一轮落地了哪些、跳过了哪些（跳过都带原因）
-        mnemon: {
-          enabled: prepass.enabled,
-          drafts: prepass.drafts,
-          apply: prepass.apply,
-          applied: prepass.applied.map((a) => ({
-            name: a.name,
-            action: a.action,
-            draftId: a.draftId,
-            targetRoot: a.targetRoot,
-            backup: a.backup,
-          })),
-          pushed: prepass.pushed.map((p) => ({ name: p.name, operation: p.operation })),
-          skipped: prepass.skipped,
+        scope: report.scope || null,
+        peers: report.peers || [],
+        missing: report.missingPreview || [],
+        differ: report.differPreview || [],
+        thirdParty: report.thirdPartyPreview || [],
+        counts: {
+          local: report.scope ? report.scope.own : null,
+          peers: (report.peers || []).length,
+          missing: (report.missing && report.missing.found) || 0,
+          same: report.sameCount || 0,
+          differ: (report.differ && report.differ.found) || 0,
+          thirdParty: report.thirdPartyFound || 0,
         },
-        errors: [...pulled.errors, ...pushed.errors, ...prepass.errors],
-        observed,
+        warnings: (report.errors || []).slice(0, 8),
       });
     },
 
+    /** 立即共享一轮：备份本机 → 扫别人 → 拉缺失 → 差异进学习评估。 */
+    'POST /skills/share': async (req, res) => {
+      if (typeof deps.runShare !== 'function') {
+        json(res, 500, { ok: false, error: '宿主未提供技能共享能力' });
+        return;
+      }
+      const body = await readJson(req).catch(() => ({}));
+      const report = await deps.runShare({ reason: '手动', dryRun: body?.dryRun === true });
+      json(res, 200, { ok: report?.ok !== false, report });
+    },
+
     /**
-     * 优化闭环的只读快照：队列里在等什么、账本里还有多少建议没做。
-     *
-     * 不改任何文件。面板用它显示「现在积压了多少」。
-     */
-    /**
-     * 手动跑一轮完整流程（发现 → 起草 → 审核 → 落地 → 结案）。
-     *
-     * body: { dryRun?: boolean, maxDrafts?: number, wait?: boolean }
+     * 本机技能优化：精炼 / 精简 / 合并重复 / 补工况 / 补踩坑 / 修死引用 / 停用作废。
      *
-     * **默认立刻返回 202，起草在后台跑**。为什么：一轮 6 条草稿要两分钟以上，
-     * 串在 HTTP 响应里会让前端「点了没反应」（实测就是这么被投诉的），
-     * 浏览器/代理还可能先超时。要同步结果就传 `wait:true`（只建议 dryRun 时用）。
-     * 进度用 `POST /skills/optimize/state` 的 running/nextRun 两个字段轮询。
+     * 一律后台跑：一轮要调好几次模型、每次几十秒，同步等会让人以为界面卡死。
+     * 进度用 `POST /skills/optimize/state` 轮询。
      */
     'POST /skills/optimize/run': async (req, res) => {
-      const body = (await readJson(req).catch(() => ({}))) || {};
-      const state = loadState();
-      // 母版不是必需品：没有母版照样能落地并结案（结案不依赖母版是既有约定），
-      // 只是跳过「推母版」这一步。所以这里不拦，只在报告里说明。
-      const master = state.skills.masterRoot || undefined;
-      const enabled = state.skills.mnemonOptimize !== false;
-      const maxDrafts = Number(body.maxDrafts) || Number(state.skills.mnemonMaxDrafts) || 6;
-      const dryRun = body.dryRun === true;
-
-      const runOnce = () =>
-        runOptimizationCycle({
-          localRoot: LOCAL_SKILLS_ROOT,
-          masterRoot: master,
-          stageDir: process.env.DSH_SYNC_STAGE_DIR || 'C:/DSH-Work/mnemon-drafts/stage',
-          minConfidence: Number(state.skills.mnemonMinConfidence) || 0.7,
-          maxDrafts,
-          dryRun,
-          // dryRun 不调模型：那样「预演」也要两分钟，且没有意义（没落地可预演）
-          draft: dryRun ? null : drafter(),
-          enabled,
-          onEvent: (kind, payload) => log(`优化闭环 ${kind}: ${JSON.stringify(payload)}`),
-        });
-
-      // 同步模式：只给 dryRun / 明确要 wait 的调用方
-      if (body.wait === true || dryRun) {
-        try {
-          const report = await runOnce();
-          json(res, 200, { ok: true, report });
-        } catch (err) {
-          json(res, 500, { ok: false, error: String((err && err.message) || err) });
-        }
+      if (typeof deps.runOptimize !== 'function') {
+        json(res, 500, { ok: false, error: '宿主未提供技能优化能力' });
         return;
       }
-
-      // 异步模式（默认）：立刻回 202，后台跑
-      if (optimizeRun.running) {
-        json(res, 202, {
-          ok: true,
-          started: false,
-          running: true,
-          startedAt: optimizeRun.startedAt,
-          note: '上一轮还在跑，本次不重复启动',
-        });
-        return;
-      }
-      optimizeRun.running = true;
-      optimizeRun.startedAt = new Date().toISOString();
-      optimizeRun.lastReport = null;
-      optimizeRun.lastError = null;
-      runOnce()
-        .then((report) => {
-          optimizeRun.lastReport = {
-            at: new Date().toISOString(),
-            remaining: report.remaining,
-            closed: report.closed,
-            landed: (report.pipeline && report.pipeline.stage && report.pipeline.stage.landed) || [],
-            drafted: (report.pipeline && report.pipeline.stage && report.pipeline.stage.drafted) || [],
-            failed: (report.pipeline && report.pipeline.stage && report.pipeline.stage.failed) || [],
-            errors: report.errors,
-          };
-          log(
-            `优化闭环（手动）：起草 ${optimizeRun.lastReport.drafted.length}、` +
-              `落地 ${optimizeRun.lastReport.landed.length}、失败 ${optimizeRun.lastReport.failed.length}、` +
-              `剩余 ${report.remaining}`,
-          );
-        })
-        .catch((err) => {
-          optimizeRun.lastError = String((err && err.message) || err);
-          log(`优化闭环（手动）失败：${optimizeRun.lastError}`);
-        })
-        .finally(() => {
-          optimizeRun.running = false;
-          optimizeRun.finishedAt = new Date().toISOString();
-        });
-      json(res, 202, {
-        ok: true,
-        started: true,
-        running: true,
-        startedAt: optimizeRun.startedAt,
-        maxDrafts,
-        note: '起草已转后台，用 POST /skills/optimize/state 轮询进度',
-      });
-    },
-
-    'POST /skills/optimize/state': async (req, res) => {
-      const state = loadState();
-      const queue = readQueue();
-      const found = discoverOptimizations({ localRoot: LOCAL_SKILLS_ROOT });
-      const { todo, dropped } = triage({
-        suggestions: found.suggestions,
-        minConfidence: Number(state.skills.mnemonMinConfidence) || 0.7,
-        seen: queue.seen,
+      const body = await readJson(req).catch(() => ({}));
+      const maxPerRound = Number(body?.maxPerRound);
+      const started = deps.runOptimize({
+        maxPerRound: Number.isFinite(maxPerRound) && maxPerRound > 0 ? maxPerRound : undefined,
+        includeMerge: body?.includeMerge !== false,
       });
-      // 账本视角的三段计数：没有草稿的 / 有 ready 草稿的 / 已经在磁盘上的
-      let ledgerView = { pending: 0, withDraft: 0, readyDrafts: 0, adopted: 0, generation: null };
-      try {
-        const raw = JSON.parse(fs.readFileSync(MNEMON_LEDGER, 'utf8'));
-        const sug = Array.isArray(raw.suggestions) ? raw.suggestions : [];
-        const drf = Array.isArray(raw.drafts) ? raw.drafts : [];
-        const readyBySuggestion = new Set(drf.filter((d) => d && d.status === 'ready' && d.suggestionId).map((d) => d.suggestionId));
-        const pending = sug.filter((s) => s && s.status === 'pending');
-        ledgerView = {
-          pending: pending.length,
-          withDraft: pending.filter((s) => readyBySuggestion.has(s.id)).length,
-          readyDrafts: drf.filter((d) => d && d.status === 'ready').length,
-          adopted: sug.filter((s) => s && s.status === 'adopted').length,
-          generation: typeof raw.generation === 'number' ? raw.generation : null,
-        };
-      } catch {
-        /* 账本读不到就返回零值，面板不报错 */
-      }
       json(res, 200, {
         ok: true,
-        ledgerView,
-        // 手动触发那一轮的运行态：面板靠这两个字段显示「在跑 / 上次结果」
-        running: optimizeRun.running,
-        startedAt: optimizeRun.startedAt,
-        finishedAt: optimizeRun.finishedAt,
-        lastReport: optimizeRun.lastReport,
-        lastError: optimizeRun.lastError,
-        enabled: state.skills.mnemonOptimize !== false,
-        minConfidence: Number(state.skills.mnemonMinConfidence) || 0.7,
-        queue: {
-          file: '~/.mnemon/skills/external-drafts.json',
-          generation: queue.generation,
-          waiting: queue.items.filter((x) => x.status === 'waiting-draft').length,
-          done: queue.items.filter((x) => x.status === 'done').length,
-          seen: queue.seen.length,
-          items: queue.items.slice(-40),
-        },
-        ledger: { suggestions: found.suggestions.length, readyDrafts: found.drafts.length },
-        todo: todo.map((x) => ({ skillName: x.skillName, action: x.action, priority: x.priority, reason: x.reason })),
-        dropped,
+        started: true,
+        note: '优化已转后台：用 POST /skills/optimize/state 轮询进度；出的稿子是待批草稿，批准才落本机',
+        state: started,
       });
     },
 
-    /**
-     * 只审核不落地：把暂存区里的草稿过一遍机械审核，看哪些能通过。
-     * 用来在真正落地前先看一眼。
-     */
-    'POST /skills/optimize/audit': async (req, res) => {
-      const body = await readJson(req).catch(() => ({}));
-      const stageDir = body.stageDir || process.env.DSH_SYNC_STAGE_DIR || 'C:/DSH-Work/mnemon-drafts/stage';
-      const state = loadState();
-      const queue = readQueue();
-      const found = discoverOptimizations({ localRoot: LOCAL_SKILLS_ROOT });
-      const { todo } = triage({
-        suggestions: found.suggestions,
-        minConfidence: Number(state.skills.mnemonMinConfidence) || 0.7,
-        seen: queue.seen,
-      });
-
-      const rows = [];
-      for (const item of todo) {
-        const file = `${stageDir}/${item.skillName}/SKILL.md`;
-        if (!fs.existsSync(file)) {
-          rows.push({ skillName: item.skillName, action: item.action, staged: false, ok: null, problems: [] });
-          continue;
-        }
-        const text = fs.readFileSync(file, 'utf8');
-        const audit = auditDraft({ text, name: item.skillName, isUpdate: item.action === 'update', localRoot: LOCAL_SKILLS_ROOT });
-        rows.push({ skillName: item.skillName, action: item.action, staged: true, ok: audit.ok, problems: audit.problems, info: audit.info });
-      }
-      json(res, 200, { ok: true, stageDir, rows });
+    /** 优化进度：running / 上一轮结果 / 待批数量。 */
+    'POST /skills/optimize/state': async (req, res) => {
+      const state = typeof deps.optimizeState === 'function' ? deps.optimizeState() : { running: false };
+      const pending = typeof deps.learningList === 'function' ? deps.learningList() : [];
+      json(res, 200, { ok: true, ...state, pendingCount: pending.length });
     },
 
-    /** 执行拉取（母版 → 本地）+ 移除母版已删的。 */
-    'POST /skills/pull': async (req, res) => {
-      const state = loadState();
-      const master = state.skills.masterRoot;
-      if (!master) {
-        json(res, 400, { ok: false, error: '尚未设置技能母版文件夹' });
+    /** 整库体检：纯机械，不调模型、不写文件，秒回。 */
+    'POST /skills/inspect': async (req, res) => {
+      if (typeof deps.inspectSkills !== 'function') {
+        json(res, 500, { ok: false, error: '宿主未提供体检能力' });
         return;
       }
-      if (!fs.existsSync(master)) {
-        json(res, 400, { ok: false, error: `母版文件夹不存在或不可访问：${master}` });
-        return;
-      }
-
-      const plan = planSync({
-        masterRoot: master,
-        localRoot: LOCAL_SKILLS_ROOT,
-        modes: state.skills.modes || {},
-        ...judgeEvidence(master),
-      });
-      const stamp = makeStamp();
-
-      const pulled = applyPull({ items: plan.pull, localRoot: LOCAL_SKILLS_ROOT, stamp });
-
-      // 拉取落地后，被拉的和本来就一致的两侧都对齐了，一起登记成基线
-      const next = loadState();
-      const stamped = stampBaseline(
-        master,
-        [...plan.pull.map((x) => x.master), ...plan.same.map((x) => x.master)].filter(Boolean),
-        next.machineId,
-      );
-
-      next.skills.lastRunAt = Date.now();
-      next.skills.lastResult = {
-        pulled: pulled.pulled.length,
-        pendingPush: plan.push.length,
-        errors: pulled.errors.length,
-        lineage: stamped,
-      };
-      pushHistory(
-        next,
-        'skills',
-        `技能拉取：更新 ${pulled.pulled.length}、待推 ${plan.push.length}`,
-      );
-      saveState(next);
+      json(res, 200, { ok: true, ...(await deps.inspectSkills()) });
+    },
 
-      json(res, 200, {
-        ok: true,
-        pulled: pulled.pulled,
-        errors: pulled.errors,
-        pendingPush: plan.push.map((x) => ({ name: x.name, reason: x.reason, basis: x.basis || null })),
-        lineage: stamped,
-        stamp,
-      });
+    /** 待批的学习 / 优化草稿列表。 */
+    'POST /skills/learning/list': async (req, res) => {
+      const items = typeof deps.learningList === 'function' ? await deps.learningList() : [];
+      json(res, 200, { ok: true, items });
     },
 
-    /** 把本地技能推回母版（用户确认后才调用）。支持覆盖，也支持新增本地独有技能。 */
-    'POST /skills/push': async (req, res) => {
+    /** 读一份草稿正文（面板预览）。 */
+    'POST /skills/learning/draft': async (req, res) => {
       const body = await readJson(req);
-      const state = loadState();
-      const master = state.skills.masterRoot;
-      if (!master) {
-        json(res, 400, { ok: false, error: '尚未设置技能母版文件夹' });
+      const name = String(body?.name || '').trim();
+      if (!name) {
+        json(res, 400, { ok: false, error: '缺少技能名' });
         return;
       }
-      const names = Array.isArray(body.names) ? body.names.filter((n) => typeof n === 'string') : [];
-      if (!names.length) {
-        json(res, 400, { ok: false, error: '未选择任何技能' });
+      const r = typeof deps.learningDraft === 'function' ? await deps.learningDraft(name) : { ok: false, text: '' };
+      json(res, r.ok ? 200 : 404, r);
+    },
+
+    /** 批准一份草稿：写进本机技能根，旧版先备份。 */
+    'POST /skills/learning/approve': async (req, res) => {
+      const body = await readJson(req);
+      const name = String(body?.name || '').trim();
+      if (!name) {
+        json(res, 400, { ok: false, error: '缺少技能名' });
         return;
       }
-
-      const plan = planSync({
-        masterRoot: master,
-        localRoot: LOCAL_SKILLS_ROOT,
-        modes: state.skills.modes || {},
-        ...judgeEvidence(master),
-      });
-      const stamp = makeStamp();
-
-      // 覆盖项：本机更新的（同步属性，在 autoPush 里）+ 待裁决里被指名的
-      // 新增项：localOnly（用户显式指名才推）
-      // 注意 autoPush 也要算进来——否则「本机更新」这条在面板上点「推送」
-      // 会报「没有可推送的变更」。
-      const overwrites = [...plan.autoPush, ...plan.push].filter((x) => names.includes(x.name));
-      const creates = plan.localOnly
-        .filter((x) => names.includes(x.name))
-        .map((x) => ({ name: x.name, action: 'create', local: x.local, master: null }));
-      const items = [...overwrites, ...creates];
-
-      if (!items.length) {
-        json(res, 400, { ok: false, error: '选中的技能当前没有可推送的变更' });
+      if (typeof deps.learningApprove !== 'function') {
+        json(res, 500, { ok: false, error: '宿主未提供落地能力' });
         return;
       }
-
-      const backRoot = path.join(master, '_backup');
-      const out = applyPush({ items, masterRoot: master, backRoot, stamp });
-
-      // 每一次实际写入都留记录
-      const audit = appendMasterChanges(
-        out.pushed.map((p) => ({
-          skill: p.name,
-          operation: p.operation,
-          detail: p.operation === '覆盖' ? `旧版备份于 _backup/${p.name}.${stamp}` : '母版此前无此技能',
-        })),
-        {
-          masterRoot: master,
-          machineId: state.machineId,
-          machineName: state.machineName,
-          trigger: '用户授权',
-        },
-      );
-
-      const next = loadState();
-      // 推送落地后母版就是本机这一份，登记成新基线
-      const stamped = stampBaseline(
-        master,
-        out.pushed.map((p) => items.find((i) => i.name === p.name)).filter(Boolean).map((i) => i.local).filter(Boolean),
-        next.machineId,
-      );
-      pushHistory(
-        next,
-        'skills',
-        `技能推送：覆盖 ${out.pushed.filter((p) => p.operation === '覆盖').length}、新增 ${
-          out.pushed.filter((p) => p.operation === '新增').length
-        }`,
-      );
-      saveState(next);
-
-      json(res, 200, {
-        ok: true,
-        pushed: out.pushed,
-        errors: out.errors,
-        backupRoot: backRoot,
-        stamp,
-        lineage: stamped,
-        changelog: {
-          path: audit.written[0]?.path || changelogPath(master),
-          written: audit.written.length,
-          failed: audit.failed,
-        },
-      });
+      const r = await deps.learningApprove({ name, force: body?.force === true });
+      json(res, r.ok ? 200 : 409, r);
     },
 
-    /** 读取母版修改记录。 */
-    'POST /skills/changelog': async (req, res) => {
+    /** 驳回：只标状态与理由，草稿文件留着复核。 */
+    'POST /skills/learning/reject': async (req, res) => {
       const body = await readJson(req);
-      const state = loadState();
-      const master = state.skills.masterRoot;
-      if (!master) {
-        json(res, 400, { ok: false, error: '尚未设置技能母版文件夹' });
+      const name = String(body?.name || '').trim();
+      if (!name) {
+        json(res, 400, { ok: false, error: '缺少技能名' });
         return;
       }
-      const limit = Number(body.limit) > 0 ? Math.min(Math.floor(Number(body.limit)), 200) : 30;
-      const log = readChangelog(master, limit);
-      json(res, 200, { ok: true, ...log });
+      const r = typeof deps.learningReject === 'function'
+        ? await deps.learningReject({ name, reason: body?.reason })
+        : { ok: false, message: '宿主未提供驳回能力' };
+      json(res, r.ok ? 200 : 404, r);
     },
 
-    /** 技能列表：合并母版与本机，带单机属性。 */
-    'POST /skills/list': async (req, res) => {
-      const state = loadState();
-      const master = state.skills.masterRoot;
-      if (!master) {
-        json(res, 400, { ok: false, error: '尚未设置技能母版文件夹' });
-        return;
-      }
-      if (!fs.existsSync(master)) {
-        json(res, 400, { ok: false, error: `母版文件夹不存在或不可访问：${master}` });
+    /** 技能归属：谁归本插件管、谁是市场装的第三方。 */
+    'POST /skills/scope': async (req, res) => {
+      if (typeof deps.skillScope !== 'function') {
+        json(res, 500, { ok: false, error: '宿主未提供归属判定' });
         return;
       }
-
-      const modes = state.skills.modes || {};
-      const m = scanSkills(master);
-      const l = scanSkills(LOCAL_SKILLS_ROOT);
-      const names = new Set([...m.keys(), ...l.keys()]);
-      const { lineage, mnemonLedger, history } = judgeEvidence(master);
-
-      const items = [...names].sort().map((name) => {
-        const mm = m.get(name);
-        const ll = l.get(name);
-        const mode = resolveMode(name, modes, m, l);
-        let status;
-        if (mm && !ll) status = mode === 'master' ? 'master-only' : 'missing-local';
-        else if (!mm && ll) status = 'local-only';
-        else status = mm.treeHash === ll.treeHash ? 'same' : 'diff';
-
-        // 内容不同时顺便给出「谁更新」的结论，前端不用再自己算
-        let verdict = null;
-        let basis = null;
-        let hint = '';
-        let diff = null;
-        if (status === 'diff') {
-          const j = judgeUpdate({ name, master: mm, local: ll, record: lineage[name], ledger: mnemonLedger, history });
-          verdict = j.verdict;
-          basis = j.basis;
-          hint = j.detail;
-          diff = diffSummary(mm.text, ll.text);
-        }
-
-        return {
-          name,
-          mode,
-          explicit: Object.prototype.hasOwnProperty.call(modes, name),
-          status,
-          verdict,
-          basis,
-          hint,
-          diff,
-          masterVersion: (mm && mm.version) || '',
-          localVersion: (ll && ll.version) || '',
-          inMaster: !!mm,
-          inLocal: !!ll,
-        };
-      });
-
-      json(res, 200, { ok: true, masterRoot: master, localRoot: LOCAL_SKILLS_ROOT, items });
+      json(res, 200, { ok: true, ...(await deps.skillScope()) });
     },
 
-    /** 切换单机属性，并执行对应的实质动作（删母版 / 删本机 / 推送）。 */
-    'POST /skills/mode': async (req, res) => {
+    /** 人工改一个技能的归属（自己编写 / 第三方）。 */
+    'POST /skills/scope/set': async (req, res) => {
       const body = await readJson(req);
-      const state = loadState();
-      const master = state.skills.masterRoot;
-      if (!master) {
-        json(res, 400, { ok: false, error: '尚未设置技能母版文件夹' });
+      const name = String(body?.name || '').trim();
+      const scope = String(body?.scope || '').trim();
+      if (!name || (scope !== 'own' && scope !== 'third-party')) {
+        json(res, 400, { ok: false, error: '需要 name 与 scope（own | third-party）' });
         return;
       }
-      const mode = body.mode;
-      if (mode !== 'sync' && mode !== 'local' && mode !== 'master') {
-        json(res, 400, { ok: false, error: '属性只能是 sync / local / master' });
+      if (typeof deps.setSkillScope !== 'function') {
+        json(res, 500, { ok: false, error: '宿主未提供归属写入' });
         return;
       }
-      const names = Array.isArray(body.names) ? body.names.filter((n) => typeof n === 'string' && n) : [];
-      if (!names.length) {
-        json(res, 400, { ok: false, error: '未选择任何技能' });
-        return;
-      }
-
-      const stamp = makeStamp();
-      const backRoot = path.join(master, '_backup');
-      const modes = state.skills.modes || {};
-      const m0 = scanSkills(master);
-      const l0 = scanSkills(LOCAL_SKILLS_ROOT);
-
-      const results = [];
-      const applied = [];
-
-      for (const name of names) {
-        const from = resolveMode(name, modes, m0, l0);
-        const out = applyModeChange({
-          name,
-          from,
-          to: mode,
-          masterRoot: master,
-          localRoot: LOCAL_SKILLS_ROOT,
-          backRoot,
-          stamp,
-        });
-        results.push(out);
-        if (out.ok) applied.push({ name, mode });
-      }
-
-      // 只有成功的才落属性
-      const next = loadState();
-      for (const a of applied) next.skills.modes[a.name] = a.mode;
-      const auditItems = results.flatMap((r) => (r.ok && r.audit ? r.audit : []));
-      if (applied.length) {
-        pushHistory(next, 'skills', `技能属性：${applied.length} 个改为「${MODE_LABEL[mode]}」`);
-      }
-      saveState(next);
-
-      // 对母版的实际改动写审计
-      let audit = { written: 0, failed: [] };
-      if (auditItems.length) {
-        const w = appendMasterChanges(auditItems, {
-          masterRoot: master,
-          machineId: next.machineId,
-          machineName: next.machineName,
-          trigger: '用户授权',
-        });
-        audit = { written: w.written.length, failed: w.failed, path: w.written[0] && w.written[0].path };
-      }
-
-      json(res, 200, {
-        ok: true,
-        mode,
-        results,
-        applied: applied.length,
-        failed: results.filter((r) => !r.ok).length,
-        audit,
-      });
+      const r = await deps.setSkillScope({ name, scope });
+      json(res, r.ok ? 200 : 400, r);
     },
 
-    /** 技能同步配置。 */
+    /**
+     * 技能共享 + 优化的配置。
+     *
+     * 注意：**没有 masterRoot**。母版功能 1.3.0 起取消，技能来源就是各台机器
+     * 特征文件夹里的备份；老 state 里残留的 masterRoot 在这里被显式清掉。
+     */
     'POST /skills/config': async (req, res) => {
       const body = await readJson(req);
       const state = loadState();
       const skills = { ...state.skills };
+      const share = { ...(skills.share || {}) };
 
-      if (typeof body.masterRoot === 'string') {
-        const p = body.masterRoot.trim();
-        skills.masterRoot = p ? normSlash(p) : '';
-        // 设置路径时就把记录文件准备好，用户能立刻看到
-        if (skills.masterRoot && fs.existsSync(skills.masterRoot)) {
-          try {
-            ensureChangelog(skills.masterRoot);
-          } catch {
-            /* 母版只读时建不了，不影响后续 */
-          }
+      if (typeof body.enabled === 'boolean') skills.enabled = body.enabled;
+      if (typeof body.shareEnabled === 'boolean') share.enabled = body.shareEnabled;
+      if (typeof body.learn === 'boolean') share.learn = body.learn;
+      if (typeof body.autoApply === 'boolean') share.autoApply = body.autoApply;
+      if (body.learnPerRound !== undefined) {
+        const n = Number(body.learnPerRound);
+        if (!Number.isFinite(n) || n < 0 || n > 24) {
+          json(res, 400, { ok: false, error: '每轮评估条数应为 0 到 24' });
+          return;
         }
+        share.learnPerRound = Math.floor(n);
       }
-      if (typeof body.enabled === 'boolean') skills.enabled = body.enabled;
-      // 记忆插件技能优化自动落地：默认开，显式传 false 才关
-      if (typeof body.mnemonAuto === 'boolean') skills.mnemonAuto = body.mnemonAuto;
-      // 优化闭环（发现 → 判断 → 入队 → 审核 → 通过）：默认开
-      if (typeof body.mnemonOptimize === 'boolean') skills.mnemonOptimize = body.mnemonOptimize;
-      if (body.mnemonMinConfidence !== undefined) {
-        const n = Number(body.mnemonMinConfidence);
-        if (!Number.isFinite(n) || n < 0 || n > 1) {
-          json(res, 400, { ok: false, error: '置信度门槛应在 0 到 1 之间' });
+      if (body.optimizePerRound !== undefined) {
+        const n = Number(body.optimizePerRound);
+        if (!Number.isFinite(n) || n < 1 || n > 12) {
+          json(res, 400, { ok: false, error: '每轮优化条数应为 1 到 12' });
           return;
         }
-        skills.mnemonMinConfidence = n;
+        share.optimizePerRound = Math.floor(n);
       }
       if (body.intervalMinutes !== undefined) {
         const n = Number(body.intervalMinutes);
         if (!Number.isFinite(n) || n < 1 || n > 10080) {
-          json(res, 400, { ok: false, error: '间隔应为 1–10080 之间的整数（分钟）' });
+          json(res, 400, { ok: false, error: '间隔应为 1 到 10080 之间的整数（分钟）' });
           return;
         }
         skills.intervalMinutes = Math.floor(n);
       }
+      // 母版已取消：显式清掉残留字段，避免老配置继续影响任何判定
+      delete skills.masterRoot;
+      delete skills.mnemonAuto;
+      delete skills.mnemonOptimize;
+      skills.share = share;
       state.skills = skills;
       saveState(state);
       json(res, 200, { ok: true, skills: state.skills, localRoot: LOCAL_SKILLS_ROOT });