@yixinkj/priority-buyer-alert-cli 0.1.43 → 0.1.44

package/index.js

@@ -1,15 +1,21 @@
 #!/usr/bin/env node
 
-import crypto from 'node:crypto';
 import fs from 'node:fs';
-import http from 'node:http';
-import https from 'node:https';
 import os from 'node:os';
 import path from 'node:path';
 import { spawnSync } from 'node:child_process';
 import { createRequire } from 'node:module';
 import { fileURLToPath } from 'node:url';
 
+// 三份启动器里逐字相同的那 700 行现在住在 launcher-core.js。
+// 它不读取任何「我是谁」的信息：SKILL_ID、版本、版本目录、日志前缀、环境变量名、
+// import.meta.url 全部由下面的绑定层显式传入，漏传就在内核入口抛一句中文错误。
+// 为什么必须这样：见 launcher-core-migration.md §1（SKILL_ID is not defined 事故）。
+// 这个文件怎么进到别的仓、怎么保证四份一致：见 launcher-core-distribution.md。
+// 注意：它必须出现在 package.json 的 files 里，否则发布出去的包在 npx 第一行就
+// ERR_MODULE_NOT_FOUND。package-contents.test.js 用真实的 npm pack 清单守着这一条。
+import * as core from './launcher-core.js';
+
 const require = createRequire(import.meta.url);
 const packageJson = require('./package.json');
 const registry = require('./skills.json');
@@ -49,257 +55,155 @@ const VERSION_ROOT = path.join(RUNTIME_ROOT, 'versions', `v${RUNTIME_VERSION}`);
 const BIN_DIR = path.join(VERSION_ROOT, 'bin');
 const INSTALL_MARKER = path.join(VERSION_ROOT, 'installed.json');
 
-function fail(message) {
-  console.error(`[${SKILL_ID}] ${message}`);
-  process.exit(1);
-}
-
-function emitStatus(status, message, details = {}) {
-  console.log(
-    JSON.stringify({ status, message, skill_version: SKILL_VERSION, ...details }, null, 2)
-  );
-}
-
-function parseSkillMetadata(content) {
-  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/);
-  if (!match) return {};
-  const metadata = {};
-  for (const line of match[1].split(/\r?\n/)) {
-    const field = line.match(/^([A-Za-z][A-Za-z0-9_-]*):\s*(.*)$/);
-    if (!field) continue;
-    let value = field[2].trim();
-    if (
-      value.length >= 2 &&
-      ((value.startsWith('"') && value.endsWith('"')) ||
-        (value.startsWith("'") && value.endsWith("'")))
-    ) {
-      value = value.slice(1, -1);
-    }
-    metadata[field[1]] = value;
-  }
-  return metadata;
-}
-
-function parseSemver(version) {
-  const match = String(version || '').trim().match(/^(\d+)\.(\d+)\.(\d+)$/);
-  return match ? match.slice(1).map(Number) : null;
-}
-
-function compareVersions(left, right) {
-  const a = parseSemver(left);
-  const b = parseSemver(right);
-  if (!a && !b) return 0;
-  if (!a) return -1;
-  if (!b) return 1;
-  for (let index = 0; index < 3; index += 1) {
-    if (a[index] !== b[index]) return a[index] < b[index] ? -1 : 1;
-  }
-  return 0;
-}
-
-function extractSkillPath(args) {
-  let skillPath = null;
-  const forwardedArgs = [];
-  for (let index = 0; index < args.length; index += 1) {
-    const arg = args[index];
-    if (arg === '--skill-path') {
-      if (!args[index + 1]) throw new Error('--skill-path 缺少 SKILL.md 路径');
-      skillPath = args[index + 1];
-      index += 1;
-      continue;
-    }
-    if (arg.startsWith('--skill-path=')) {
-      skillPath = arg.slice('--skill-path='.length);
-      continue;
-    }
-    forwardedArgs.push(arg);
-  }
-  return { skillPath, forwardedArgs };
-}
-
-function isHelpRequest(args) {
-  return args.length === 0 || args.some((arg) => arg === '--help' || arg === '-h');
-}
+/* ------------------------------------------------------------------ *
+ * 绑定层
+ *
+ * 这一层只做一件事：把上面那批「我是谁」的常量补给共享内核。里面不允许有判断逻辑，
+ * 有判断的部分（身份校验、退出协议、帮助文案）一律留在下面的本仓代码里。
+ *
+ * 保留同名薄封装而不是直接调用 core.*，是因为现有 index.test.js 是回归基线：
+ * 它按位置参数调用 pruneOldRuntimeVersions / reportPrunedRuntimeVersions，
+ * 按三参数调用 verifyReleaseArchive。封装在这里，测试一行都不用改。
+ * ------------------------------------------------------------------ */
+
+const fail = core.createFailHandler({ logPrefix: SKILL_ID });
+
+const emitStatus = core.createStatusEmitter({ skillVersion: SKILL_VERSION });
+
+// 本仓把「不带任何参数」当作帮助请求（它没有可用的默认动作）。这个值必须显式写出来：
+// public-customer-reactivation 的答案是相反的，内核因此不给默认值。
+const isHelpRequest = (args) => core.isHelpRequest(args, { emptyArgsMeansHelp: true });
+
+// 环境变量的**名字**属于本仓身份，留在这里；「显式覆盖主源就不追加默认备用源」那条规则在内核里。
+// 必须在函数内部读 process.env：模块加载时读会让测试和联调无法在运行中改源。
+const releaseBaseUrls = () =>
+  core.resolveReleaseBaseUrls({
+    defaultPrimary: OSS_RELEASE_BASE_URL,
+    defaultFallbacks: [R2_RELEASE_BASE_URL],
+    overridePrimary: process.env.PRIORITY_BUYER_ALERT_RELEASE_BASE_URL,
+    overrideFallbacks: process.env.PRIORITY_BUYER_ALERT_FALLBACK_BASE_URLS
+  });
 
-function printHelp() {
-  process.stdout.write(`${SKILL_DISPLAY_NAME} ${SKILL_VERSION}（Runtime ${RUNTIME_VERSION}）
+const releaseUrls = (target) => core.releaseUrls(releaseBaseUrls(), target);
 
-用法：
-  ${SKILL_ID} --skill-path <SKILL.md> --start [扫描选项]
-  ${SKILL_ID} --skill-path <SKILL.md> --poll-run <RUN_ID>
-  ${SKILL_ID} --skill-path <SKILL.md> --run-status <RUN_ID>
-  ${SKILL_ID} --skill-path <SKILL.md> --cancel-run <RUN_ID>
-  ${SKILL_ID} --skill-path <SKILL.md> --first-response-scan [--since 24] [--limit 100]
+const runtimeManifestUrls = () => core.runtimeManifestUrls(releaseBaseUrls());
 
-通用：
-  --skill-path <PATH>       本次实际读取的 SKILL.md 绝对路径
-  --version                 显示版本
-  --help                    显示本帮助
+const runtimeManifestUrl = () => runtimeManifestUrls()[0];
 
-扫描选项（仅与 --start 一起使用）：
-  --minutes <N>             回复时限（SLA），默认 30
-  --lookback-hours <N>      只看最近 N 小时内有过消息的询盘，默认 24；0 表示不限
-  --max-pages <N>           翻页上限，每页 100 条，默认 3
-  --levels <LEVELS>         重点买家等级白名单，默认 L1+,L2,L3,L4  (阿里等级 L0-L4，L4 封顶)
-  --re-alert <N>            升级重提间隔；不给则只提醒一次
-  --assignee <NAME>         只看某个负责人
-  --no-strict-bot           关闭机器人核验
-  --verify-all-replied      对全部已回复的重点买家做详情核验
-  --mark                    推进提醒水位；只有心跳式调用才应使用
-
-首响扫描选项（仅与 --first-response-scan 一起使用）：
-  --since <HOURS>           只看最近 N 小时内有消息的询盘，默认 24
-  --limit <N>               本轮最多核验多少条会话详情，默认 100
-
-环境变量：
-  PRIORITY_BUYER_ALERT_DETAIL_CONCURRENCY   详情核验并发度，默认 3，范围 1-8
+// 清单 schema 是本 Skill 自己的字符串：两个 Skill 的产物可能放在同一个桶里，
+// 只比版本号会让「下错 Skill 的包」一路通过校验。
+const verifyReleaseArchive = (manifest, target, archivePath) =>
+  core.verifyReleaseArchive(manifest, target, archivePath, {
+    manifestSchema: RUNTIME_MANIFEST_SCHEMA,
+    runtimeVersion: RUNTIME_VERSION
+  });
 
-本 Skill 只读：只提醒，不发送消息、不修改任何页面状态。
-`);
-}
+// options 放在最后展开：测试会注入 baseUrls / downloadFile，注入值必须能盖掉默认值。
+const downloadVerifiedRelease = (target, releaseManifestPath, archivePath, options = {}) =>
+  core.downloadVerifiedRelease(target, releaseManifestPath, archivePath, {
+    baseUrls: releaseBaseUrls(),
+    downloadFile: (url, outputPath) =>
+      core.download(url, outputPath, { userAgent: `@yixinkj/${SKILL_ID}-cli` }),
+    verifyArchive: verifyReleaseArchive,
+    ...options
+  });
 
-function normalizePath(filePath) {
-  const resolved = path.resolve(filePath);
-  return process.platform === 'win32' ? resolved.toLowerCase() : resolved;
-}
+const detectTarget = () =>
+  core.detectTarget({ platforms: registry.platforms, binName: registry.skill.bin });
 
-function stripJsonComments(content) {
-  let output = '';
-  let inString = false;
-  let escaped = false;
-  let lineComment = false;
-  let blockComment = false;
-  for (let index = 0; index < content.length; index += 1) {
-    const char = content[index];
-    const next = content[index + 1];
-    if (lineComment) {
-      if (char === '\n') {
-        lineComment = false;
-        output += char;
-      }
-      continue;
-    }
-    if (blockComment) {
-      if (char === '*' && next === '/') {
-        blockComment = false;
-        index += 1;
-      }
-      continue;
-    }
-    if (inString) {
-      output += char;
-      if (escaped) escaped = false;
-      else if (char === '\\') escaped = true;
-      else if (char === '"') inString = false;
-      continue;
-    }
-    if (char === '"') {
-      inString = true;
-      output += char;
-      continue;
-    }
-    if (char === '/' && next === '/') {
-      lineComment = true;
-      index += 1;
-      continue;
-    }
-    if (char === '/' && next === '*') {
-      blockComment = true;
-      index += 1;
-      continue;
-    }
-    output += char;
-  }
-  return output.replace(/,\s*([}\]])/g, '$1');
-}
+const isInstalled = (target) =>
+  core.isRuntimeInstalled({
+    target,
+    binDir: BIN_DIR,
+    installMarkerPath: INSTALL_MARKER,
+    runtimeVersion: RUNTIME_VERSION
+  });
 
-function readSkillsRegistry(registryPath) {
-  return JSON.parse(stripJsonComments(fs.readFileSync(registryPath, 'utf8')));
-}
+// 位置参数原样保留，index.test.js 里 `pruneOldRuntimeVersions(root, 'v0.1.1', 2)` 不用改。
+const pruneOldRuntimeVersions = (
+  versionsRoot = path.dirname(VERSION_ROOT),
+  active = path.basename(VERSION_ROOT),
+  keepCount = core.RUNTIME_VERSIONS_TO_KEEP
+) => core.pruneOldRuntimeVersions({ versionsRoot, active, keepCount });
+
+// logPrefix 必填就是那次事故的正解：漏传时在入口报「缺少 logPrefix」，
+// 而不是等到真的删掉了旧版本、走到打印那一行才崩掉整个启动。
+// 这里刻意不传 log：内核的默认值是在每次调用时取 console.error，
+// 测试替换 console.error 才能截到这行日志。
+const reportPrunedRuntimeVersions = (
+  versionsRoot = path.dirname(VERSION_ROOT),
+  active = path.basename(VERSION_ROOT),
+  keepCount = core.RUNTIME_VERSIONS_TO_KEEP
+) => core.reportPrunedRuntimeVersions({ versionsRoot, active, keepCount, logPrefix: SKILL_ID });
+
+const ensureInstalled = (target) =>
+  core.ensureRuntimeInstalled({
+    target,
+    runtimeVersion: RUNTIME_VERSION,
+    versionRoot: VERSION_ROOT,
+    binDir: BIN_DIR,
+    tempDirPrefix: `${SKILL_ID}-install-`,
+    logPrefix: SKILL_ID,
+    downloadRelease: downloadVerifiedRelease
+  });
 
-function findRegistryEntry(data, skillDir) {
-  const target = normalizePath(skillDir);
-  return data.skills?.find(
-    (entry) => entry.installPath && normalizePath(entry.installPath) === target
-  );
-}
+// 桥的 import 由这里注入，内核因此不静态依赖任何第三方包。
+const ensureSharedBridge = () =>
+  core.ensureSharedBridge({
+    importBridge: () => import('@yixinkj/yixin-bridge-cli'),
+    minVersion: registry.bridge.minVersion,
+    requiredCapabilities: registry.bridge.requiredCapabilities || []
+  });
 
-function registryUpdatePreview(skillPath, metadata) {
-  const skillDir = path.dirname(skillPath);
-  const registryPath = path.join(skillDir, '..', 'skills.jsonc');
-  if (!fs.existsSync(registryPath)) {
-    return { registryPath: null, currentVersion: null, changed: false, content: null };
-  }
-  const data = readSkillsRegistry(registryPath);
-  const entry = findRegistryEntry(data, skillDir);
-  if (!entry) {
-    throw new Error(`skills.jsonc 未找到 installPath 对应项：${skillDir}`);
-  }
-  const before = JSON.stringify(entry);
-  const currentVersion = entry.version || null;
-  entry.name = metadata.name;
-  entry.description = metadata.description;
-  entry.version = SKILL_VERSION;
-  return {
-    registryPath,
-    currentVersion,
-    changed: before !== JSON.stringify(entry),
-    content: `${JSON.stringify(data, null, 2)}\n`
-  };
-}
+const emitBrowserExtensionNotice = (sharedBridge) =>
+  core.emitBrowserExtensionNotice(sharedBridge, { logPrefix: SKILL_ID });
 
-function snapshotFile(filePath) {
-  return fs.existsSync(filePath)
-    ? { exists: true, content: fs.readFileSync(filePath) }
-    : { exists: false, content: null };
-}
+// 识别特征（包名出现在正文里，或 frontmatter 的 name 就是内部 ID）属于本仓。
+const discoverLegacySkillPaths = (homeDir = os.homedir()) =>
+  core.discoverLegacySkillPaths({
+    homeDir,
+    matches: (content) =>
+      content.includes(`@yixinkj/${SKILL_ID}-cli`) ||
+      new RegExp(`^name:\\s*${SKILL_ID}\\s*$`, 'm').test(content)
+  });
 
-function restoreFile(filePath, snapshot) {
-  fs.mkdirSync(path.dirname(filePath), { recursive: true });
-  if (snapshot.exists) fs.writeFileSync(filePath, snapshot.content);
-  else fs.rmSync(filePath, { force: true });
-}
+// 'require_argument' 是本仓现有语义：没传 --skill-path 就永远不放行，并在结论里点名参数和路径。
+// 缺的是参数，不是同步；含糊的「请重新试一次」正好会诱导调用方原样重试——重试一万次也不会成功。
+// 内核把这个参数设成必填、不给默认值，就是为了不让它在迁移里被顺手改成另外两仓的
+// 'restart_required'（那会连带改掉退出协议）。
+const resolveSkillGate = (skillPath, { homeDir = os.homedir(), syncOptions = {} } = {}) =>
+  core.resolveSkillGate(skillPath, {
+    syncSkill: (found) => syncSkillInstallation(found, syncOptions),
+    discoverSkillPaths: () => discoverLegacySkillPaths(homeDir),
+    discoveredPathPolicy: 'require_argument'
+  });
 
-function readInstalledSkillVersion(skillDir, registryVersion) {
-  const markerPath = path.join(skillDir, SKILL_VERSION_MARKER);
-  try {
-    const marker = JSON.parse(fs.readFileSync(markerPath, 'utf8'));
-    return marker.version || registryVersion || null;
-  } catch {
-    return registryVersion || null;
-  }
-}
+/* ------------------------------------------------------------------ *
+ * 本仓自己的逻辑
+ * ------------------------------------------------------------------ */
 
 /**
  * 把 npm 包内置的 SKILL.md 同步到当前智能体实际使用的安装位置。
  * 本地版本更高时拒绝降级；任一校验失败时整体回滚，不留下半个新版 Skill。
+ *
+ * 这个函数没有被提取进共享内核：三个仓真正不同的地方就在这里——同步的产物不同
+ * （本仓只有 SKILL.md + 版本标记）、身份判定不同（本仓认展示名、内部 ID 和历史展示名白名单）、
+ * 版本来源不同。做成一个带三套插件点的通用函数只会变成隐式行为的温床。
+ * 内部真正共用且最危险的四块（路径校验、内置包校验、registry 预演/回读、可回滚事务）走内核。
  * @param {string} skillPath 本次实际读取的 SKILL.md 绝对路径。
  * @param {object} [options] 测试注入的内置文件路径。
  * @returns {object} 同步结论与版本信息。
  */
 function syncSkillInstallation(skillPath, { bundledSkillPath = BUNDLED_SKILL_PATH } = {}) {
-  const resolvedSkillPath = path.resolve(skillPath);
-  if (path.basename(resolvedSkillPath).toLowerCase() !== 'skill.md') {
-    throw new Error('--skill-path 必须指向 SKILL.md');
-  }
-  if (!fs.existsSync(resolvedSkillPath)) {
-    throw new Error(`SKILL.md 不存在：${resolvedSkillPath}`);
-  }
-  if (!fs.existsSync(bundledSkillPath)) {
-    throw new Error('npm 包缺少内置 SKILL.md，请重新安装当前版本');
-  }
-
-  const bundledSkill = fs.readFileSync(bundledSkillPath, 'utf8');
-  const bundledMetadata = parseSkillMetadata(bundledSkill);
-  if (!bundledMetadata.name || !bundledMetadata.description) {
-    throw new Error('内置 SKILL.md 缺少 name 或 description');
-  }
+  const resolvedSkillPath = core.resolveSkillMdPath(skillPath);
+  const { content: bundledSkill, metadata: bundledMetadata } = core.loadBundledSkill(bundledSkillPath);
+  // 内核只检查包自身完整性（文件在不在、name/description 有没有），身份判定留在本仓。
   if (bundledMetadata.name !== SKILL_DISPLAY_NAME) {
     throw new Error('内置 SKILL.md 名称不匹配');
   }
 
   const currentSkill = fs.readFileSync(resolvedSkillPath, 'utf8');
-  const currentSkillName = parseSkillMetadata(currentSkill).name;
+  const currentSkillName = core.parseSkillMetadata(currentSkill).name;
   // 旧版 frontmatter 使用内部 ID 作为 name；允许它被新展示名平滑升级，避免 OTA 被自身名称校验挡住。
   if (
     currentSkillName !== SKILL_ID &&
@@ -310,9 +214,14 @@ function syncSkillInstallation(skillPath, { bundledSkillPath = BUNDLED_SKILL_PAT
   }
 
   const skillDir = path.dirname(resolvedSkillPath);
-  const registryPreview = registryUpdatePreview(resolvedSkillPath, bundledMetadata);
-  const currentVersion = readInstalledSkillVersion(skillDir, registryPreview.currentVersion);
-  if (compareVersions(currentVersion, SKILL_VERSION) > 0) {
+  const registryPreview = core.registryUpdatePreview(resolvedSkillPath, bundledMetadata, {
+    targetVersion: SKILL_VERSION
+  });
+  const currentVersion = core.readInstalledSkillVersion(skillDir, {
+    markerFileName: SKILL_VERSION_MARKER,
+    registryVersion: registryPreview.currentVersion
+  });
+  if (core.compareVersions(currentVersion, SKILL_VERSION) > 0) {
     return {
       action: 'local_newer',
       skillPath: resolvedSkillPath,
@@ -322,7 +231,8 @@ function syncSkillInstallation(skillPath, { bundledSkillPath = BUNDLED_SKILL_PAT
   }
 
   const markerPath = path.join(skillDir, SKILL_VERSION_MARKER);
-  const markerContent = `${JSON.stringify({ version: SKILL_VERSION }, null, 2)}\n`;
+  // 写入内容和比对内容必须来自同一个函数，否则「写时带换行、比时不带」会让每次启动都判定有变化。
+  const markerContent = core.versionMarkerContent(SKILL_VERSION);
   const skillChanged = Buffer.from(currentSkill).compare(Buffer.from(bundledSkill)) !== 0;
   const markerChanged =
     !fs.existsSync(markerPath) || fs.readFileSync(markerPath, 'utf8') !== markerContent;
@@ -337,44 +247,39 @@ function syncSkillInstallation(skillPath, { bundledSkillPath = BUNDLED_SKILL_PAT
     };
   }
 
-  const snapshots = new Map([
-    [resolvedSkillPath, snapshotFile(resolvedSkillPath)],
-    [markerPath, snapshotFile(markerPath)]
-  ]);
-  if (registryPreview.registryPath) {
-    snapshots.set(registryPreview.registryPath, snapshotFile(registryPreview.registryPath));
-  }
-  try {
-    if (skillChanged) fs.writeFileSync(resolvedSkillPath, bundledSkill);
-    if (markerChanged) fs.writeFileSync(markerPath, markerContent);
-    if (registryPreview.changed) {
-      fs.writeFileSync(registryPreview.registryPath, registryPreview.content);
-    }
-    const writtenMetadata = parseSkillMetadata(fs.readFileSync(resolvedSkillPath, 'utf8'));
-    if (writtenMetadata.name !== bundledMetadata.name) {
-      throw new Error('写入后的 SKILL.md 名称校验失败');
-    }
-    if (JSON.parse(fs.readFileSync(markerPath, 'utf8')).version !== SKILL_VERSION) {
-      throw new Error('写入后的 Skill 版本标记校验失败');
-    }
-    if (registryPreview.registryPath) {
-      const writtenEntry = findRegistryEntry(
-        readSkillsRegistry(registryPreview.registryPath),
-        skillDir
-      );
-      if (
-        !writtenEntry ||
-        writtenEntry.version !== SKILL_VERSION ||
-        writtenEntry.name !== bundledMetadata.name ||
-        writtenEntry.description !== bundledMetadata.description
-      ) {
-        throw new Error('写入后的 skills.jsonc 校验失败');
+  core.runWithRollback({
+    files: [
+      resolvedSkillPath,
+      markerPath,
+      ...(registryPreview.registryPath ? [registryPreview.registryPath] : [])
+    ],
+    apply: () => {
+      if (skillChanged) fs.writeFileSync(resolvedSkillPath, bundledSkill);
+      if (markerChanged) fs.writeFileSync(markerPath, markerContent);
+      if (registryPreview.changed) {
+        fs.writeFileSync(registryPreview.registryPath, registryPreview.content);
+      }
+    },
+    // 自检必须在事务内：校验失败同样要整体回滚，否则「校验」只是打印了一句话。
+    verify: () => {
+      const writtenMetadata = core.parseSkillMetadata(fs.readFileSync(resolvedSkillPath, 'utf8'));
+      if (writtenMetadata.name !== bundledMetadata.name) {
+        throw new Error('写入后的 SKILL.md 名称校验失败');
+      }
+      if (JSON.parse(fs.readFileSync(markerPath, 'utf8')).version !== SKILL_VERSION) {
+        throw new Error('写入后的 Skill 版本标记校验失败');
+      }
+      if (registryPreview.registryPath) {
+        core.assertRegistryEntryWritten({
+          registryPath: registryPreview.registryPath,
+          skillDir,
+          version: SKILL_VERSION,
+          name: bundledMetadata.name,
+          description: bundledMetadata.description
+        });
       }
     }
-  } catch (error) {
-    for (const [filePath, snapshot] of snapshots) restoreFile(filePath, snapshot);
-    throw error;
-  }
+  });
 
   return {
     action: skillChanged ? 'updated' : 'registry_updated',
@@ -385,542 +290,58 @@ function syncSkillInstallation(skillPath, { bundledSkillPath = BUNDLED_SKILL_PAT
   };
 }
 
-function discoverLegacySkillPaths(homeDir = os.homedir()) {
-  const accountsRoot = path.join(homeDir, '.accio', 'accounts');
-  if (!fs.existsSync(accountsRoot)) return [];
-  const candidates = [];
-  for (const account of fs.readdirSync(accountsRoot, { withFileTypes: true })) {
-    if (!account.isDirectory()) continue;
-    const agentsRoot = path.join(accountsRoot, account.name, 'agents');
-    if (!fs.existsSync(agentsRoot)) continue;
-    for (const agent of fs.readdirSync(agentsRoot, { withFileTypes: true })) {
-      if (!agent.isDirectory()) continue;
-      const registryPath = path.join(
-        agentsRoot,
-        agent.name,
-        'agent-core',
-        'skills',
-        'skills.jsonc'
-      );
-      if (!fs.existsSync(registryPath)) continue;
-      let data;
-      try {
-        data = readSkillsRegistry(registryPath);
-      } catch {
-        continue;
-      }
-      for (const entry of data.skills || []) {
-        if (!entry.installPath) continue;
-        const skillPath = path.join(entry.installPath, 'SKILL.md');
-        if (!fs.existsSync(skillPath)) continue;
-        let content;
-        try {
-          content = fs.readFileSync(skillPath, 'utf8');
-        } catch {
-          continue;
-        }
-        if (
-          content.includes(`@yixinkj/${SKILL_ID}-cli`) ||
-          new RegExp(`^name:\\s*${SKILL_ID}\\s*$`, 'm').test(content)
-        ) {
-          candidates.push(path.resolve(skillPath));
-        }
-      }
-    }
-  }
-  return [...new Set(candidates.map(normalizePath))];
-}
-
-function resolveSkillGate(skillPath, { homeDir = os.homedir(), syncOptions = {} } = {}) {
-  if (skillPath) {
-    const sync = syncSkillInstallation(skillPath, syncOptions);
-    return { allowRun: sync.action === 'current', sync };
-  }
-  const candidates = discoverLegacySkillPaths(homeDir);
-  if (candidates.length !== 1) {
-    return { allowRun: false, sync: { action: 'skill_path_required', candidates } };
-  }
-  const sync = syncSkillInstallation(candidates[0], syncOptions);
-  if (sync.action === 'local_newer') {
-    return { allowRun: false, sync };
-  }
-  // 走到这里说明调用方没传 --skill-path，是靠扫描猜出来的安装位置。这条路径永远不放行：
-  // 缺的是参数，不是同步。提示必须点名参数和路径，否则调用方只会原样重试——重试一万次
-  // 也不会成功，而含糊的「请重新试一次」正好会诱导它这么做。
-  return {
-    allowRun: false,
-    sync: { ...sync, action: 'skill_path_required', candidates, synced: sync.action !== 'current' }
-  };
-}
-
-function detectTarget() {
-  const platform = registry.platforms[`${process.platform}-${process.arch}`];
-  if (!platform) {
-    const supported = Object.values(registry.platforms)
-      .map((entry) => entry.id)
-      .join('、');
-    throw new Error(
-      `暂不支持当前平台：${process.platform}/${process.arch}。已支持：${supported}。`
-    );
-  }
-  return { ...platform, binaries: [`${registry.skill.bin}-${platform.id}${platform.exe || ''}`] };
-}
-
-/**
- * 生成业务运行时下载源，固定保持 OSS 主源优先、R2 备用源在后。
- * @returns {string[]} 已清理、去重并保持优先级的下载根地址。
- */
-function releaseBaseUrls() {
-  const primary = process.env.PRIORITY_BUYER_ALERT_RELEASE_BASE_URL || OSS_RELEASE_BASE_URL;
-  const fallbacks = process.env.PRIORITY_BUYER_ALERT_FALLBACK_BASE_URLS
-    ? process.env.PRIORITY_BUYER_ALERT_FALLBACK_BASE_URLS.split(',')
-    : process.env.PRIORITY_BUYER_ALERT_RELEASE_BASE_URL
-      ? []
-      : [R2_RELEASE_BASE_URL];
-  return [
-    ...new Set(
-      [primary, ...fallbacks]
-        .filter(Boolean)
-        .map((value) => String(value).trim().replace(/\/$/, ''))
-    )
-  ];
-}
-
-function releaseUrls(target) {
-  return releaseBaseUrls().map((baseUrl) => `${baseUrl}/${target.archive}`);
-}
-
-function runtimeManifestUrls() {
-  return releaseBaseUrls().map((baseUrl) => `${baseUrl}/runtime-manifest.json`);
-}
-
-function runtimeManifestUrl() {
-  return runtimeManifestUrls()[0];
-}
-
-function sha256(filePath) {
-  return crypto.createHash('sha256').update(fs.readFileSync(filePath)).digest('hex');
-}
-
-function isInstalled(target) {
-  try {
-    const marker = JSON.parse(fs.readFileSync(INSTALL_MARKER, 'utf8'));
-    return (
-      marker.version === RUNTIME_VERSION &&
-      marker.platform === target.id &&
-      target.binaries.every((name) => {
-        const expected = marker.files?.[name];
-        const filePath = path.join(BIN_DIR, name);
-        return (
-          expected &&
-          fs.existsSync(filePath) &&
-          fs.statSync(filePath).size === expected.size &&
-          sha256(filePath) === expected.sha256
-        );
-      })
-    );
-  } catch {
-    return false;
-  }
-}
-
-function download(url, outputPath, redirects = 5) {
-  return new Promise((resolve, reject) => {
-    const client = url.startsWith('http:') ? http : https;
-    const request = client.get(
-      url,
-      { headers: { 'User-Agent': `@yixinkj/${SKILL_ID}-cli` } },
-      (response) => {
-        if ([301, 302, 303, 307, 308].includes(response.statusCode)) {
-          response.resume();
-          if (!response.headers.location || redirects === 0) {
-            reject(new Error(`下载重定向过多：${url}`));
-            return;
-          }
-          download(
-            new URL(response.headers.location, url).toString(),
-            outputPath,
-            redirects - 1
-          ).then(resolve, reject);
-          return;
-        }
-        if (response.statusCode !== 200) {
-          response.resume();
-          reject(new Error(`下载失败：HTTP ${response.statusCode} ${url}`));
-          return;
-        }
-        const file = fs.createWriteStream(outputPath);
-        response.pipe(file);
-        response.on('aborted', () => {
-          file.destroy();
-          reject(new Error(`下载连接意外中断：${url}`));
-        });
-        response.on('error', (error) => file.destroy(error));
-        file.on('finish', () => file.close(resolve));
-        file.on('error', reject);
-      }
-    );
-    request.setTimeout(60000, () => request.destroy(new Error(`下载超时：${url}`)));
-    request.on('error', reject);
-  });
-}
-
-/**
- * 从同一个来源成对下载清单和压缩包，并在切换来源前完成版本、平台和 SHA256 校验。
- * 清单与文件必须同源处理，避免主源清单与备用源文件版本漂移时被错误组合。
- * @param {object} target 当前平台的归档名称和标识。
- * @param {string} releaseManifestPath 临时清单文件路径。
- * @param {string} archivePath 临时运行时归档路径。
- * @param {object} [options] 下载源和测试注入选项。
- * @returns {Promise<object>} 与归档同源且已通过校验的运行时清单。
- */
-async function downloadVerifiedRelease(
-  target,
-  releaseManifestPath,
-  archivePath,
-  { baseUrls = releaseBaseUrls(), downloadFile = download } = {}
-) {
-  const failures = [];
-  for (const baseUrl of baseUrls) {
-    const root = String(baseUrl).trim().replace(/\/$/, '');
-    try {
-      fs.rmSync(releaseManifestPath, { force: true });
-      fs.rmSync(archivePath, { force: true });
-      await downloadFile(`${root}/runtime-manifest.json`, releaseManifestPath);
-      const manifest = JSON.parse(fs.readFileSync(releaseManifestPath, 'utf8'));
-      await downloadFile(`${root}/${target.archive}`, archivePath);
-      verifyReleaseArchive(manifest, target, archivePath);
-      return manifest;
-    } catch (error) {
-      fs.rmSync(releaseManifestPath, { force: true });
-      fs.rmSync(archivePath, { force: true });
-      failures.push(`${root}: ${error.message}`);
-    }
-  }
-  throw new Error(`所有下载源均未通过运行时校验：\n${failures.join('\n')}`);
-}
-
-function verifyReleaseArchive(manifest, target, archivePath) {
-  if (
-    manifest?.schema !== RUNTIME_MANIFEST_SCHEMA ||
-    manifest.runtime_version !== RUNTIME_VERSION
-  ) {
-    throw new Error('公共运行时清单版本与当前启动器不一致');
-  }
-  const expected = manifest.platforms?.[target.id];
-  if (!expected || expected.archive !== target.archive) {
-    throw new Error(`公共运行时清单缺少平台 ${target.id}`);
-  }
-  const stat = fs.statSync(archivePath);
-  if (stat.size !== expected.size || sha256(archivePath) !== expected.sha256) {
-    throw new Error(`公共运行时压缩包校验失败：${target.archive}`);
-  }
-}
-
-function runCommand(command, args) {
-  const result = spawnSync(command, args, {
-    encoding: 'utf8',
-    stdio: ['ignore', 'pipe', 'pipe'],
-    windowsHide: true
-  });
-  if (result.error) throw result.error;
-  if (result.status !== 0) {
-    const detail = [result.stderr, result.stdout].filter(Boolean).join('\n').trim();
-    throw new Error(detail || `${command} 退出码为 ${result.status}`);
-  }
-}
-
-function extractArchive(archivePath, destination) {
-  fs.mkdirSync(destination, { recursive: true });
-  if (archivePath.endsWith('.tar.gz')) {
-    runCommand('tar', ['-xzf', archivePath, '-C', destination]);
-    return;
-  }
-  if (archivePath.endsWith('.zip')) {
-    if (process.platform === 'win32') {
-      runCommand('powershell.exe', [
-        '-NoProfile',
-        '-ExecutionPolicy',
-        'Bypass',
-        '-Command',
-        `Expand-Archive -LiteralPath ${JSON.stringify(archivePath)} -DestinationPath ${JSON.stringify(destination)} -Force`
-      ]);
-      return;
-    }
-    runCommand('unzip', ['-q', archivePath, '-d', destination]);
-    return;
-  }
-  throw new Error(`暂不支持的压缩包类型：${archivePath}`);
-}
-
-function verifyExtracted(extractedDir, target) {
-  const manifest = JSON.parse(
-    fs.readFileSync(path.join(extractedDir, 'checksums.json'), 'utf8')
-  );
-  if (manifest.version !== RUNTIME_VERSION || manifest.platform !== target.id) {
-    throw new Error('下载包版本或平台与当前启动器不一致');
-  }
-  for (const name of target.binaries) {
-    const expected = manifest.files?.[name];
-    const filePath = path.join(extractedDir, name);
-    if (
-      !expected ||
-      !fs.existsSync(filePath) ||
-      fs.statSync(filePath).size !== expected.size ||
-      sha256(filePath) !== expected.sha256
-    ) {
-      throw new Error(`下载包校验失败：${name}`);
-    }
-  }
-  return manifest.files;
-}
+/** 帮助文案是本仓的命令面，不进共享内核。 */
+function printHelp() {
+  process.stdout.write(`${SKILL_DISPLAY_NAME} ${SKILL_VERSION}（Runtime ${RUNTIME_VERSION}）
 
-function prepareMacBinaries(target) {
-  if (process.platform !== 'darwin') return;
-  for (const name of target.binaries) {
-    const filePath = path.join(BIN_DIR, name);
-    spawnSync('xattr', ['-dr', 'com.apple.quarantine', filePath], { stdio: 'ignore' });
-    runCommand('chmod', ['+x', filePath]);
-  }
-}
+用法：
+  ${SKILL_ID} --skill-path <SKILL.md> --start [扫描选项]
+  ${SKILL_ID} --skill-path <SKILL.md> --poll-run <RUN_ID>
+  ${SKILL_ID} --skill-path <SKILL.md> --run-status <RUN_ID>
+  ${SKILL_ID} --skill-path <SKILL.md> --cancel-run <RUN_ID>
+  ${SKILL_ID} --skill-path <SKILL.md> --first-response-scan [--since 24] [--limit 100]
 
-/// 同机保留的运行时版本数（含当前正在用的这一版）。
-///
-/// 每升一版就多留一份二进制，从来没人删。真机上 public-customer-reactivation 攒了 16 份
-/// 共 94M，三个 Skill 合计 164M，而任何时刻真正被执行的只有一份。
-/// 不设成 1 是因为同一台机器会交替跑不同 dist-tag（例如 latest 与 beta），
-/// 只留当前版会让每次切换都重新下载一遍。
-const RUNTIME_VERSIONS_TO_KEEP = 2;
+通用：
+  --skill-path <PATH>       本次实际读取的 SKILL.md 绝对路径
+  --version                 显示版本
+  --help                    显示本帮助
 
-/**
- * 清理旧版本运行时目录，按最近使用时间保留最新的若干份。
- *
- * 尽力而为：删不掉就算了，绝不因为清理失败影响本次运行。
- * @returns {string[]} 实际删掉的版本目录名。
- */
-function pruneOldRuntimeVersions(
-  versionsRoot = path.dirname(VERSION_ROOT),
-  active = path.basename(VERSION_ROOT),
-  keepCount = RUNTIME_VERSIONS_TO_KEEP
-) {
-  let entries;
-  try {
-    entries = fs.readdirSync(versionsRoot, { withFileTypes: true });
-  } catch {
-    return [];
-  }
-  // 先把当前版本的时间戳刷新成现在：保留依据是「最近用过」而不是「最近装的」，
-  // 否则交替使用两个版本时，先装的那个会被误判成最旧的。
-  try {
-    const now = new Date();
-    fs.utimesSync(path.join(versionsRoot, active), now, now);
-  } catch {
-    // 目录还没建好（首次安装前）就跳过，不影响后面的判断。
-  }
-  const ranked = entries
-    .filter((entry) => entry.isDirectory())
-    .map((entry) => entry.name)
-    // 排除 v<版本>.staging-<pid>：那可能是另一个进程正在写的半成品。
-    .filter((name) => /^v\d/.test(name) && !name.includes('.staging-'))
-    .map((name) => {
-      let usedAt = 0;
-      try {
-        usedAt = fs.statSync(path.join(versionsRoot, name)).mtimeMs;
-      } catch {
-        usedAt = 0;
-      }
-      return { name, usedAt };
-    })
-    .sort((a, b) => b.usedAt - a.usedAt);
+扫描选项（仅与 --start 一起使用）：
+  --minutes <N>             回复时限（SLA），默认 30
+  --lookback-hours <N>      只看最近 N 小时内有过消息的询盘，默认 24；0 表示不限
+  --max-pages <N>           翻页上限，每页 100 条，默认 3
+  --levels <LEVELS>         重点买家等级白名单，默认 L1+,L2,L3,L4  (阿里等级 L0-L4，L4 封顶)
+  --re-alert <N>            升级重提间隔；不给则只提醒一次
+  --assignee <NAME>         只看某个负责人
+  --no-strict-bot           关闭机器人核验
+  --verify-all-replied      对全部已回复的重点买家做详情核验
+  --mark                    推进提醒水位；只有心跳式调用才应使用
 
-  const keep = new Set(ranked.slice(0, keepCount).map((item) => item.name));
-  keep.add(active);
+首响扫描选项（仅与 --first-response-scan 一起使用）：
+  --since <HOURS>           只看最近 N 小时内有消息的询盘，默认 24
+  --limit <N>               本轮最多核验多少条会话详情，默认 100
 
-  const removed = [];
-  for (const { name } of ranked) {
-    if (keep.has(name)) continue;
-    try {
-      fs.rmSync(path.join(versionsRoot, name), { recursive: true, force: true });
-      removed.push(name);
-    } catch {
-      // 正被占用或权限不足都不是本次运行该处理的问题，留到下次。
-    }
-  }
-  return removed;
-}
+环境变量：
+  PRIORITY_BUYER_ALERT_DETAIL_CONCURRENCY   详情核验并发度，默认 3，范围 1-8
 
-/**
- * 每次启动都清理一次旧版本，并把删掉的版本写到 stderr。
- *
- * 放在「已安装」的快路径上也要跑：只在新装时清理的话，一台停止升级的机器会把
- * 历史版本永远留着。
- */
-function reportPrunedRuntimeVersions(...args) {
-  const removed = pruneOldRuntimeVersions(...args);
-  if (removed.length > 0) {
-    console.error(`[${SKILL_ID}] 已清理旧版本运行时：${removed.join('、')}`);
-  }
-  return removed;
+本 Skill 只读：只提醒，不发送消息、不修改任何页面状态。
+`);
 }
 
 /**
- * 把校验完毕的 staging 目录提交为当前版本运行时。
- *
- * 同一 Skill 的两个实例可能同时首次安装同一版本，各自下载到自己的 staging。
- * 版本目录按版本号钉死，内容又逐个核对过大小与 sha256，谁装出来的字节都一样，
- * 因此没有必要抢：对方已经装好就直接用他那份。
- *
- * 抢的代价是真的。原来的写法是无条件 `rmSync` 再 `renameSync`，会删掉对方刚
- * 装好、正准备执行的目录：POSIX 上对方若已 spawn 还能活下来，但两步之间那一瞬
- * 版本目录是不存在的；Windows 上更直接——删正在运行的 exe 会抛错，把这次启动
- * 整个带崩。
+ * 启动流程。
  *
- * @param {string} stagingRoot 已校验完毕、等待就位的临时目录。
- * @param {string} versionRoot 版本目录。
- * @param {() => boolean} isVersionReady 版本目录里是否已经是一份可用的同版本运行时。
- * @returns {'installed' | 'kept_existing'} 就位的是本进程这份还是别人那份。
- */
-function commitRuntimeInstall(stagingRoot, versionRoot, isVersionReady) {
-  if (isVersionReady()) return 'kept_existing';
-  fs.rmSync(versionRoot, { recursive: true, force: true });
-  try {
-    fs.renameSync(stagingRoot, versionRoot);
-  } catch (error) {
-    // 对方恰好在这两步之间把同版本装好了。抢输不该让本次启动失败。
-    if (!isVersionReady()) throw error;
-    return 'kept_existing';
-  }
-  return 'installed';
-}
-
-async function ensureInstalled(target) {
-  if (isInstalled(target)) {
-    prepareMacBinaries(target);
-    reportPrunedRuntimeVersions();
-    return;
-  }
-  const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), `${SKILL_ID}-install-`));
-  const archivePath = path.join(tempRoot, target.archive);
-  const releaseManifestPath = path.join(tempRoot, 'runtime-manifest.json');
-  const extractedDir = path.join(tempRoot, 'extracted');
-  const stagingRoot = `${VERSION_ROOT}.staging-${process.pid}`;
-  try {
-    await downloadVerifiedRelease(target, releaseManifestPath, archivePath);
-    extractArchive(archivePath, extractedDir);
-    const files = verifyExtracted(extractedDir, target);
-
-    fs.mkdirSync(path.dirname(VERSION_ROOT), { recursive: true });
-    fs.rmSync(stagingRoot, { recursive: true, force: true });
-    fs.mkdirSync(path.join(stagingRoot, 'bin'), { recursive: true });
-    for (const name of target.binaries) {
-      fs.copyFileSync(path.join(extractedDir, name), path.join(stagingRoot, 'bin', name));
-    }
-    fs.writeFileSync(
-      path.join(stagingRoot, 'installed.json'),
-      `${JSON.stringify({ version: RUNTIME_VERSION, platform: target.id, files }, null, 2)}\n`
-    );
-
-    commitRuntimeInstall(stagingRoot, VERSION_ROOT, () => isInstalled(target));
-    prepareMacBinaries(target);
-    reportPrunedRuntimeVersions();
-  } finally {
-    fs.rmSync(stagingRoot, { recursive: true, force: true });
-    fs.rmSync(tempRoot, { recursive: true, force: true });
-  }
-}
-
-async function ensureSharedBridge() {
-  let manager;
-  try {
-    manager = await import('@yixinkj/yixin-bridge-cli');
-  } catch (error) {
-    throw new Error(`缺少共享译心桥管理器 @yixinkj/yixin-bridge-cli：${error.message}`);
-  }
-  const result = await manager.ensureBridgeRuntime({ minVersion: registry.bridge.minVersion });
-  if (!result?.bridge_path || !fs.existsSync(result.bridge_path)) {
-    throw new Error('共享译心桥安装完成后未返回有效运行路径');
-  }
-  validateBridgeCapabilities(result, registry.bridge.requiredCapabilities || []);
-  return result;
-}
-
-/**
- * 校验当前共享桥是否具备本 Skill 的硬依赖能力。
- * @param {object} result 共享桥管理器返回的运行时信息。
- * @param {string[]} requiredCapabilities 本 Skill 声明的能力白名单。
- * @returns {object} 校验通过后的原始运行时信息。
+ * 这段也没有进共享内核：三个仓的退出协议不同（本仓在 skill_path_required 时置
+ * exitCode = 1，另外两仓直接 return），文案里的动作名也不同。把它模板化会让「改一句文案」
+ * 变成「改共享库」，更糟的是会悄悄统一退出码——退出码是调用方（智能体）的协议。
  */
-function validateBridgeCapabilities(result, requiredCapabilities) {
-  const missing = requiredCapabilities.filter(
-    (capability) => !result.capabilities?.includes(capability)
-  );
-  if (missing.length > 0) {
-    // 具体 Skill 只校验自己声明的能力，避免无关运行时能力成为全局硬依赖。
-    throw new Error(`共享译心桥缺少必要能力：${missing.join(', ')}`);
-  }
-  return result;
-}
-
-/**
- * 把共享管理器的底层插件状态转换为用户可理解的有限提示。
- * @param {object | null} sharedBridge 共享桥管理器返回的安装和插件状态。
- * @returns {object | null} 需要展示的提示结构；无需提示时返回空值。
- */
-function browserExtensionNotice(sharedBridge) {
-  if (!sharedBridge) return null;
-  const reloadStatus = sharedBridge.extension_reload?.status || 'not_requested';
-  const details = {
-    extension_version: sharedBridge.extension_version || null,
-    extension_path: sharedBridge.extension_path || null,
-    reload_status: reloadStatus
-  };
-  if (sharedBridge.extension_updated) {
-    return reloadStatus === 'reloaded'
-      ? {
-          ...details,
-          status: 'updated_reloaded',
-          message: `浏览器插件已更新至 ${details.extension_version || '最新版'}，并已自动重新加载。`
-        }
-      : {
-          ...details,
-          status: 'manual_reload_required',
-          message: `浏览器插件已更新至 ${details.extension_version || '最新版'}，但未能自动加载。请先删除 Chrome 扩展管理页中的旧译心插件，再按下方“浏览器插件本地路径”导入新版并重新加载。`
-        };
-  }
-  if (reloadStatus === 'active_tasks_present') {
-    return {
-      ...details,
-      status: 'update_deferred',
-      message: '检测到浏览器插件更新，但当前仍有采集任务，已暂缓更新。任务结束后请重新运行。'
-    };
-  }
-  if (reloadStatus === 'daemon_status_unavailable') {
-    return {
-      ...details,
-      status: 'update_deferred',
-      message: '检测到浏览器插件更新，但暂时无法确认浏览器任务状态，未自动替换。请稍后重新运行。'
-    };
-  }
-  return null;
-}
-
-function emitBrowserExtensionNotice(sharedBridge) {
-  const notice = browserExtensionNotice(sharedBridge);
-  if (!notice) return;
-  // 原生 CLI 的 stdout 是机器解析的 JSON，因此提示只能写 stderr。
-  console.error(`[${SKILL_ID}] ${notice.message}`);
-  if (notice.extension_path) {
-    console.error(`[${SKILL_ID}] 浏览器插件本地路径：${notice.extension_path}`);
-  }
-}
-
 async function main() {
   const rawArgs = process.argv.slice(2);
   if (isHelpRequest(rawArgs)) {
     printHelp();
     return;
   }
-  const { skillPath, forwardedArgs } = extractSkillPath(rawArgs);
+  const { skillPath, forwardedArgs } = core.extractSkillPath(rawArgs);
   if (forwardedArgs.length === 1 && ['--version', '-V', '-v'].includes(forwardedArgs[0])) {
     console.log(`${SKILL_ID} ${SKILL_VERSION} (runtime ${RUNTIME_VERSION})`);
     return;
@@ -1000,25 +421,24 @@ async function main() {
   process.exitCode = result.status ?? 1;
 }
 
-function isDirectExecution() {
-  if (!process.argv[1]) return false;
-  let invoked = path.resolve(process.argv[1]);
-  let current = fileURLToPath(import.meta.url);
-  try {
-    invoked = fs.realpathSync(invoked);
-    current = fs.realpathSync(current);
-  } catch {
-    // 某些文件系统无法解析符号链接时使用绝对路径比较。
-  }
-  return process.platform === 'win32'
-    ? invoked.toLowerCase() === current.toLowerCase()
-    : invoked === current;
-}
-
-if (isDirectExecution()) {
+// import.meta.url 必须由这里传：内核若用自己的 import.meta.url 去比，结果永远是 false，
+// 启动器会变成「导入即返回、什么都不做」，而且不报错，只会静默失效。
+if (core.isDirectExecution(import.meta.url)) {
   main().catch((error) => fail(error.message));
 }
 
+// 这几个与「我是谁」无关，内核版本逐字等价，直接转发即可，不必再包一层。
+// browserExtensionNotice 的默认「未能自动加载」文案就是本仓这版（先删旧插件、再按路径导入），
+// 内核把它当默认值，因此这里不需要传 manualReloadMessage。
+export {
+  browserExtensionNotice,
+  commitRuntimeInstall,
+  compareVersions,
+  extractSkillPath,
+  parseSkillMetadata,
+  validateBridgeCapabilities
+} from './launcher-core.js';
+
 export {
   BIN_DIR,
   BUNDLED_SKILL_PATH,
@@ -1027,16 +447,11 @@ export {
   SKILL_ROOT,
   SKILL_VERSION,
   VERSION_ROOT,
-  browserExtensionNotice,
-  commitRuntimeInstall,
-  compareVersions,
   detectTarget,
   discoverLegacySkillPaths,
   downloadVerifiedRelease,
-  extractSkillPath,
   isHelpRequest,
   isInstalled,
-  parseSkillMetadata,
   pruneOldRuntimeVersions,
   reportPrunedRuntimeVersions,
   releaseUrls,
@@ -1044,6 +459,5 @@ export {
   runtimeManifestUrl,
   runtimeManifestUrls,
   syncSkillInstallation,
-  validateBridgeCapabilities,
   verifyReleaseArchive
 };