@yixinkj/inquiry-opening-coach-cli 0.3.1

package/index.js

@@ -0,0 +1,528 @@
+#!/usr/bin/env node
+
+import fs from 'node:fs';
+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.js 是副本，唯一源在 priority-buyer-alert。
+// **禁止在本仓就地修改它**：launcher-core-integrity.test.js 用 sha256 守着，
+// prepack 也会中止发布。要改就回源仓改，让内核的 58 条测试先过一遍。
+//
+// 它必须出现在 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');
+
+const VERSION = packageJson.version;
+const SKILL_VERSION = registry.skill.version || VERSION;
+const SKILL_ID = registry.skill.id;
+// 本 Skill 的 frontmatter name 就是目录名 create-inquiry-openers，与内部 ID 不同。
+// 本仓没有改过展示名，因此不需要 priority-buyer-alert 那张历史展示名白名单——
+// 那张表属于那个 Skill 自己的改名历史，照抄过来只会凭空放宽身份校验。
+const SKILL_DISPLAY_NAME = registry.skill.name;
+const RUNTIME_VERSION = registry.runtimeVersion || VERSION;
+const OSS_RELEASE_BASE_URL =
+  `https://broswer-plugs1.oss-cn-beijing.aliyuncs.com/releases/${SKILL_ID}/v${RUNTIME_VERSION}`;
+const R2_RELEASE_BASE_URL =
+  `https://pub-60851fbb424a46c9a15b0ffce2ffea86.r2.dev/releases/${SKILL_ID}/v${RUNTIME_VERSION}`;
+// 与 tools/release/write_release_manifest.mjs 写进清单的 schema 逐字一致。
+// 它是本 Skill 自己的字符串：多个 Skill 的产物放在同一个桶里，只比版本号会让
+// 「下错 Skill 的包」一路通过校验。
+const RUNTIME_MANIFEST_SCHEMA = 'inquiry_opening_coach_runtime_manifest_v1';
+const PACKAGE_ROOT = path.dirname(fileURLToPath(import.meta.url));
+// 已发布的包里 `skill/` 由 prepack 的 sync-skill-assets.mjs 整份生成；直接在源码仓库里
+// 跑 index.js 时它不存在，此时回退到仓库内的 Skill 源目录，避免联调必须先手工同步一次。
+// 发布产物中不存在仓库路径，因此这个回退不会让线上包读到仓库副本。
+const PACKED_SKILL_PATH = path.join(PACKAGE_ROOT, 'skill', 'SKILL.md');
+const REPOSITORY_SKILL_PATH = path.join(
+  PACKAGE_ROOT,
+  '..',
+  '..',
+  'skills',
+  'create-inquiry-openers',
+  'SKILL.md'
+);
+const BUNDLED_SKILL_PATH = fs.existsSync(PACKED_SKILL_PATH)
+  ? PACKED_SKILL_PATH
+  : REPOSITORY_SKILL_PATH;
+const SKILL_VERSION_MARKER = `.${SKILL_ID}-version.json`;
+// 注意：SKILL_ROOT 下面除了 runtime/ 还住着用户的记忆库（banks/、config.json）。
+// 那是用户从 0.2 起累积的资料，任何发布都不许动它——本文件只写 runtime/ 这一层。
+const SKILL_ROOT = path.join(os.homedir(), '.yixin', SKILL_ID);
+const RUNTIME_ROOT = path.join(SKILL_ROOT, 'runtime');
+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');
+
+/* ------------------------------------------------------------------ *
+ * 绑定层
+ *
+ * 这一层只做一件事：把上面那批「我是谁」的常量补给共享内核。里面不允许有判断逻辑，
+ * 有判断的部分（身份校验、退出协议、帮助文案）一律留在下面的本仓代码里。
+ * ------------------------------------------------------------------ */
+
+const fail = core.createFailHandler({ logPrefix: SKILL_ID });
+
+const emitStatus = core.createStatusEmitter({ skillVersion: SKILL_VERSION });
+
+// 本仓把「不带任何参数」当作帮助请求。理由：这个 CLI 是子命令式的（retain / recall /
+// fetch / validate …），没有任何可用的默认动作，裸调一次的唯一合理产物就是命令面。
+// 而帮助必须在 Skill OTA 和运行时下载之前返回——若判成「不是帮助」，裸调会先跑一遍
+// Skill 发现、再下载几十兆运行时，最后只为让 clap 打印一句 usage 错误。
+// 这个值必须显式写出来：public-customer-reactivation 的答案是相反的，内核因此不给默认值。
+const isHelpRequest = (args) => core.isHelpRequest(args, { emptyArgsMeansHelp: true });
+
+// 环境变量的**名字**属于本仓身份，留在这里；「显式覆盖主源就不追加默认备用源」那条规则在内核里。
+// 前缀 INQUIRY_OPENING_COACH_ 与 Rust 侧一致（src/store/storage.rs 的
+// INQUIRY_OPENING_COACH_DATA_DIR）。必须在函数内部读 process.env：模块加载时读会让
+// 测试和联调无法在运行中改源。
+const releaseBaseUrls = () =>
+  core.resolveReleaseBaseUrls({
+    defaultPrimary: OSS_RELEASE_BASE_URL,
+    defaultFallbacks: [R2_RELEASE_BASE_URL],
+    overridePrimary: process.env.INQUIRY_OPENING_COACH_RELEASE_BASE_URL,
+    overrideFallbacks: process.env.INQUIRY_OPENING_COACH_FALLBACK_BASE_URLS
+  });
+
+const releaseUrls = (target) => core.releaseUrls(releaseBaseUrls(), target);
+
+const runtimeManifestUrls = () => core.runtimeManifestUrls(releaseBaseUrls());
+
+const runtimeManifestUrl = () => runtimeManifestUrls()[0];
+
+const verifyReleaseArchive = (manifest, target, archivePath) =>
+  core.verifyReleaseArchive(manifest, target, archivePath, {
+    manifestSchema: RUNTIME_MANIFEST_SCHEMA,
+    runtimeVersion: RUNTIME_VERSION
+  });
+
+// 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
+  });
+
+// registry.skill.bin 是 inquiry-opening-coach-cli（Cargo 的 [[bin]] name），
+// 与 SKILL_ID 差一个 -cli 后缀，不能互相顶替：内核会拼成
+// `${bin}-${平台id}${exe}`，正是 build_local.sh 放进压缩包的那个文件名。
+const detectTarget = () =>
+  core.detectTarget({ platforms: registry.platforms, binName: registry.skill.bin });
+
+const isInstalled = (target) =>
+  core.isRuntimeInstalled({
+    target,
+    binDir: BIN_DIR,
+    installMarkerPath: INSTALL_MARKER,
+    runtimeVersion: RUNTIME_VERSION
+  });
+
+// 位置参数原样保留，index.test.js 里 `pruneOldRuntimeVersions(root, 'v0.0.3', 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
+  });
+
+// 桥的 import 由这里注入，内核因此不静态依赖任何第三方包。
+//
+// requiredCapabilities 取本仓 skills.json 的声明，当前是空的，且**必须**是空的：
+// runtime-dependencies.json 里写清楚了理由——本 Skill 只在询盘详情页读 DOM 并在页面
+// 上下文内发一次同源 POST，不做 frame 定位、不截图、不复用调试会话。从别的仓照抄一份
+// 非空清单（例如 frame_url_v1）会在插件升级改名或合并能力时变成假硬依赖，
+// 把本来能跑的 Skill 直接挡在门外。任务协议底线由 yixin-browser 的 ensure_ready 自己强制。
+const ensureSharedBridge = () =>
+  core.ensureSharedBridge({
+    importBridge: () => import('@yixinkj/yixin-bridge-cli'),
+    minVersion: registry.bridge.minVersion,
+    requiredCapabilities: registry.bridge.requiredCapabilities || []
+  });
+
+const emitBrowserExtensionNotice = (sharedBridge) =>
+  core.emitBrowserExtensionNotice(sharedBridge, { logPrefix: SKILL_ID });
+
+// 识别特征属于本仓：npm 包名出现在正文里（SKILL.md 的运行入口就是 npx 那一行），
+// 或 frontmatter 的 name 正是本 Skill 的目录名。
+const discoverLegacySkillPaths = (homeDir = os.homedir()) =>
+  core.discoverLegacySkillPaths({
+    homeDir,
+    matches: (content) =>
+      content.includes(`@yixinkj/${SKILL_ID}-cli`) ||
+      new RegExp(`^name:\\s*${SKILL_DISPLAY_NAME}\\s*$`, 'm').test(content)
+  });
+
+// 'require_argument'：没传 --skill-path 就永远不放行，并在结论里点名参数和具体路径。
+//
+// 本 Skill 是第四个接线的仓，此前从没有过 npm 启动器（旧形态是 Codex 插件直接调
+// bin/ 下的二进制），**因此不存在需要保持兼容的历史退出协议**——另外两仓保留
+// 'restart_required' 只是为了不在迁移里顺手改掉既有行为，本仓没有这个包袱，
+// 直接取正确的那个语义。
+//
+// 而且本 Skill 一轮对话里要调十几次 CLI（fetch → recall → validate → retain …）。
+// 'restart_required' 给出的是含糊的「已更新，请重新试一次」，可缺的明明是参数不是同步，
+// 正好会诱导调用方原样重跑——重试一万次也不会成功，而且是每条命令都重试一遍。
+const resolveSkillGate = (skillPath, { homeDir = os.homedir(), syncOptions = {} } = {}) =>
+  core.resolveSkillGate(skillPath, {
+    syncSkill: (found) => syncSkillInstallation(found, syncOptions),
+    discoverSkillPaths: () => discoverLegacySkillPaths(homeDir),
+    discoveredPathPolicy: 'require_argument'
+  });
+
+/* ------------------------------------------------------------------ *
+ * 本仓自己的逻辑
+ * ------------------------------------------------------------------ */
+
+/**
+ * 列出内置 Skill 目录里除 SKILL.md 之外要整棵同步的资源目录。
+ *
+ * 按目录扫描而不是按文件名列举：本 Skill 的 `references/country-styles.md` 和
+ * `references/opening-rules.md` 是开场白的核心依据，`agents/openai.yaml` 是宿主适配。
+ * 写死清单的话，以后新增一份参考文件不会有任何报错——SKILL.md 照样能跑，只是文案
+ * 没了依据，输出慢慢变差，这种失效最难被发现。scripts/sync-skill-assets.mjs 出于同样
+ * 的理由复制整棵目录，两边保持一致。
+ * @param {string} bundledSkillRoot 内置 SKILL.md 所在目录。
+ * @returns {string[]} 排序后的一级子目录名。
+ */
+function bundledAssetDirNames(bundledSkillRoot) {
+  return fs
+    .readdirSync(bundledSkillRoot, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => entry.name)
+    .sort();
+}
+
+/**
+ * 把 npm 包内置的 Skill 同步到当前智能体实际使用的安装位置。
+ * 本地版本更高时拒绝降级；任一校验失败时整体回滚，不留下半个新版 Skill。
+ *
+ * 这个函数没有被提取进共享内核：四个仓真正不同的地方就在这里——同步的产物不同、
+ * 身份判定不同、版本来源不同。做成一个带三套插件点的通用函数只会变成隐式行为的温床。
+ * 内部真正共用且最危险的四块（路径校验、内置包校验、registry 预演/回读、可回滚事务）走内核。
+ *
+ * 本仓与 priority-buyer-alert 的实质差别：**除 SKILL.md 外还要整棵同步 references/ 和
+ * agents/**。只换 SKILL.md 会得到「新版说明 + 旧版参考文件」的组合，既不报错也不对。
+ * 因此这里用内核的 trees 参数做整棵回滚——只还原被改动的文件会把新版新增的文件留在原地。
+ * @param {string} skillPath 本次实际读取的 SKILL.md 绝对路径。
+ * @param {object} [options] 测试注入的内置文件路径。
+ * @returns {object} 同步结论与版本信息。
+ */
+function syncSkillInstallation(skillPath, { bundledSkillPath = BUNDLED_SKILL_PATH } = {}) {
+  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 = core.parseSkillMetadata(currentSkill).name;
+  // 也认内部 ID：早期安装副本的 frontmatter 可能写的是 inquiry-opening-coach，
+  // 允许它被目录名平滑升级，避免 OTA 被自身名称校验永久挡住。
+  if (currentSkillName !== SKILL_ID && currentSkillName !== SKILL_DISPLAY_NAME) {
+    throw new Error(`--skill-path 指向的不是${SKILL_DISPLAY_NAME} Skill，已拒绝覆盖`);
+  }
+
+  const skillDir = path.dirname(resolvedSkillPath);
+  const bundledSkillRoot = path.dirname(path.resolve(bundledSkillPath));
+  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,
+      currentVersion,
+      targetVersion: SKILL_VERSION
+    };
+  }
+
+  const markerPath = path.join(skillDir, SKILL_VERSION_MARKER);
+  // 写入内容和比对内容必须来自同一个函数，否则「写时带换行、比时不带」会让每次启动都判定有变化。
+  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;
+  // 摘要相同就不动那棵树：每次启动都重写一遍资源目录会把 mtime 刷成现在，
+  // 也会让「这次到底改了什么」无从判断。
+  const changedAssets = bundledAssetDirNames(bundledSkillRoot)
+    .map((name) => ({
+      name,
+      source: path.join(bundledSkillRoot, name),
+      target: path.join(skillDir, name)
+    }))
+    .filter((asset) => core.treeDigest(asset.target) !== core.treeDigest(asset.source));
+
+  if (!skillChanged && !markerChanged && !registryPreview.changed && changedAssets.length === 0) {
+    return {
+      action: 'current',
+      skillPath: resolvedSkillPath,
+      currentVersion,
+      targetVersion: SKILL_VERSION,
+      registryPath: registryPreview.registryPath
+    };
+  }
+
+  core.runWithRollback({
+    files: [
+      resolvedSkillPath,
+      markerPath,
+      ...(registryPreview.registryPath ? [registryPreview.registryPath] : [])
+    ],
+    trees: changedAssets.map((asset) => asset.target),
+    apply: () => {
+      if (skillChanged) fs.writeFileSync(resolvedSkillPath, bundledSkill);
+      if (markerChanged) fs.writeFileSync(markerPath, markerContent);
+      for (const asset of changedAssets) {
+        // restoreTree 先整棵删再按快照写回，正好等于「用内置那棵覆盖安装位置那棵」。
+        core.restoreTree(asset.target, core.snapshotTree(asset.source));
+      }
+      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 版本标记校验失败');
+      }
+      for (const asset of changedAssets) {
+        if (core.treeDigest(asset.target) !== core.treeDigest(asset.source)) {
+          throw new Error(`写入后的 Skill 资源目录校验失败：${asset.name}`);
+        }
+      }
+      if (registryPreview.registryPath) {
+        core.assertRegistryEntryWritten({
+          registryPath: registryPreview.registryPath,
+          skillDir,
+          version: SKILL_VERSION,
+          name: bundledMetadata.name,
+          description: bundledMetadata.description
+        });
+      }
+    }
+  });
+
+  return {
+    action: skillChanged || changedAssets.length > 0 ? 'updated' : 'registry_updated',
+    skillPath: resolvedSkillPath,
+    currentVersion,
+    targetVersion: SKILL_VERSION,
+    syncedAssets: changedAssets.map((asset) => asset.name),
+    registryPath: registryPreview.registryPath
+  };
+}
+
+/** 帮助文案是本仓的命令面，不进共享内核。 */
+function printHelp() {
+  process.stdout.write(`${SKILL_DISPLAY_NAME} ${SKILL_VERSION}（Runtime ${RUNTIME_VERSION}）
+
+用法：
+  npx -y @yixinkj/${SKILL_ID}-cli@latest --skill-path <SKILL.md> <子命令> [选项]
+
+通用：
+  --skill-path <PATH>       本次实际读取的 SKILL.md 绝对路径（每条命令都要带）
+  --version                 显示版本
+  --help                    显示本帮助
+
+子命令：
+  fetch --detail-url <URL>  从询盘详情页只读抓取买家国家、需求卡片和买家原话
+                            可加 --from-scan <FILE> 接住哨兵已取到的卡片，省掉一次开页
+  recall                    召回档案、行为约束与长期记忆（--country/--product/--query/--budget）
+  validate --file <FILE>    校验三套开场白并渲染 Markdown（--inquiry-id 用于记账，勿省）
+  retain                    写入一条记忆（--type fact|experience|directive|model，--source 必填）
+  outcome --id <ID>         为一条经验补记真实结果，使其可作为归纳证据
+  reflect                   列出已有结果、尚未归纳的经验
+  memory list|get|update    查看与修改已有记忆
+  forget --id <ID>          永久删除一条记忆
+  profile show|save         读取或保存业务档案
+  bank list|create|use      管理记忆库分区（任意命令可用 --bank 临时指定）
+  self-check                本地结构与运行时自检
+
+环境变量：
+  INQUIRY_OPENING_COACH_DATA_DIR   记忆库数据目录，默认 ~/.yixin/${SKILL_ID}/
+
+本 Skill 抓取端只读：只读取询盘详情页，不发送任何消息、不修改任何页面状态。
+`);
+}
+
+/**
+ * 启动流程。
+ *
+ * 这段也没有进共享内核：四个仓的退出协议不同，文案里的动作名也不同。把它模板化会让
+ * 「改一句文案」变成「改共享库」，更糟的是会悄悄统一退出码——退出码是调用方（智能体）的协议。
+ */
+async function main() {
+  const rawArgs = process.argv.slice(2);
+  if (isHelpRequest(rawArgs)) {
+    printHelp();
+    return;
+  }
+  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;
+  }
+
+  console.error(`[${SKILL_ID}] ${SKILL_DISPLAY_NAME} ${SKILL_VERSION}`);
+  const gate = resolveSkillGate(skillPath);
+  if (!gate.allowRun) {
+    if (gate.sync.action === 'local_newer') {
+      emitStatus(
+        'skill_version_conflict',
+        `当前 Skill 版本 ${gate.sync.currentVersion} 高于 npm 版本 ${SKILL_VERSION}，已停止运行，未执行降级。`,
+        { skill_path: gate.sync.skillPath }
+      );
+      process.exitCode = 1;
+      return;
+    }
+    if (gate.sync.action === 'skill_path_required') {
+      const found = gate.sync.skillPath;
+      emitStatus(
+        'skill_path_required',
+        found
+          ? `缺少 --skill-path，本次未执行。${gate.sync.synced ? `已同步 Skill 到 ${SKILL_VERSION}；` : ''}请带上参数重新运行：--skill-path "${found}"`
+          : '无法唯一确定当前智能体的 SKILL.md。请使用本次读取的 SKILL.md 绝对路径重新运行；本次未执行任何命令。',
+        {
+          skill_path: found || null,
+          candidates: gate.sync.candidates,
+          required_argument: '--skill-path'
+        }
+      );
+      process.exitCode = 1;
+      return;
+    }
+    emitStatus(
+      'skill_updated',
+      `${SKILL_DISPLAY_NAME}已更新至 ${SKILL_VERSION}。请重新试一次，本次不执行任何命令。`,
+      {
+        skill_path: gate.sync.skillPath,
+        previous_version: gate.sync.currentVersion || null,
+        synced_assets: gate.sync.syncedAssets || [],
+        skills_registry: gate.sync.registryPath || null,
+        restart_required: true
+      }
+    );
+    return;
+  }
+
+  const runtimeOverride = process.env.INQUIRY_OPENING_COACH_RUNTIME_BINARY;
+  if (runtimeOverride) {
+    const binary = path.resolve(runtimeOverride);
+    if (!fs.existsSync(binary)) throw new Error(`开发运行时不存在：${binary}`);
+    const result = spawnSync(binary, forwardedArgs, {
+      stdio: 'inherit',
+      windowsHide: true,
+      env: process.env
+    });
+    if (result.error) throw result.error;
+    process.exitCode = result.status ?? 1;
+    return;
+  }
+
+  const target = detectTarget();
+  const [sharedBridge] = await Promise.all([ensureSharedBridge(), ensureInstalled(target)]);
+  emitBrowserExtensionNotice(sharedBridge);
+  const result = spawnSync(path.join(BIN_DIR, target.binaries[0]), forwardedArgs, {
+    stdio: 'inherit',
+    windowsHide: true,
+    // 运行时在插件过旧时也要返回同一个目录，模型才能给出可执行的导入指引。
+    env: {
+      ...process.env,
+      YIXIN_BRIDGE_BIN: sharedBridge.bridge_path,
+      ...(sharedBridge.extension_path
+        ? { YIXIN_EXTENSION_PATH: sharedBridge.extension_path }
+        : {})
+    }
+  });
+  if (result.error) throw result.error;
+  process.exitCode = result.status ?? 1;
+}
+
+// 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,
+  treeDigest,
+  validateBridgeCapabilities
+} from './launcher-core.js';
+
+export {
+  BIN_DIR,
+  BUNDLED_SKILL_PATH,
+  RUNTIME_VERSION,
+  RUNTIME_ROOT,
+  SKILL_DISPLAY_NAME,
+  SKILL_ID,
+  SKILL_ROOT,
+  SKILL_VERSION,
+  VERSION_ROOT,
+  detectTarget,
+  discoverLegacySkillPaths,
+  downloadVerifiedRelease,
+  isHelpRequest,
+  isInstalled,
+  pruneOldRuntimeVersions,
+  reportPrunedRuntimeVersions,
+  releaseUrls,
+  resolveSkillGate,
+  runtimeManifestUrl,
+  runtimeManifestUrls,
+  syncSkillInstallation,
+  verifyReleaseArchive
+};