ygc-dsh-sync 1.2.2 → 1.3.0

package/index.js

@@ -19,22 +19,13 @@ import {
 import { attachMany, findPulledUnattached } from './lib/attach.js';
 import { scanFolders } from './lib/patrol.js';
 import { applyFeaturePlan, onlyActive, pickRemovedIds, planFeatures, reconcileRemoved } from './lib/features.js';
-import {
-  LINEAGE_FILE,
-  LOCAL_SKILLS_ROOT,
-  applyPull,
-  applyPush,
-  buildHistoryIndex,
-  loadLineage,
-  makeStamp,
-  planSync,
-  readMnemonLedger,
-  recordLineage,
-  saveLineage,
-} from './lib/skills.js';
-import { appendMasterChanges } from './lib/changelog.js';
-import { runMnemonPrepass } from './lib/mnemon.js';
-import { runOptimizationCycle } from './lib/mnemon-optimize.js';
+// 1.3.0 母版取消：技能不再有「母版 ↔ 本机」这条链，只剩
+//   本机特征文件夹备份 + 别人格子只读拉取 + 本机技能优化
+import { LOCAL_SKILLS_ROOT } from './lib/skills.js';
+import { draftsDirOf, runSkillShare } from './lib/skill-share-run.js';
+import { inspectAll, runOptimizeRound } from './lib/skill-optimize.js';
+import { ownNames, scopeSnapshot, SCOPE } from './lib/skill-scope.js';
+import { approveLearning, listPendingLearnings, readDraft, rejectLearning } from './lib/skill-learn.js';
 import { createHostDrafter } from './lib/mnemon-drafter.js';
 import {
   addToBundles as addPluginToBundles,
@@ -44,9 +35,6 @@ import {
 
 export const inject = ['webServer', 'workspaceRegistry'];
 
-/** 外部草稿暂存区：优化闭环把待审草稿放这里，审核通过才落地。 */
-const STAGE_DIR = process.env.DSH_SYNC_STAGE_DIR || 'C:/DSH-Work/mnemon-drafts/stage';
-
 const DEBOUNCE_MS = 4000;
 /** 巡检轮询间隔：每 30 秒看一次是否到了该跑的时候。 */
 const PATROL_TICK_MS = 30 * 1000;
@@ -212,7 +200,265 @@ export function apply(ctx, config = {}) {
     }
   };
 
-  // ---- HTTP API ----
+  // ---- 技能共享（1.3.0 新增）----
+  //
+  // 与插件清单同步同构：一人一格，只写自己的格子。触发点是「技能同步」
+  // （开机 + 定时 + 面板按钮），不单独开一个定时器——用户的心智模型是
+  // 「同步技能时顺带把技能也共享出去」，两个独立周期只会让人怀疑哪个没跑。
+  const runShare = async ({ reason = '技能同步', dryRun = false } = {}) => {
+    const state = loadState();
+    const share = state.skills.share || {};
+    if (share.enabled === false && reason !== '手动') {
+      return { ok: true, skipped: '技能共享已关闭' };
+    }
+    const feature = state.machineId;
+    if (!feature) return { ok: false, error: '本机标识还没生成' };
+    let generate = null;
+    try {
+      generate = createHostDrafter(ctx, {
+        logger: (m) => log(`[learn] ${m}`),
+        provider: config.draftProvider,
+        model: config.draftModel,
+      });
+    } catch {
+      generate = null;
+    }
+    const report = await runSkillShare({
+      config: { libraryRoot: state.plugins.libraryRoot },
+      machineId: feature,
+      machineHash: state.machineHash,
+      machineName: state.machineName,
+      localRoot: LOCAL_SKILLS_ROOT,
+      // 母版已取消：不再传 masterRoot。技能来源就是各台机器的特征文件夹备份，
+      // 归属判定只靠市场台账 + 人工指定 + 默认归自己（见 lib/skill-scope.js）。
+      modes: state.skills.modes || {},
+      scopeOverrides: (state.skills.share && state.skills.share.scope) || {},
+      learn: share.learn !== false,
+      learnPerRound: Number(share.learnPerRound) || 4,
+      autoApply: share.autoApply === true,
+      generate,
+      dryRun,
+      log,
+      reason,
+    });
+    if (dryRun) return report;
+    const next = loadState();
+    if (!next.skills.share) next.skills.share = {};
+    next.skills.share.lastRunAt = Date.now();
+    next.skills.share.lastScope = report.scope || null;
+    next.skills.share.lastResult = {
+      peers: report.peers.length,
+      own: report.scope ? report.scope.own : null,
+      thirdParty: report.scope ? report.scope.thirdParty.length : 0,
+      backup: report.backup ? report.backup.counts.total : 0,
+      missing: report.missing.found,
+      pulled: report.missing.pulled,
+      differ: report.differ.found,
+      evaluated: report.differ.evaluated,
+      byAction: report.differ.byAction,
+      pending: report.pending,
+      applied: report.applied.length,
+      redundant: report.redundant || 0,
+      reason,
+    };
+    next.skills.share.lastError = report.errors.length ? report.errors.slice(0, 3).join('；') : '';
+    if (report.missing.pulled || report.differ.evaluated || report.errors.length) {
+      pushHistory(next, {
+        kind: 'skill-share',
+        detail:
+          `技能共享（${reason}）：备份 ${report.backup ? report.backup.counts.total : 0}、` +
+          `他人 ${report.peers.length} 台、缺失 ${report.missing.found}（拉 ${report.missing.pulled}）、` +
+          `差异 ${report.differ.found}（评估 ${report.differ.evaluated}）、待批 ${report.pending}` +
+          (report.errors.length ? `、错误 ${report.errors.length}` : ''),
+      });
+    }
+    saveState(next);
+    return report;
+  };
+
+  // ---- 本机技能优化（1.3.0）----
+  //
+  // 点一下就在后台跑：体检 → 排优先级 → 调模型出草稿 → 落草稿等批。
+  // 三条纪律：
+  //   ① 同一时刻只跑一轮（inFlight），重复点击不会堆出并发模型调用
+  //   ② 只处理归本插件管的技能；市场装的第三方技能在 ownSet 之外，直接跳过
+  //   ③ 出的都是草稿，改本机技能只在人点「批准」时发生（批准前留备份）
+  /** 优化任务的运行态：面板靠它显示进度，不靠长连接的返回值。 */
+  const optimizeRun = {
+    running: false,
+    startedAt: null,
+    finishedAt: null,
+    lastReport: null,
+    lastError: null,
+    reason: '',
+  };
+
+  /** 归属判定的统一入口：一处算、处处用。 */
+  const scopeOf = () => {
+    const st = loadState();
+    const overrides = (st.skills.share && st.skills.share.scope) || {};
+    return scopeSnapshot({
+      localRoot: LOCAL_SKILLS_ROOT,
+      overrides,
+    });
+  };
+
+  /** 拿 ownSet（Set<技能名>），失败时退化成 null（调用方按「全都管」处理）。 */
+  const ownSetOf = () => {
+    try {
+      const st = loadState();
+      const overrides = (st.skills.share && st.skills.share.scope) || {};
+      return ownNames({ localRoot: LOCAL_SKILLS_ROOT, overrides }).names;
+    } catch (err) {
+      log(`技能归属判定失败，按「全都管」处理：${String((err && err.message) || err)}`);
+      return null;
+    }
+  };
+
+  /** 整库体检：纯机械、不调模型、不写盘，随时可点。 */
+  const inspectSkills = () => {
+    const out = inspectAll({ localRoot: LOCAL_SKILLS_ROOT, ownSet: ownSetOf() });
+    return {
+      ...out,
+      thirdPartyNote: '技能市场装的第三方技能不进体检（不管理、不同步、不优化）',
+      scope: scopeOf().counts,
+    };
+  };
+
+  /** 起一轮优化（后台）。已经有一轮在跑就直接返回当前运行态。 */
+  const startOptimize = ({ maxPerRound, includeMerge = true } = {}) => {
+    if (optimizeRun.running) {
+      return { running: true, startedAt: optimizeRun.startedAt, note: '上一轮还在跑，本次未启动' };
+    }
+    optimizeRun.running = true;
+    optimizeRun.startedAt = Date.now();
+    optimizeRun.finishedAt = null;
+    optimizeRun.lastError = null;
+    optimizeRun.reason = '面板';
+    const st = loadState();
+    const share = st.skills.share || {};
+    const feature = st.machineId;
+    const ownSet = ownSetOf();
+    let generate = null;
+    try {
+      generate = createHostDrafter(ctx, {
+        logger: (m) => log(`[opt] ${m}`),
+        provider: config.draftProvider,
+        model: config.draftModel,
+      });
+    } catch {
+      generate = null;
+    }
+    Promise.resolve()
+      .then(() =>
+        runOptimizeRound({
+          config: { libraryRoot: st.plugins.libraryRoot },
+          machineId: feature,
+          machineName: st.machineName,
+          localRoot: LOCAL_SKILLS_ROOT,
+          ownSet,
+          generate,
+          maxPerRound: Number(maxPerRound) || Number(share.optimizePerRound) || 3,
+          includeMerge,
+          log,
+        }),
+      )
+      .then((report) => {
+        optimizeRun.lastReport = {
+          scanned: report.scanned,
+          healthy: report.healthy,
+          skippedThirdParty: report.skippedThirdParty,
+          queued: report.queued.length,
+          drafted: report.drafted.length,
+          draftedNames: report.drafted.map((x) => `${x.name}（${x.label}）`).slice(0, 12),
+          rejected: report.rejected.length,
+          merged: report.merged.length,
+          errors: report.errors.slice(0, 5),
+          dryRun: report.dryRun,
+          ms: report.ms,
+        };
+        const next = loadState();
+        if (!next.skills.share) next.skills.share = {};
+        next.skills.share.lastOptimizeAt = Date.now();
+        next.skills.share.lastOptimize = optimizeRun.lastReport;
+        if (report.drafted.length || report.errors.length) {
+          pushHistory(next, {
+            kind: 'skill-optimize',
+            detail:
+              `本机技能优化：体检 ${report.scanned} 个（健康 ${report.healthy}，第三方跳过 ${report.skippedThirdParty}）、` +
+              `出草稿 ${report.drafted.length}、审核未过 ${report.rejected.length}` +
+              (report.errors.length ? `、错误 ${report.errors.length}` : ''),
+          });
+        }
+        saveState(next);
+      })
+      .catch((err) => {
+        optimizeRun.lastError = String((err && err.message) || err);
+        log(`本机技能优化失败：${optimizeRun.lastError}`);
+      })
+      .finally(() => {
+        optimizeRun.running = false;
+        optimizeRun.finishedAt = Date.now();
+      });
+    return { running: true, startedAt: optimizeRun.startedAt };
+  };
+
+  /** 待批草稿（学习 + 优化同一份台账）。 */
+  const listLearning = () => {
+    const st = loadState();
+    if (!st.machineId) return [];
+    try {
+      return listPendingLearnings({ config: { libraryRoot: st.plugins.libraryRoot }, machineId: st.machineId });
+    } catch (err) {
+      log(`读待批草稿失败：${String((err && err.message) || err)}`);
+      return [];
+    }
+  };
+
+  const draftOf = (name) => {
+    const st = loadState();
+    if (!st.machineId) return { ok: false, text: '', message: '本机标识还没生成' };
+    return readDraft({ config: { libraryRoot: st.plugins.libraryRoot }, machineId: st.machineId, name });
+  };
+
+  const approveOf = ({ name, force = false }) => {
+    const st = loadState();
+    if (!st.machineId) return { ok: false, message: '本机标识还没生成' };
+    const r = approveLearning({
+      config: { libraryRoot: st.plugins.libraryRoot },
+      machineId: st.machineId,
+      localRoot: LOCAL_SKILLS_ROOT,
+      name,
+      force,
+      log,
+    });
+    if (r.ok) {
+      const next = loadState();
+      pushHistory(next, { kind: 'skill-apply', detail: `技能草稿落地：${name}` });
+      saveState(next);
+    }
+    return r;
+  };
+
+  const rejectOf = ({ name, reason }) => {
+    const st = loadState();
+    if (!st.machineId) return { ok: false, message: '本机标识还没生成' };
+    return rejectLearning({ config: { libraryRoot: st.plugins.libraryRoot }, machineId: st.machineId, name, reason });
+  };
+
+  /** 人工改归属：写进 state（本机持久化），下次判定直接生效。 */
+  const setScopeOf = ({ name, scope }) => {
+    const allowed = new Set([SCOPE.OWN, SCOPE.THIRD_PARTY]);
+    if (!allowed.has(scope)) return { ok: false, message: `未知归属 ${scope}` };
+    const next = loadState();
+    if (!next.skills.share) next.skills.share = {};
+    if (!next.skills.share.scope || typeof next.skills.share.scope !== 'object') next.skills.share.scope = {};
+    next.skills.share.scope[name] = scope;
+    saveState(next);
+    log(`技能归属改为 ${scope}：${name}（人工指定优先于市场台账判定）`);
+    return { ok: true, name, scope, scopeSnapshot: scopeOf() };
+  };
+
   const api = createApi({
     workspaces,
     machineId,
@@ -222,6 +468,26 @@ export function apply(ctx, config = {}) {
     entities,
     // 起草器：宿主的默认模型。没有 llm 服务时返回 null，流水线自动跳过起草。
     log,
+    // 技能共享（1.3.0）：同步一次 / 技能同步触发时顺带跑
+    runShare,
+    draftsRoot: () => {
+      const st = loadState();
+      return draftsDirOf({ libraryRoot: st.plugins.libraryRoot }, st.machineId);
+    },
+    skillShareConfig: () => {
+      const st = loadState();
+      return { ...(st.skills.share || {}), libraryRoot: st.plugins.libraryRoot, machineId: st.machineId };
+    },
+    // 本机优化：体检 / 出草稿（后台跑）/ 待批草稿的批准与驳回
+    inspectSkills: async () => inspectSkills(),
+    runOptimize: (opts) => startOptimize(opts),
+    optimizeState: () => ({ ...optimizeRun }),
+    learningList: async () => listLearning(),
+    learningDraft: async (name) => draftOf(name),
+    learningApprove: async (args) => approveOf(args),
+    learningReject: async (args) => rejectOf(args),
+    skillScope: async () => scopeOf(),
+    setSkillScope: async (args) => setScopeOf(args),
     // 插件清单同步（1.0.0 迁入）：同步动作、安装通道、bundles 登记
     syncPlugins,
     pluginInstall,
@@ -607,209 +873,28 @@ export function apply(ctx, config = {}) {
     };
   });
 
-  // ---- 技能同步定时器 ----
-  // 语义：开机拉取一次，之后每 intervalMinutes 分钟一次（默认 120）。
+  // ---- 技能共享 + 本机优化 ----
   //
-  // 每轮开头先跑「记忆插件预处理」：把 dsh-mnemon 写好的 ready 草稿落地到
-  // 本机并推回母版，再照常比对。这样一次同步就把两件事一起做完，不必人
-  // 到面板上逐个点采纳，草稿也不会在账本里越积越多。
-  /** 优化闭环的起草段是否在跑：后台任务，同一时刻只允许一轮。 */
-  let optimizeInFlight = false;
-
+  // 语义（1.3.0 起，母版取消后）：开机跑一次，之后每 intervalMinutes 分钟一次。
+  // 一轮里做三件事，顺序固定：
+  //   1. 把本机自研技能备份进 `插件库/<本机标识>/skills/`（整棵目录 + 名片）
+  //   2. 扫别人格子：本机没有的拉过来；同名不同内容进学习评估出草稿
+  //   3. （可选）顺带跑一轮本机优化：精炼 / 精简 / 合并重复 / 补工况 / 补踩坑
+  //
+  // 三条纪律：
+  //   ① 只碰「归本插件管」的技能：市场装的第三方技能不同步、不优化（skill-scope.js 判定）
+  //   ② 优化一律出草稿，不自动改本机技能；批准才落地（除非显式开 share.autoApply）
+  //   ③ 别人的特征文件夹全程只读：本模块的写操作全在自己那一格里
   const runSkillsPull = async (reason) => {
     try {
       const state = loadState();
-      const master = state.skills.masterRoot;
-      if (!master || !fs.existsSync(master)) {
-        log(`技能拉取跳过：母版不可用（${master || '未设置'}）`);
+      if (state.skills.enabled === false && reason !== '手动') {
         return null;
       }
-
-      // ── 阶段 0：记忆插件技能优化闭环（发现 → 起草 → 审核 → 落地 → 结案）
-      //
-      // 两条纪律：
-      // ① **起草不能阻塞同步**。一轮最多 6 条、每条一次模型调用几十秒，串进同步里
-      //    会让 pull/push 卡两分钟以上，看起来像同步挂了。所以起草放在后台跑，
-      //    同步立刻继续；后台那轮自己写账本、自己落地。
-      // ② 后台同一时刻只允许跑一轮，用 inFlight 挡住重入。
-      if (state.skills.mnemonOptimize !== false) {
-        if (optimizeInFlight) {
-          log('优化闭环：上一轮还在跑，本轮跳过起草');
-        } else {
-          optimizeInFlight = true;
-          // 先把「不需要模型」的部分做完（对账结案、已有草稿审核落地），这一步很快
-          runOptimizationCycle({
-            localRoot: LOCAL_SKILLS_ROOT,
-            masterRoot: master,
-            stageDir: STAGE_DIR,
-            minConfidence: Number(state.skills.mnemonMinConfidence) || 0.7,
-            enabled: true,
-            draft: null,
-            onEvent: (kind, payload) => {
-              if (kind === 'landed') log(`优化闭环落地: ${payload.skillName}`);
-            },
-          })
-            .then((r) => {
-              if (r.closed.length || r.accepted.length) {
-                log(
-                  `优化闭环（无模型段）：结案 ${r.closed.length}、落地 ${r.accepted.length}、剩余 ${r.remaining}`,
-                );
-              }
-              // 再把这批「需要模型」的丢到后台
-              return runOptimizationCycle({
-                localRoot: LOCAL_SKILLS_ROOT,
-                masterRoot: master,
-                stageDir: STAGE_DIR,
-                minConfidence: Number(state.skills.mnemonMinConfidence) || 0.7,
-                enabled: true,
-                draft: createHostDrafter(ctx, { logger: (m) => log(`[draft] ${m}`) }),
-                maxDrafts: Number(state.skills.mnemonMaxDrafts) || 6,
-                onEvent: (kind, payload) => {
-                  if (kind === 'landed' || kind === 'drafting' || kind === 'audit-fail' || kind === 'parse-fail') {
-                    log(`优化闭环 ${kind}: ${payload.skillName}`);
-                  }
-                },
-              });
-            })
-            .then((r) => {
-              log(
-                `优化闭环（起草段）：起草 ${(r.pipeline?.stage?.drafted || []).length}、` +
-                  `落地 ${r.accepted.length}、失败 ${(r.pipeline?.stage?.failed || []).length}、剩余 ${r.remaining}`,
-              );
-              for (const e of r.errors.slice(0, 6)) log(`  ! ${e}`);
-            })
-            .catch((err) => log(`优化闭环失败：${err && err.message ? err.message : String(err)}`))
-            .finally(() => {
-              optimizeInFlight = false;
-            });
-        }
-      }
-
-      // 记忆插件草稿预处理（可关：state.skills.mnemonAuto === false）
-      const prepass = runMnemonPrepass({
-        masterRoot: master,
-        localRoot: LOCAL_SKILLS_ROOT,
-        modes: state.skills.modes || {},
-        machineId: state.machineId,
-        machineName: state.machineName,
-        enabled: state.skills.mnemonAuto !== false,
-      });
-      if (prepass.applied.length || prepass.skipped.length) {
-        log(
-          `记忆插件预处理：草稿 ${prepass.drafts}、落地 ${prepass.applied.length}、` +
-            `跳过 ${prepass.skipped.length}、推回母版 ${prepass.pushed.length}`,
-        );
-      }
-
-      // 判新旧要的三份只读证据：谱系观测 + 记忆插件账本 + 历史快照
-      const lineageFile = path.join(master, LINEAGE_FILE);
-      const lineage = loadLineage(lineageFile);
-      const plan = planSync({
-        masterRoot: master,
-        localRoot: LOCAL_SKILLS_ROOT,
-        modes: (state.skills.modes || {}),
-        lineage,
-        mnemonLedger: readMnemonLedger(),
-        history: buildHistoryIndex({ masterRoot: master, localRoot: LOCAL_SKILLS_ROOT }),
-      });
-      const stamp = makeStamp();
-
-      // 母版更新 → 拉下来；本机更新（同步属性）→ 推上去。判不出来的一律不动。
-      const pulled = plan.pull.length
-        ? applyPull({ items: plan.pull, localRoot: LOCAL_SKILLS_ROOT, stamp })
-        : { pulled: [], errors: [] };
-
-      let pushed = { pushed: [], errors: [] };
-      if (plan.autoPush.length) {
-        pushed = applyPush({
-          items: plan.autoPush,
-          masterRoot: master,
-          backRoot: path.join(master, '_backup'),
-          stamp,
-        });
-        const audit = pushed.pushed.map((p) => ({
-          skill: p.name,
-          operation: p.operation,
-          detail: `${p.operation === '覆盖' ? `旧版备份于 _backup/${p.name}.${stamp}` : '母版此前无此技能'}（自动：内容更新）`,
-        }));
-        if (audit.length) {
-          try {
-            appendMasterChanges(audit, {
-              masterRoot: master,
-              machineId: state.machineId,
-              machineName: state.machineName,
-              trigger: `自动同步（${reason}）`,
-            });
-          } catch {
-            /* 记录写不进去不影响同步 */
-          }
-        }
-      }
-
-      // 记观测 + 把已经对齐的登记成基线
-      let stamped = 0;
-      try {
-        let map = lineage;
-        const now = Date.now();
-        for (const [name, m] of plan.master) {
-          const l = plan.local.get(name);
-          if (!l) continue;
-          map = recordLineage(map, {
-            name,
-            ...(m.treeHash === l.treeHash ? { baseline: m.treeHash } : {}),
-            master: m,
-            local: l,
-            by: `timer:${reason}`,
-            at: now,
-          });
-        }
-        const aligned = [
-          ...plan.pull.map((x) => x.master),
-          ...plan.autoPush.map((x) => x.local),
-          ...plan.same.map((x) => x.master),
-        ].filter(Boolean);
-        for (const x of aligned) {
-          map = recordLineage(map, { name: x.name, baseline: x.treeHash, master: x, local: x, by: `timer:${reason}`, at: now });
-        }
-        stamped = saveLineage(lineageFile, map) ? aligned.length : 0;
-      } catch {
-        /* 谱系写失败只影响判定精度，不影响主流程 */
-      }
-
-      const next = loadState();
-      next.skills.lastRunAt = Date.now();
-      next.skills.lastResult = {
-        pulled: pulled.pulled.length,
-        pushed: pushed.pushed.length,
-        pendingPush: plan.push.length,
-        errors: pulled.errors.length + pushed.errors.length + prepass.errors.length,
-        lineage: stamped,
-        reason,
-        // 起草已移到后台（见阶段 0），同步这一轮没有可报告的优化数据；
-        // 实况用 POST /skills/optimize/state 查。
-        optimize: null,
-        mnemon: {
-          drafts: prepass.drafts,
-          applied: prepass.applied.length,
-          pushed: prepass.pushed.length,
-          skipped: prepass.skipped.length,
-        },
-      };
-      const summary = `拉取 ${pulled.pulled.length}、推送 ${pushed.pushed.length}、待裁决 ${plan.push.length}`;
-      const mnemonNote = prepass.applied.length
-        ? `；记忆插件草稿落地 ${prepass.applied.length}（推回母版 ${prepass.pushed.length}）`
-        : '';
-      if (pulled.pulled.length || pushed.pushed.length || plan.push.length || prepass.applied.length) {
-        pushHistory(next, 'skills', `技能自动同步（${reason}）：${summary}${mnemonNote}`);
-      }
-      saveState(next);
-
-      if (pulled.pulled.length || pushed.pushed.length || plan.push.length || prepass.applied.length) {
-        log(`技能自动同步：${summary}${mnemonNote}`);
-      }
-      return next.skills.lastResult;
+      const report = await runShare({ reason });
+      return report;
     } catch (err) {
-      log(`技能拉取失败：${err && err.message ? err.message : err}`);
+      log(`技能共享失败：${err && err.message ? err.message : String(err)}`);
       return null;
     }
   };
@@ -823,7 +908,9 @@ export function apply(ctx, config = {}) {
       try {
         const state = loadState();
         const cfg = state.skills || {};
-        if (!cfg.enabled || !cfg.masterRoot) {
+        const share = cfg.share || {};
+        // 没有母版了：开关只看 enabled，不再要求任何外部路径存在
+        if (cfg.enabled === false || share.enabled === false) {
           booted = false;
           nextDueAt = 0;
           lastIntervalMs = 0;
@@ -834,31 +921,31 @@ export function apply(ctx, config = {}) {
 
         // 间隔被改过：按新间隔从上次运行时间重算
         if (lastIntervalMs && intervalMs !== lastIntervalMs) {
-          const lastRun = Number(cfg.lastRunAt) || 0;
+          const lastRun = Number(share.lastRunAt) || 0;
           nextDueAt = lastRun ? lastRun + intervalMs : Date.now();
         }
         lastIntervalMs = intervalMs;
 
-        // 开机首拉
+        // 开机首跑
         if (!booted) {
           booted = true;
-          runSkillsPull('开机').catch((err) => log('开机同步失败：' + (err && err.message ? err.message : String(err))));
+          runSkillsPull('开机').catch((err) => log('开机共享失败：' + (err && err.message ? err.message : String(err))));
           nextDueAt = Date.now() + intervalMs;
           return;
         }
 
         if (Date.now() < nextDueAt) return;
 
-        runSkillsPull('定时').catch((err) => log('定时同步失败：' + (err && err.message ? err.message : String(err))));
+        runSkillsPull('定时').catch((err) => log('定时共享失败：' + (err && err.message ? err.message : String(err))));
         nextDueAt = Date.now() + intervalMs;
       } catch (err) {
-        log(`技能同步调度失败：${err && err.message ? err.message : err}`);
+        log(`技能共享调度失败：${err && err.message ? err.message : err}`);
       }
     };
 
     const timer = setInterval(tick, PATROL_TICK_MS);
     if (typeof timer?.unref === 'function') timer.unref();
-    // 开机首拉稍晚一点，避开启动高峰
+    // 开机首跑稍晚一点，避开启动高峰
     const boot = setTimeout(tick, 12 * 1000);
     if (typeof boot?.unref === 'function') boot.unref();
 
@@ -868,6 +955,7 @@ export function apply(ctx, config = {}) {
     };
   });
 
+
   log('已加载');
 }