@pab-iprg/huohuo 1.0.0-preview.3 → 1.0.0-preview.5

package/README.md

@@ -1,12 +1,12 @@
-# 火火安装入口
+# 火火轻量入口（本地开发候选）
 
-入口在设备预检后安装 DSH 和火火运行环境。npm 预览包内置火火运行文件，Python 运行时和依赖从固定上游地址获取并校验摘要。
+此目录是 `@pab-iprg/huohuo` 的私有构建模板。入口代码只使用 Node 内置模块；npm 按 OS/CPU 选择同版本的静态资源包，资源包不含安装脚本。设备预检前只准备入口和对应平台的压缩资源，不安装 DSH 或 Python。源码具备某个平台的选择逻辑，不代表该平台已完成实机验收。
 
-构建时需要已完成平台测量与摘要绑定的 `release.json`。没有发行清单时入口明确停止，不从不可信页面选择资源，也不使用虚构的最低配置。
+构建时需要已完成平台测量与摘要绑定的 `release.json`，可以是旧版单平台清单，也可以是包含多个同版本发行的索引。首次安装与显式升级只选择本机系统/CPU 对应的发行，再按需下载运行包、独立 Python 和固定 wheels；其他平台的大包不下载。Linux 索引条目目前只接受 glibc，未收录的平台提前提示。没有完整发行清单时明确停止。
 
-发布后的预览入口为 `npx --yes @pab-iprg/huohuo@next`。首版验收基线为 macOS Apple Silicon、Node 24.8.0 和 npm 11.6.0。默认持久目录为 `~/.huohuo`，普通重开保留已安装版本，安装中断后继续原目标。
+运行 npx 前仍需安装兼容的 Node/npm（当前入口要求 Node 24.8+，具体 Node 主版本由所选发行固定）。运行环境在用户目录中准备，不替换系统 Python；已校验的下载缓存会复用。Python 和 wheels 在构建端选定版本及 SHA；npm 预览包携带下载清单和构建好的 jsonpath wheel，其余 wheel 按固定上游 URL 下载并校验，不在用户机器编译。仍兼容旧的完整离线 wheel 包；npm 依赖按运行包锁文件安装。
 
-命令支持 `huohuo [start|doctor|stop|upgrade|uninstall] [--home 目录] [--no-open]`。
+当前开发入口：`huohuo [start|status|doctor|stop|upgrade|uninstall] [--home 目录] [--no-open]`。`status --watch` 持续显示进度；安装前展示资源计划，`--yes` 可显式确认。默认持久目录 `~/.huohuo`；普通重开保留已安装版本，安装中断继续原目标。npx 缓存保存入口和所选平台资源；再次解析最新入口可能联网。
 
 显式升级检查旧迁移不可变、追加迁移顺序、执行库格式与 DSH 会话兼容范围，先一致性备份再迁移和验证，成功后切换；不自动恢复旧备份覆盖新数据。默认卸载保留实例、凭据、会话和备份，不提供直接彻底删除业务数据的快捷入口。
 

package/cli.js

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
 
 // distribution/bootstrap/entry.ts
-import { open as open3, readFile as readFile7, realpath as realpath5 } from "node:fs/promises";
+import { open as open3, readFile as readFile9, realpath as realpath5 } from "node:fs/promises";
 import { Readable } from "node:stream";
-import { homedir } from "node:os";
-import { dirname as dirname5, join as join6, resolve as resolve5 } from "node:path";
-import { fileURLToPath } from "node:url";
+import { homedir as homedir2 } from "node:os";
+import { dirname as dirname6, join as join8, resolve as resolve5 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // distribution/bootstrap/install.ts
 import { readFile as readFile4, mkdir as mkdir3, access, rename as rename3, rm as rm2, realpath as realpath3, readdir } from "node:fs/promises";
@@ -132,20 +132,24 @@ var hash = /^[a-f0-9]{64}$/;
 function integer(n) {
   return Number.isSafeInteger(n) && Number(n) >= 0;
 }
-function artifact(a) {
-  if (!a || !hash.test(a.sha256) || !integer(a.downloadBytes) || !integer(a.expandedBytes) || !a.downloadBytes || !a.expandedBytes) return false;
-  if (a.redirectHosts !== void 0 && (!Array.isArray(a.redirectHosts) || a.redirectHosts.length > 4 || !a.redirectHosts.every((s) => typeof s === "string" && /^[a-z0-9.-]+$/.test(s)))) return false;
-  if (a.bundled !== void 0) return a.bundled === true && a.url === `https://bundled.invalid/${a.sha256}.tgz` && a.redirectHosts === void 0;
+function httpsURL(value) {
+  if (typeof value !== "string") return false;
   try {
-    const u = new URL(a.url);
+    const u = new URL(value);
     return u.protocol === "https:" && !u.username && !u.password && !u.hash;
   } catch {
     return false;
   }
 }
+function artifact(a) {
+  if (!a || !hash.test(a.sha256) || !integer(a.downloadBytes) || !integer(a.expandedBytes) || !a.downloadBytes || !a.expandedBytes) return false;
+  if (a.redirectHosts !== void 0 && (!Array.isArray(a.redirectHosts) || a.redirectHosts.length > 4 || !a.redirectHosts.every((s) => typeof s === "string" && /^[a-z0-9.-]+$/.test(s)))) return false;
+  if (a.bundled !== void 0) return a.bundled === true && a.url === `https://bundled.invalid/${a.sha256}.tgz` && a.redirectHosts === void 0 && a.mirrors === void 0;
+  return httpsURL(a.url) && (a.mirrors === void 0 || Array.isArray(a.mirrors) && a.mirrors.length <= 3 && a.mirrors.every(httpsURL));
+}
 function validateRelease(input) {
   const r = input;
-  if (!r || r.format !== 1 || r.bootstrapFormat !== 1 || !version.test(r.version) || !integer(r.nodeMajor) || r.nodeMajor < 24 || !integer(r.npmMajor) || r.npmMajor < 11 || !r.platform?.minimumOsRelease || !["darwin", "linux", "win32"].includes(r.platform.os) || !["arm64", "x64"].includes(r.platform.arch) || !artifact(r.runtime) || r.runtime.name !== "@huohuo/research-agent" || r.runtime.version !== r.version || !/^sha512-[A-Za-z0-9+/]+={0,2}$/.test(r.runtime.integrity) || !artifact(r.python) || !artifact(r.pythonDependencies) || !r.python.build || !r.python.license || !r.python.executable || r.python.executable.startsWith("/") || r.python.executable.split(/[\\/]/).some((p) => p === ".." || !p) || !version.test(r.dsh?.version) || !hash.test(r.dsh?.assemblySha256) || !hash.test(r.requirementsSha256) || !hash.test(r.profilesSha256) || !r.budget || ![
+  if (!r || r.format !== 1 || r.bootstrapFormat !== 1 || !version.test(r.version) || !integer(r.nodeMajor) || r.nodeMajor < 24 || !integer(r.npmMajor) || r.npmMajor < 11 || !r.platform?.minimumOsRelease || !["darwin", "linux", "win32"].includes(r.platform.os) || !["arm64", "x64"].includes(r.platform.arch) || r.platform.libc !== void 0 && (r.platform.os !== "linux" || r.platform.libc !== "glibc") || r.assetPackage !== void 0 && (r.assetPackage.name !== `@pab-iprg/huohuo-assets-${r.platform.os}-${r.platform.arch}` || !version.test(r.assetPackage.version) || !r.runtime?.bundled || !r.pythonDependencies?.bundled) || !artifact(r.runtime) || r.runtime.name !== "@huohuo/research-agent" || r.runtime.version !== r.version || !/^sha512-[A-Za-z0-9+/]+={0,2}$/.test(r.runtime.integrity) || !artifact(r.python) || !artifact(r.pythonDependencies) || !r.python.build || !r.python.license || r.pythonDependencies.upstreamWheelCount !== void 0 && !integer(r.pythonDependencies.upstreamWheelCount) || !r.python.executable || r.python.executable.startsWith("/") || r.python.executable.split(/[\\/]/).some((p) => p === ".." || !p) || !version.test(r.dsh?.version) || !hash.test(r.dsh?.assemblySha256) || !hash.test(r.requirementsSha256) || !hash.test(r.profilesSha256) || !r.budget || ![
     "minimumEffectiveMemoryBytes",
     "startupHeadroomBytes",
     "heavyJobHeadroomBytes",
@@ -157,7 +161,7 @@ function validateRelease(input) {
     "processTreeBudgetBytes",
     "sampleIntervalMs",
     "sampleMaxAgeMs"
-  ].every((k) => integer(r.budget[k])) || r.budget.startupHeadroomBytes <= 0 || r.budget.minimumEffectiveMemoryBytes <= 0 || r.budget.diskReserveBytes <= 0 || r.budget.recoverySamples < 2 || r.budget.heavyJobHeadroomBytes < r.budget.startupHeadroomBytes || r.budget.processTreeBudgetBytes <= 0 || r.budget.sampleIntervalMs < 1e3 || r.budget.sampleMaxAgeMs < r.budget.sampleIntervalMs * 2 || r.budget.sampleMaxAgeMs > 3e4 || !r.schema || !integer(r.schema.minimum) || !integer(r.schema.maximum) || r.schema.minimum > r.schema.maximum) {
+  ].every((k) => integer(r.budget[k])) || r.budget.observedInstallRssBytes !== void 0 && (!integer(r.budget.observedInstallRssBytes) || r.budget.observedInstallRssBytes <= 0) || r.budget.startupHeadroomBytes <= 0 || r.budget.minimumEffectiveMemoryBytes <= 0 || r.budget.diskReserveBytes <= 0 || r.budget.recoverySamples < 2 || r.budget.heavyJobHeadroomBytes < r.budget.startupHeadroomBytes || r.budget.processTreeBudgetBytes <= 0 || r.budget.sampleIntervalMs < 1e3 || r.budget.sampleMaxAgeMs < r.budget.sampleIntervalMs * 2 || r.budget.sampleMaxAgeMs > 3e4 || !r.schema || !integer(r.schema.minimum) || !integer(r.schema.maximum) || r.schema.minimum > r.schema.maximum) {
     throw new Error("\u53D1\u884C\u6E05\u5355\u65E0\u6548\u6216\u5C1A\u672A\u5B8C\u6210\u5E73\u53F0\u3001\u6458\u8981\u4E0E\u8D44\u6E90\u6D4B\u91CF\uFF1B\u4E0D\u80FD\u5B89\u88C5");
   }
   if (!hash.test(r.schema.migrationsSha256)) throw new Error("\u7F3A\u5C11\u6570\u636E\u5E93\u8FC1\u79FB\u88C5\u914D\u6458\u8981");
@@ -181,45 +185,102 @@ async function verifyArtifact(path, artifact2) {
   }
   if (bytes !== artifact2.downloadBytes || digest2.digest("hex") !== artifact2.sha256 || "integrity" in artifact2 && artifact2.integrity !== `sha512-${integrity.digest("base64")}`) throw new Error("\u4E0B\u8F7D\u4EA7\u7269\u5927\u5C0F\u6216\u6458\u8981\u4E0D\u7B26");
 }
-async function downloadArtifact(artifact2, path, fetcher = fetch) {
+var RetryableDownload = class extends Error {
+};
+async function downloadArtifact(artifact2, path, fetcher = fetch, progress) {
   try {
     await verifyArtifact(path, artifact2);
+    progress?.({ status: "cached", bytes: artifact2.downloadBytes });
     return;
   } catch (e) {
     if (e.code !== "ENOENT") throw e;
   }
   await mkdir2(dirname2(path), { recursive: true, mode: 448 });
+  const sources = [.../* @__PURE__ */ new Set([artifact2.url, ...artifact2.mirrors ?? []])];
+  if (sources.length > 1) {
+    progress?.({ status: "probing", bytes: 0 });
+    const results = await Promise.all(sources.map(async (source) => {
+      const started = performance.now();
+      try {
+        const response = await requestSource(artifact2, source, fetcher, AbortSignal.timeout(5e3), "HEAD");
+        await response.body?.cancel();
+        return { source, latency: response.ok ? performance.now() - started : Infinity };
+      } catch {
+        return { source, latency: Infinity };
+      }
+    }));
+    results.sort((a, b) => a.latency - b.latency);
+    sources.splice(0, sources.length, ...results.map((result) => result.source));
+  } else if (!artifact2.bundled) sources.push(artifact2.url);
+  for (const [index, source] of sources.entries()) {
+    const host = artifact2.bundled ? void 0 : new URL(source).hostname;
+    progress?.({ status: "start", bytes: 0, host });
+    try {
+      await transfer(artifact2, path, source, fetcher, (bytes) => progress?.({ status: "receiving", bytes, host }));
+      progress?.({ status: "verified", bytes: artifact2.downloadBytes, host });
+      return;
+    } catch (error) {
+      if (!(error instanceof RetryableDownload)) throw error;
+      if (index === sources.length - 1) throw new Error(`${host} \u4E0B\u8F7D\u672A\u5B8C\u6210\uFF08${error.message}\uFF09\u3002\u8BF7\u68C0\u67E5\u7F51\u7EDC\u540E\u91CD\u8DD1\uFF0C\u5DF2\u6821\u9A8C\u7684\u6587\u4EF6\u4F1A\u590D\u7528\u3002`, { cause: error });
+      progress?.({ status: "retry", bytes: 0, host });
+    }
+  }
+}
+async function requestSource(artifact2, source, fetcher, signal, method, onResponse) {
+  const allowed = /* @__PURE__ */ new Set([new URL(source).hostname, ...artifact2.redirectHosts ?? []]);
+  let url = source;
+  for (let redirects = 0; redirects <= 4; redirects++) {
+    const next = new URL(url);
+    if (next.protocol !== "https:" || next.username || next.password || !allowed.has(next.hostname)) throw new Error("\u4E0B\u8F7D\u91CD\u5B9A\u5411\u4E0D\u5728\u56FA\u5B9A\u53D1\u884C\u5141\u8BB8\u6765\u6E90\u5185");
+    const response = await fetcher(url, { signal, method, redirect: "manual" });
+    onResponse?.();
+    if (![301, 302, 303, 307, 308].includes(response.status)) return response;
+    const location = response.headers.get("location");
+    await response.body?.cancel();
+    if (!location || redirects === 4) throw new Error("\u4E0B\u8F7D\u91CD\u5B9A\u5411\u65E0\u6548\u6216\u8FC7\u591A");
+    url = new URL(location, url).href;
+  }
+  throw new Error("\u4E0B\u8F7D\u672A\u8FD4\u56DE\u54CD\u5E94");
+}
+async function transfer(artifact2, path, source, fetcher, onBytes) {
   const pending = `${path}.${randomUUID2()}.partial`;
   const handle = await open2(pending, "wx", 384);
+  const idle = new AbortController();
+  let timer;
+  const keepAlive = () => {
+    clearTimeout(timer);
+    timer = setTimeout(() => idle.abort(), 45e3);
+    timer.unref();
+  };
+  const signal = AbortSignal.any([idle.signal, AbortSignal.timeout(30 * 6e4)]);
+  keepAlive();
   try {
-    const allowed = /* @__PURE__ */ new Set([new URL(artifact2.url).hostname, ...artifact2.redirectHosts ?? []]);
-    let url = artifact2.url;
-    let response;
-    const transferMs = Math.ceil(artifact2.downloadBytes / (64 * 1024)) * 1e3;
-    const signal = AbortSignal.timeout(Math.min(9e5, Math.max(12e4, 3e4 + transferMs)));
-    for (let redirects = 0; redirects <= 4; redirects++) {
-      const next = new URL(url);
-      if (next.protocol !== "https:" || next.username || next.password || !allowed.has(next.hostname)) throw new Error("\u4E0B\u8F7D\u91CD\u5B9A\u5411\u4E0D\u5728\u56FA\u5B9A\u53D1\u884C\u5141\u8BB8\u6765\u6E90\u5185");
-      response = await fetcher(url, { signal, redirect: "manual" });
-      if (![301, 302, 303, 307, 308].includes(response.status)) break;
-      const location = response.headers.get("location");
+    const response = await requestSource(artifact2, source, fetcher, signal, "GET", keepAlive);
+    if (!response.ok || !response.body) {
       await response.body?.cancel();
-      if (!location || redirects === 4) throw new Error("\u4E0B\u8F7D\u91CD\u5B9A\u5411\u65E0\u6548\u6216\u8FC7\u591A");
-      url = new URL(location, url).href;
+      if (!artifact2.bundled && (response.status === 408 || response.status === 429 || response.status >= 500 || artifact2.mirrors?.length && [403, 404].includes(response.status))) {
+        throw new RetryableDownload(`HTTP ${response.status}`);
+      }
+      throw new Error(`\u4E0B\u8F7D\u5931\u8D25\uFF1AHTTP ${response.status}`);
     }
-    if (!response) throw new Error("\u4E0B\u8F7D\u672A\u8FD4\u56DE\u54CD\u5E94");
-    if (!response.ok || !response.body) throw new Error(`\u4E0B\u8F7D\u5931\u8D25\uFF1AHTTP ${response.status}`);
     let received = 0;
     for await (const chunk of response.body) {
       received += chunk.byteLength;
+      keepAlive();
       if (received > artifact2.downloadBytes) throw new Error("\u4E0B\u8F7D\u8D85\u8FC7\u53D1\u884C\u6E05\u5355\u5927\u5C0F");
       await handle.writeFile(chunk);
+      onBytes(received);
     }
     await handle.sync();
     await handle.close();
     await verifyArtifact(pending, artifact2);
     await rename2(pending, path);
+  } catch (error) {
+    if (!artifact2.bundled && signal.aborted) throw new RetryableDownload(idle.signal.aborted ? "\u8FDE\u7EED 45 \u79D2\u672A\u6536\u5230\u6570\u636E" : "\u8D85\u8FC7\u5355\u6B21\u4E0B\u8F7D\u65F6\u9650", { cause: error });
+    if (!artifact2.bundled && error instanceof TypeError) throw new RetryableDownload("\u7F51\u7EDC\u8FDE\u63A5\u4E2D\u65AD", { cause: error });
+    throw error;
   } finally {
+    clearTimeout(timer);
     await handle.close().catch(() => {
     });
     await rm(pending, { force: true });
@@ -303,8 +364,8 @@ async function extractArchive(archive, root, expandedLimit) {
           }
         } else if (kind === "1" || kind === "2") {
           if (size || !linkText || linkText.startsWith("/") || linkText.includes("\\")) throw new Error("\u538B\u7F29\u5305\u94FE\u63A5\u65E0\u6548");
-          const relative = kind === "2" ? posix.normalize(posix.join(posix.dirname(name), linkText)) : linkText;
-          links.push({ target, source: safePath(root, relative), symbolic: kind === "2", text: linkText });
+          const relative2 = kind === "2" ? posix.normalize(posix.join(posix.dirname(name), linkText)) : linkText;
+          links.push({ target, source: safePath(root, relative2), symbolic: kind === "2", text: linkText });
         } else throw new Error(`\u538B\u7F29\u5305\u6761\u76EE\u7C7B\u578B\u4E0D\u53D7\u652F\u6301\uFF1A${kind}`);
       }
       if (size % 512) await take(512 - size % 512);
@@ -357,6 +418,13 @@ async function existingParent(path) {
     current = parent;
   }
 }
+function linuxAvailableMemory(processAvailable, meminfo) {
+  if (processAvailable === null || !Number.isSafeInteger(processAvailable) || processAvailable <= 0) return null;
+  const match = /^MemAvailable:\s+(\d+) kB$/m.exec(meminfo);
+  if (!match) return processAvailable;
+  const hostAvailable = Number(match[1]) * 1024;
+  return Number.isSafeInteger(hostAvailable) && hostAvailable >= 0 ? Math.min(processAvailable, hostAvailable) : null;
+}
 async function sampleResources(paths) {
   const limit = constrainedMemory();
   let effectiveMemoryBytes = Math.min(totalmem(), limit || Infinity);
@@ -389,16 +457,7 @@ async function sampleResources(paths) {
   } else if (process.platform === "linux") {
     try {
       const info = await readFile3("/proc/meminfo", "utf8");
-      const available = /^MemAvailable:\s+(\d+) kB$/m.exec(info);
-      if (available) availableMemoryBytes = Math.min(availableMemoryBytes ?? Infinity, Number(available[1]) * 1024);
-      if (limit) {
-        try {
-          const current = Number((await readFile3("/sys/fs/cgroup/memory.current", "utf8")).trim());
-          if (Number.isFinite(current)) availableMemoryBytes = Math.min(availableMemoryBytes ?? Infinity, Math.max(0, limit - current));
-        } catch {
-          availableMemoryBytes = null;
-        }
-      }
+      availableMemoryBytes = linuxAvailableMemory(availableMemoryBytes, info);
       const psi = await readFile3("/proc/pressure/memory", "utf8");
       const full = /^full avg10=(\d+(?:\.\d+)?)/m.exec(psi);
       if (full) pressure = Number(full[1]) > 0 ? "high" : "normal";
@@ -487,6 +546,50 @@ function npmCommand() {
   return { command: process.env.ComSpec ?? "cmd.exe", prefix: ["/d", "/s", "/c", "npm"] };
 }
 
+// distribution/bootstrap/catalog.ts
+function hostPlatform() {
+  const host = { os: process.platform, arch: process.arch };
+  if (host.os === "linux") {
+    const report = process.report?.getReport();
+    host.libc = report?.header?.glibcVersionRuntime ? "glibc" : "unknown";
+  }
+  return host;
+}
+function validateCatalog(input) {
+  const catalog = input;
+  if (!catalog || catalog.kind !== "huohuo-release-catalog" || catalog.format !== 1 || !Array.isArray(catalog.releases) || !catalog.releases.length || catalog.releases.length > 6) {
+    throw new Error("\u5E73\u53F0\u53D1\u884C\u7D22\u5F15\u65E0\u6548\uFF1B\u8BF7\u4F7F\u7528\u5B8C\u6574\u7684\u706B\u706B\u5B89\u88C5\u5305");
+  }
+  const platforms = /* @__PURE__ */ new Set();
+  for (const candidate of catalog.releases) {
+    const release = validateRelease(candidate);
+    const platform = `${release.platform.os}-${release.platform.arch}`;
+    if (release.version !== catalog.version || platforms.has(platform)) throw new Error("\u5E73\u53F0\u53D1\u884C\u7D22\u5F15\u542B\u6DF7\u5408\u7248\u672C\u6216\u91CD\u590D\u5E73\u53F0");
+    if (release.platform.os === "linux" && release.platform.libc !== "glibc") throw new Error("Linux \u5E73\u53F0\u53D1\u884C\u5FC5\u987B\u660E\u786E glibc \u8FD0\u884C\u73AF\u5883");
+    platforms.add(platform);
+  }
+  return catalog;
+}
+function validateReleaseSource(input) {
+  if (input && typeof input === "object" && ("kind" in input || "releases" in input)) return validateCatalog(input);
+  return validateRelease(input);
+}
+function selectRelease(input, host = hostPlatform()) {
+  const source = validateReleaseSource(input);
+  const releases = "releases" in source ? source.releases : [source];
+  const selected = releases.find((release) => release.platform.os === host.os && release.platform.arch === host.arch);
+  if (!selected) {
+    throw new Error(`\u8FD9\u4E2A\u5B89\u88C5\u5305\u5C1A\u672A\u63D0\u4F9B ${host.os}-${host.arch} \u7248\u672C\u3002\u5DF2\u6536\u5F55\uFF1A${releases.map((release) => `${release.platform.os}-${release.platform.arch}`).join("\u3001")}\u3002\u8BF7\u4F7F\u7528\u9002\u914D\u5F53\u524D\u8BBE\u5907\u7684\u53D1\u884C\u7248\u672C\uFF1B\u672A\u4E0B\u8F7D\u6216\u4FEE\u6539\u73B0\u6709\u5B89\u88C5\u3002`);
+  }
+  assertLibcCompatible(selected, host);
+  return selected;
+}
+function assertLibcCompatible(release, host = hostPlatform()) {
+  if (release.platform.libc && host.libc !== release.platform.libc) {
+    throw new Error("\u8FD9\u4E2A Linux \u5B89\u88C5\u5305\u9700\u8981 glibc \u73AF\u5883\uFF0C\u5F53\u524D\u7CFB\u7EDF\u65E0\u6CD5\u786E\u8BA4\u517C\u5BB9\uFF08\u4F8B\u5982 Alpine/musl\uFF09\u3002\u8BF7\u4F7F\u7528\u5DF2\u9A8C\u8BC1\u7684 glibc \u7CFB\u7EDF\uFF1B\u672A\u4E0B\u8F7D\u6216\u4FEE\u6539\u73B0\u6709\u5B89\u88C5\u3002");
+  }
+}
+
 // distribution/bootstrap/install.ts
 var digest = (value) => createHash2("sha256").update(JSON.stringify(value)).digest("hex");
 async function ownedDirectory(path, owner) {
@@ -561,13 +664,20 @@ function installationPaths(home, release) {
   };
 }
 function versionAtLeast(actual, minimum) {
+  if (![actual, minimum].every((value) => /^\d+(?:\.\d+)*$/.test(value))) return false;
   const a = actual.split(".").map(Number), b = minimum.split(".").map(Number);
-  if ([...a, ...b].some((n) => !Number.isInteger(n))) return false;
+  if ([...a, ...b].some((n) => !Number.isSafeInteger(n))) return false;
   for (let i = 0; i < Math.max(a.length, b.length); i++) {
     if ((a[i] ?? 0) !== (b[i] ?? 0)) return (a[i] ?? 0) > (b[i] ?? 0);
   }
   return true;
 }
+function osReleaseAtLeast(actual, minimum, platform = process.platform) {
+  if (platform !== "linux") return versionAtLeast(actual, minimum);
+  const numericRelease = (value) => /^(\d+(?:\.\d+)*)(?:-[A-Za-z0-9][A-Za-z0-9.+_-]*)?$/.exec(value)?.[1];
+  const a = numericRelease(actual), b = numericRelease(minimum);
+  return a !== void 0 && b !== void 0 && versionAtLeast(a, b);
+}
 async function install(home, candidate, hooks = {}, programsOnly = false) {
   home = resolve3(home);
   await mkdir3(home, { recursive: true, mode: 448 });
@@ -614,7 +724,8 @@ async function install(home, candidate, hooks = {}, programsOnly = false) {
       }
     }
     const release = record?.release ?? validateRelease(candidate);
-    if (release.platform.os !== process.platform || release.platform.arch !== process.arch || !versionAtLeast(osRelease(), release.platform.minimumOsRelease) || !versionAtLeast(process.versions.node, "24.8.0") || Number(process.versions.node.split(".")[0]) !== release.nodeMajor) {
+    assertLibcCompatible(release);
+    if (release.platform.os !== process.platform || release.platform.arch !== process.arch || !osReleaseAtLeast(osRelease(), release.platform.minimumOsRelease) || !versionAtLeast(process.versions.node, "24.8.0") || Number(process.versions.node.split(".")[0]) !== release.nodeMajor) {
       throw new Error("\u6B64\u53D1\u884C\u5C1A\u672A\u9A8C\u8BC1\u5F53\u524D OS/CPU/Node \u7EC4\u5408\uFF1B\u672A\u5F00\u59CB\u91CD\u4E0B\u8F7D");
     }
     record ??= { format: 1, release, releaseDigest: digest(release), home, status: "installing", stage: "preflight", stages: {} };
@@ -622,6 +733,20 @@ async function install(home, candidate, hooks = {}, programsOnly = false) {
     const paths = installationPaths(home, release);
     const execute4 = hooks.run ?? run;
     const sample = hooks.sample ?? sampleResources;
+    const files = [
+      { name: "\u706B\u706B\u8FD0\u884C\u5305", artifact: release.runtime, path: paths.archive },
+      { name: "Python \u8FD0\u884C\u73AF\u5883", artifact: release.python, path: paths.pythonArchive },
+      { name: "Python \u4F9D\u8D56\u6E05\u5355\u6216\u79BB\u7EBF\u5305", artifact: release.pythonDependencies, path: join3(home, "cache", release.pythonDependencies.sha256 + ".tgz") }
+    ];
+    const withActivity = async (label, action) => {
+      hooks.progress?.(label);
+      const timer = hooks.progress && setInterval(() => hooks.progress?.(`${label}\u4ECD\u5728\u8FDB\u884C\uFF0C\u8BF7\u7A0D\u5019`), 2e4);
+      try {
+        await action();
+      } finally {
+        if (timer) clearInterval(timer);
+      }
+    };
     const cached = async (path, artifact2) => {
       try {
         await verifyArtifact(path, artifact2);
@@ -656,15 +781,10 @@ async function install(home, candidate, hooks = {}, programsOnly = false) {
       }
     };
     const check = async () => {
-      const [runtimeCached, pythonCached, wheelsCached, inventory] = await Promise.all([
-        cached(paths.archive, release.runtime),
-        cached(paths.pythonArchive, release.python),
-        cached(join3(home, "cache", release.pythonDependencies.sha256 + ".tgz"), release.pythonDependencies),
-        installed()
-      ]);
+      const [cacheHits, inventory] = await Promise.all([Promise.all(files.map((file) => cached(file.path, file.artifact))), installed()]);
       const remainingDependencies = inventory.dependencies ? 0 : release.budget.dependenciesBytes;
       const costs = [
-        { path: join3(home, "cache"), bytes: (runtimeCached ? 0 : release.runtime.downloadBytes) + (pythonCached ? 0 : release.python.downloadBytes) + (wheelsCached ? 0 : release.pythonDependencies.downloadBytes) },
+        { path: join3(home, "cache"), bytes: files.reduce((sum, file, index) => sum + (cacheHits[index] ? 0 : file.artifact.downloadBytes), 0) },
         { path: paths.directory, bytes: inventory.dependencies ? 0 : release.runtime.expandedBytes + release.budget.installTemporaryBytes },
         { path: paths.python, bytes: inventory.python ? 0 : release.python.expandedBytes },
         { path: paths.environment, bytes: 0 },
@@ -690,6 +810,19 @@ async function install(home, candidate, hooks = {}, programsOnly = false) {
 ${details}
 \u5904\u7406\u540E\uFF0C\u91CD\u65B0\u8FD0\u884C\u521A\u624D\u7684\u5B89\u88C5\u547D\u4EE4\u3002`), { code: "RESOURCE_BLOCKED" });
       }
+      const pendingFiles = files.filter((_, index) => !cacheHits[index]);
+      return {
+        home,
+        resources: result,
+        cached: files.length - pendingFiles.length,
+        bundled: pendingFiles.filter((file) => file.artifact.bundled).length,
+        upstreamWheelCount: inventory.dependencies ? void 0 : release.pythonDependencies.upstreamWheelCount,
+        downloads: pendingFiles.filter((file) => !file.artifact.bundled).map((file) => ({
+          name: file.name,
+          size: file.artifact.downloadBytes,
+          host: new URL(file.artifact.url).hostname
+        }))
+      };
     };
     const stage = async (name, action) => {
       hooks.progress?.(name);
@@ -700,8 +833,8 @@ ${details}
       record.stages[name] = entry;
       await atomicJSON(recordPath, record);
       try {
-        await check();
-        const output = await action();
+        const plan = await check();
+        const output = await action(plan);
         entry.status = "verified";
         entry.outputDigest = digest(output ?? null);
         entry.endedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -709,13 +842,13 @@ ${details}
         entry.status = "failed";
         entry.endedAt = (/* @__PURE__ */ new Date()).toISOString();
         entry.errorCode = typeof error.code === "string" && /^[A-Z0-9_]+$/.test(error.code) ? error.code : "STAGE_FAILED";
-        record.status = entry.errorCode === "RESOURCE_BLOCKED" ? "blocked" : "failed";
+        record.status = entry.errorCode === "RESOURCE_BLOCKED" || entry.errorCode === "INSTALL_CANCELLED" ? "blocked" : "failed";
         await atomicJSON(recordPath, record);
         throw error;
       }
       await atomicJSON(recordPath, record);
     };
-    await stage("preflight", async () => {
+    await stage("preflight", async (plan) => {
       const npm = npmCommand();
       const { stdout } = await promisify3(execFile3)(npm.command, [...npm.prefix, "--version"], { timeout: 5e3 });
       if (!/^\d+\.\d+\.\d+\s*$/.test(stdout) || Number(stdout.split(".")[0]) !== release.npmMajor) throw new Error("npm \u7248\u672C\u672A\u77E5\u6216\u4E0D\u5728\u6B64\u53D1\u884C\u5DF2\u9A8C\u8BC1\u8303\u56F4\u5185");
@@ -725,11 +858,25 @@ ${details}
       } finally {
         await rm2(probe, { force: true });
       }
+      if (hooks.confirm && !await hooks.confirm(plan)) {
+        throw Object.assign(new Error("\u5DF2\u53D6\u6D88\u5B89\u88C5\uFF0C\u672C\u6B21\u6CA1\u6709\u8FDB\u5165\u4E0B\u8F7D\u3002"), { code: "INSTALL_CANCELLED" });
+      }
     });
     await stage("download", async () => {
-      await downloadArtifact(release.runtime, paths.archive, hooks.fetcher);
-      await downloadArtifact(release.python, paths.pythonArchive, hooks.fetcher);
-      await downloadArtifact(release.pythonDependencies, join3(home, "cache", release.pythonDependencies.sha256 + ".tgz"), hooks.fetcher);
+      for (const [index, file] of files.entries()) {
+        const progress = (event) => hooks.downloadProgress?.({
+          name: file.name,
+          index: index + 1,
+          total: files.length,
+          size: file.artifact.downloadBytes
+        }, event);
+        try {
+          await downloadArtifact(file.artifact, file.path, hooks.fetcher, progress);
+        } catch (error) {
+          progress({ status: "failed", bytes: 0 });
+          throw new Error(`${file.name}\u5904\u7406\u5931\u8D25\u3002 ${error instanceof Error ? error.message : "\u8BF7\u91CD\u8BD5\u5B89\u88C5\u3002"}`, { cause: error });
+        }
+      }
       return [release.runtime.sha256, release.python.sha256, release.pythonDependencies.sha256];
     });
     await stage("install-runtime", async () => {
@@ -762,7 +909,7 @@ ${details}
         dependencies: { "@huohuo/research-agent": `file:${paths.archive}` }
       });
       const npm = npmCommand();
-      await execute4(npm.command, [...npm.prefix, "install", "--omit=dev", "--ignore-scripts", "--no-audit", "--no-fund", "--prefer-offline", "--cache", join3(home, "cache/npm")], paths.directory);
+      await withActivity("\u5B89\u88C5 npm \u4F9D\u8D56", () => execute4(npm.command, [...npm.prefix, "install", "--omit=dev", "--ignore-scripts", "--no-audit", "--no-fund", "--prefer-offline", "--cache", join3(home, "cache/npm")], paths.directory));
       const runtime = JSON.parse(await readFile4(join3(paths.runtime, "package.json"), "utf8"));
       if (runtime.name !== release.runtime.name || runtime.version !== release.version) throw new Error("\u8FD0\u884C\u5305\u8EAB\u4EFD\u4E0D\u7B26");
       const requirements = await readFile4(join3(paths.runtime, "sidecar/requirements.lock"));
@@ -796,7 +943,12 @@ ${details}
       }
       if (!environmentReady) {
         await execute4(join3(paths.python, release.python.executable), ["-m", "venv", paths.environment], home);
-        await execute4(python, [
+        if (release.pythonDependencies.bundled && hooks.progress) {
+          const lock = await readFile4(join3(wheels, "requirements.txt"), "utf8");
+          const upstream = lock.split("\n").filter((line) => /^[\w.-]+\s+@\s+https:\/\//.test(line)).length;
+          if (upstream) hooks.progress?.(`Python \u4F9D\u8D56\u6E05\u5355\u6709 ${upstream} \u4E2A\u4E0A\u6E38\u6587\u4EF6\uFF0C\u4E0B\u65B9\u663E\u793A\u6B63\u5728\u5904\u7406\u7684\u6587\u4EF6`);
+        }
+        await withActivity("\u5B89\u88C5 Python \u4F9D\u8D56", () => execute4(python, [
           "-m",
           "pip",
           "--isolated",
@@ -809,7 +961,7 @@ ${details}
           ...release.pythonDependencies.bundled ? ["--no-cache-dir"] : [],
           "-r",
           join3(wheels, "requirements.txt")
-        ], home);
+        ], home));
       }
       await execute4(python, ["-m", "pip", "--isolated", "check"], home);
       await atomicJSON(join3(paths.environment, ".dependencies-ready.json"), { sha256: release.pythonDependencies.sha256 });
@@ -822,7 +974,7 @@ ${details}
       return record;
     }
     await stage("assemble-profiles", async () => {
-      await execute4(process.execPath, [join3(paths.runtime, "lib/distribution/managed.js"), "prepare", home], home);
+      await withActivity("\u914D\u7F6E\u5BF9\u8BDD\u4E0E\u540E\u53F0\u8FD0\u884C\u4F9D\u8D56", () => execute4(process.execPath, [join3(paths.runtime, "lib/distribution/managed.js"), "prepare", home], home));
       return { release: record.releaseDigest };
     });
     await stage("verify", async () => {
@@ -1071,6 +1223,220 @@ async function uninstall(home, hooks = {}) {
   });
 }
 
+// distribution/bootstrap/install-ui.ts
+import { createInterface } from "node:readline";
+import { homedir } from "node:os";
+import { relative, sep as sep3 } from "node:path";
+var gb = (bytes) => bytes === null ? "\u672A\u77E5" : `${(bytes / 1e9).toFixed(2)} GB`;
+var mb = (bytes) => bytes < 1e5 ? `${(bytes / 1e3).toFixed(1)} KB` : `${(bytes / 1e6).toFixed(1)} MB`;
+var memory = (bytes) => {
+  if (bytes === null) return "\u672A\u77E5";
+  return bytes < 2 ** 30 ? `${Math.floor(bytes / 2 ** 20)} MiB` : `${Number((bytes / 2 ** 30).toFixed(2))} GiB`;
+};
+function displayPath(path) {
+  const local = relative(homedir(), path);
+  if (!local) return "~";
+  return local === ".." || local.startsWith(`..${sep3}`) ? path : `~${sep3}${local}`;
+}
+function installUI(assumeYes) {
+  const interactive = process.stdin.isTTY && process.stderr.isTTY;
+  const output = process.stderr;
+  let lastUpdate = 0;
+  let lineActive = false;
+  const clear = () => {
+    if (lineActive) {
+      output.write("\r\x1B[2K");
+      lineActive = false;
+    }
+  };
+  const line = (text) => {
+    clear();
+    output.write(text + "\n");
+  };
+  const heading = (text) => line(interactive && process.env.TERM !== "dumb" && process.env.NO_COLOR === void 0 ? `\x1B[1m${text}\x1B[22m` : text);
+  return {
+    async confirm(plan) {
+      const { sample, policy, disks } = plan.resources;
+      const narrow = interactive && output.columns > 0 && output.columns < 48;
+      line("");
+      heading("\u706B\u706B\u5B89\u88C5 \xB7 \u786E\u8BA4\u8BA1\u5212");
+      line(`  \u5B89\u88C5\u5230  ${displayPath(plan.home)}`);
+      line("");
+      heading("\u672C\u673A\u8D44\u6E90");
+      for (const [index, disk] of disks.entries()) {
+        const location = sample.disks.find((item) => item.device === disk.device)?.paths[0] ?? plan.home;
+        if (disks.length > 1) line(`  \u78C1\u76D8 ${index + 1}  ${displayPath(location)}`);
+        const need = `\u9700\u7559 ${gb(disk.requiredBytes)}`;
+        const free = `\u53EF\u7528 ${gb(disk.availableBytes)}`;
+        line(narrow ? `  \u78C1\u76D8  ${need}
+        ${free}` : `  \u78C1\u76D8  ${need} \xB7 ${free}`);
+      }
+      const available = `\u53EF\u7528 ${memory(sample.availableMemoryBytes)}`;
+      const total = `\u603B\u91CF ${memory(sample.effectiveMemoryBytes)}`;
+      line(narrow ? `  \u5185\u5B58  ${available}
+        ${total}` : `  \u5185\u5B58  ${available} \xB7 ${total}`);
+      line(`        \u542F\u52A8\u9700\u7559 ${memory(policy.startupHeadroomBytes)}`);
+      line(`        \u6700\u4F4E\u5BB9\u91CF ${memory(policy.minimumEffectiveMemoryBytes)}`);
+      if (policy.observedInstallRssBytes) line(`        \u5386\u53F2\u5B89\u88C5\u5CF0\u503C\u7EA6 ${memory(policy.observedInstallRssBytes)}`);
+      for (const reason of plan.resources.reasons) line(`  \u63D0\u793A  ${reason}`);
+      line("");
+      heading("\u4E0B\u8F7D\u8BA1\u5212");
+      const bytes = plan.downloads.reduce((total2, file) => total2 + file.size, 0);
+      line(plan.downloads.length ? `  \u56FA\u5B9A\u8D44\u6E90\u5F85\u4E0B\u8F7D  ${plan.downloads.length} \u9879 \xB7 ${mb(bytes)}` : "  \u56FA\u5B9A\u8D44\u6E90\u65E0\u9700\u8054\u7F51\u4E0B\u8F7D");
+      const local = [plan.bundled ? `\u968F\u5305 ${plan.bundled} \u9879` : "", plan.cached ? `\u590D\u7528\u7F13\u5B58 ${plan.cached} \u9879` : ""].filter(Boolean);
+      if (local.length) line(`  ${local.join(" \xB7 ")}`);
+      for (const file of plan.downloads) {
+        line(`  ${file.name}  ${mb(file.size)}`);
+        line(`    \u6765\u6E90  ${file.host}`);
+      }
+      if (plan.downloads.length || plan.bundled) line(`  \u4FDD\u5B58\u5230  ${displayPath(plan.home)}/cache`);
+      if (plan.upstreamWheelCount !== void 0) line(`  Python \u4E0A\u6E38\u6587\u4EF6  ${plan.upstreamWheelCount} \u9879`);
+      line("  npm \u548C Python \u4F9D\u8D56\u4ECD\u53EF\u80FD\u8054\u7F51");
+      line("");
+      if (assumeYes) return true;
+      if (!interactive) throw new Error("\u9700\u8981\u786E\u8BA4\u5B89\u88C5\u3002\u8BF7\u5728\u7EC8\u7AEF\u8FD0\u884C\uFF0C\u6216\u5728\u706B\u706B\u547D\u4EE4\u672B\u5C3E\u52A0\u4E0A --yes\u3002");
+      const terminal = createInterface({ input: process.stdin, output, terminal: true });
+      try {
+        const answers = terminal[Symbol.asyncIterator]();
+        output.write("\u7EE7\u7EED\u5B89\u88C5\uFF1F[y/N] ");
+        const answer = await answers.next();
+        return !answer.done && /^(y|yes|是)$/i.test(answer.value.trim());
+      } finally {
+        terminal.close();
+      }
+    },
+    downloadProgress(file, event) {
+      const label = `[${file.index}/${file.total}] ${file.name}`;
+      if (event.status === "probing") {
+        line(`${label}  \u6B63\u5728\u68C0\u67E5\u4E0B\u8F7D\u6E90\u662F\u5426\u53EF\u8FBE`);
+      } else if (event.status === "start") {
+        lastUpdate = Date.now();
+        line(`${label}  ${event.host ? `\u6B63\u5728\u8FDE\u63A5 ${event.host}` : "\u6B63\u5728\u8BFB\u53D6\u968F\u5305\u8D44\u6E90"}  ${mb(file.size)}`);
+      } else if (event.status === "cached") {
+        line(`${label}  \u5DF2\u6821\u9A8C\u5E76\u590D\u7528\u7F13\u5B58`);
+      } else if (event.status === "verified") {
+        line(`${label}  \u5DF2\u5B8C\u6210\u5E76\u6821\u9A8C  ${mb(file.size)}`);
+      } else if (event.status === "retry") {
+        line(`${label}  ${event.host} \u4E0B\u8F7D\u672A\u5B8C\u6210\uFF0C\u51C6\u5907\u91CD\u8BD5`);
+      } else if (event.status === "failed") {
+        clear();
+      } else {
+        const now = Date.now();
+        if (now - lastUpdate < (interactive ? 180 : 15e3)) return;
+        lastUpdate = now;
+        const percent = Math.min(99, Math.floor(100 * event.bytes / file.size));
+        const filled = Math.floor(percent / 10);
+        const value = `[${"#".repeat(filled)}${"-".repeat(10 - filled)}] ${percent}%  ${mb(event.bytes)} / ${mb(file.size)}`;
+        if (interactive && (output.columns ?? 0) >= value.length) {
+          clear();
+          output.write(value);
+          lineActive = true;
+        } else line(`${label}  ${value}`);
+      }
+    }
+  };
+}
+
+// distribution/bootstrap/status-ui.ts
+import { readFile as readFile7 } from "node:fs/promises";
+import { join as join6 } from "node:path";
+import { setTimeout as delay2 } from "node:timers/promises";
+var mib = (bytes) => typeof bytes === "number" && Number.isFinite(bytes) ? `${Math.round(bytes / 2 ** 20)} MiB` : "\u672A\u77E5";
+var pressureLabels = { normal: "\u6B63\u5E38", high: "\u504F\u9AD8", critical: "\u4E25\u91CD", unknown: "\u672A\u77E5" };
+async function statusLines(home) {
+  const title = "\u706B\u706B \xB7 \u8FD0\u884C\u72B6\u6001";
+  const installed = await readInstallation(home);
+  if (!installed) return [title, "\u5C1A\u672A\u5B89\u88C5\u706B\u706B\u3002"];
+  if (installed.status !== "ready") return [title, "\u5B89\u88C5\u5C1A\u672A\u5B8C\u6210\u3002"];
+  let admission;
+  try {
+    admission = JSON.parse(await readFile7(join6(home, "state/default-admission.json"), "utf8"));
+  } catch (error) {
+    if (error.code !== "ENOENT") return [title, "\u6682\u65F6\u65E0\u6CD5\u8BFB\u53D6\u8D44\u6E90\u72B6\u6001\u3002"];
+  }
+  const now = Date.now() / 1e3;
+  if (!admission || admission.format !== 1 || admission.releaseDigest !== installed.releaseDigest || !Number.isFinite(admission.sampledAt) || !(admission.validUntil > now) || typeof admission.allowHeavy !== "boolean" || !admission.resources?.sample) {
+    return [title, "\u6682\u65E0\u6709\u6548\u7684\u8FD0\u884C\u91C7\u6837\u3002\u8BF7\u68C0\u67E5\u706B\u706B\u670D\u52A1\u662F\u5426\u6B63\u5728\u8FD0\u884C\u3002"];
+  }
+  const { sample, reasons } = admission.resources;
+  const needed = installed.release.budget.heavyJobHeadroomBytes;
+  const gap = sample.availableMemoryBytes === null ? null : Math.max(0, needed - sample.availableMemoryBytes);
+  const lines = [
+    title,
+    `\u540E\u53F0\u7814\u7A76  ${admission.allowHeavy ? "\u53EF\u63A5\u6536\u4EFB\u52A1" : "\u6682\u7F13\u65B0\u4EFB\u52A1"}`,
+    `\u7CFB\u7EDF\u5185\u5B58  \u53EF\u7528 ${mib(sample.availableMemoryBytes)} / \u603B\u5BB9\u91CF ${mib(sample.effectiveMemoryBytes)}`,
+    `\u4EFB\u52A1\u95E8\u69DB  \u9884\u7559 ${mib(needed)}${gap ? `\uFF0C\u8FD8\u5DEE ${mib(gap)}` : ""}`,
+    `\u5185\u5B58\u538B\u529B  ${pressureLabels[sample.pressure] ?? "\u672A\u77E5"}`,
+    `\u706B\u706B\u8FDB\u7A0B  \u4F30\u7B97\u5360\u7528 ${mib(admission.rssSumEstimateBytes)}`
+  ];
+  if (!admission.allowHeavy) lines.push(reasons?.[0] ? `\u6682\u7F13\u539F\u56E0  ${reasons[0]}` : "\u6B63\u5728\u7B49\u5F85\u8FDE\u7EED\u5065\u5EB7\u91C7\u6837\u3002");
+  lines.push(`\u91C7\u6837\u65F6\u95F4  ${new Date(admission.sampledAt * 1e3).toLocaleTimeString()}`);
+  return lines;
+}
+async function showStatus(home, watch) {
+  const output = process.stdout;
+  if (!watch || !output.isTTY || process.env.TERM === "dumb") {
+    output.write((await statusLines(home)).join("\n") + "\n");
+    return;
+  }
+  const stop = new AbortController();
+  const close = () => stop.abort();
+  const input = process.stdin;
+  const raw = input.isTTY;
+  const wasRaw = input.isRaw;
+  const onKey = (chunk) => {
+    if (chunk.includes(3)) close();
+  };
+  process.once("SIGINT", close);
+  process.once("SIGTERM", close);
+  try {
+    if (raw) {
+      input.setRawMode(true);
+      input.on("data", onKey);
+      input.resume();
+    }
+    output.write("\x1B[?1049h\x1B[?25l");
+    while (!stop.signal.aborted) {
+      const lines = await statusLines(home);
+      if (stop.signal.aborted) break;
+      output.write("\x1B[H\x1B[0J" + [...lines, "", "\u6BCF 2 \u79D2\u5237\u65B0 \xB7 Ctrl+C \u5173\u95ED\u770B\u677F"].join("\n"));
+      await delay2(2e3, void 0, { signal: stop.signal }).catch((error) => {
+        if (!stop.signal.aborted) throw error;
+      });
+    }
+  } finally {
+    output.write("\x1B[?25h\x1B[?1049l");
+    if (raw) {
+      input.off("data", onKey);
+      input.setRawMode(Boolean(wasRaw));
+      input.pause();
+    }
+    process.off("SIGINT", close);
+    process.off("SIGTERM", close);
+  }
+}
+
+// distribution/bootstrap/assets.ts
+import { createRequire } from "node:module";
+import { readFile as readFile8 } from "node:fs/promises";
+import { dirname as dirname5, join as join7 } from "node:path";
+import { fileURLToPath } from "node:url";
+async function assetsDirectory(release, entryURL = import.meta.url) {
+  if (!release?.assetPackage) return join7(dirname5(fileURLToPath(entryURL)), "assets");
+  const expected = release.assetPackage;
+  let file;
+  try {
+    file = createRequire(entryURL).resolve(`${expected.name}/package.json`);
+  } catch {
+    throw new Error("\u6CA1\u6709\u627E\u5230\u5F53\u524D\u8BBE\u5907\u7684\u706B\u706B\u8D44\u6E90\u5305\u3002\u8BF7\u91CD\u65B0\u6267\u884C\u5B8C\u6574\u5B89\u88C5\u547D\u4EE4\uFF0C\u5E76\u786E\u4FDD\u6CA1\u6709\u8DF3\u8FC7 npm \u53EF\u9009\u4F9D\u8D56\u3002");
+  }
+  const manifest = JSON.parse(await readFile8(file, "utf8"));
+  if (manifest.name !== expected.name || manifest.version !== expected.version) {
+    throw new Error("\u706B\u706B\u5165\u53E3\u4E0E\u5E73\u53F0\u8D44\u6E90\u5305\u7248\u672C\u4E0D\u4E00\u81F4\u3002\u8BF7\u91CD\u65B0\u8FD0\u884C\u540C\u4E00\u7248\u672C\u7684\u5B8C\u6574\u5B89\u88C5\u547D\u4EE4\u3002");
+  }
+  return join7(dirname5(file), "assets");
+}
+
 // distribution/bootstrap/entry.ts
 function artifactSource(source, directory) {
   return async (url, options) => {
@@ -1079,8 +1445,8 @@ function artifactSource(source, directory) {
     const artifact2 = source && [source.runtime, source.python, source.pythonDependencies].find((item) => item.url === String(url));
     const sha256 = bundled?.[1] ?? artifact2?.sha256;
     if (!sha256) throw new Error("\u672C\u673A\u4EA7\u7269\u76EE\u5F55\u7F3A\u5C11\u8BE5\u56FA\u5B9A\u53D1\u884C\u8D44\u6E90");
-    const root = directory ?? join6(dirname5(fileURLToPath(import.meta.url)), "assets");
-    const path = join6(root, sha256 + ".tgz");
+    const root = directory ?? await assetsDirectory(source, import.meta.url);
+    const path = join8(root, sha256 + ".tgz");
     const file = await open3(path).catch((error) => {
       if (error.code === "ENOENT" && bundled) throw new Error("\u7F3A\u5C11\u4E0A\u6B21\u5B89\u88C5\u4F7F\u7528\u7684\u6587\u4EF6\u3002\u8BF7\u7528\u4E0A\u6B21\u5B89\u88C5\u65F6\u7684\u7248\u672C\u7EE7\u7EED\u3002");
       throw error;
@@ -1089,7 +1455,7 @@ function artifactSource(source, directory) {
   };
 }
 async function main(args = process.argv.slice(2)) {
-  let home = join6(homedir(), ".huohuo"), noOpen = false, command = "start";
+  let home = join8(homedir2(), ".huohuo"), noOpen = false, assumeYes = false, watch = false, command = "start";
   let releaseFile, artifactDirectory;
   for (let i = 0; i < args.length; i++) {
     if (args[i] === "--home") {
@@ -1101,19 +1467,23 @@ async function main(args = process.argv.slice(2)) {
       if (option === "--release") releaseFile = resolve5(args[++i]);
       else artifactDirectory = resolve5(args[++i]);
     } else if (args[i] === "--no-open") noOpen = true;
+    else if (args[i] === "--yes") assumeYes = true;
+    else if (args[i] === "--watch") watch = true;
     else if (args[i] === "--version") {
-      const packageFile = join6(dirname5(fileURLToPath(import.meta.url)), "package.json");
-      const manifest = JSON.parse(await readFile7(packageFile, "utf8"));
+      const packageFile = join8(dirname6(fileURLToPath2(import.meta.url)), "package.json");
+      const manifest = JSON.parse(await readFile9(packageFile, "utf8"));
       console.log(`${manifest.name} ${manifest.version}${manifest.private ? "\uFF08\u672C\u5730\u5019\u9009\uFF09" : ""}`);
       return;
-    } else if (["start", "doctor", "stop", "upgrade", "uninstall"].includes(args[i])) command = args[i];
-    else throw new Error("\u7528\u6CD5\uFF1Ahuohuo [start|doctor|stop|upgrade|uninstall] [--home \u76EE\u5F55] [--no-open]");
+    } else if (["start", "status", "doctor", "stop", "upgrade", "uninstall"].includes(args[i])) command = args[i];
+    else throw new Error("\u7528\u6CD5\uFF1Ahuohuo [start|status|doctor|stop|upgrade|uninstall] [--home \u76EE\u5F55] [--no-open]");
   }
+  if (watch && command !== "status") throw new Error("--watch \u8BF7\u4E0E status \u4E00\u8D77\u4F7F\u7528");
   try {
     home = await realpath5(home);
   } catch (e) {
     if (e.code !== "ENOENT") throw e;
   }
+  if (command === "status") return showStatus(home, watch);
   let record = await readInstallation(home);
   const labels = {
     preflight: "\u68C0\u67E5\u672C\u673A\u73AF\u5883",
@@ -1124,13 +1494,19 @@ async function main(args = process.argv.slice(2)) {
     verify: "\u68C0\u67E5\u5B89\u88C5\u7ED3\u679C",
     "resume-current-package": "\u4E0A\u6B21\u5B89\u88C5\u5C1A\u672A\u5199\u5165\u8FD0\u884C\u73AF\u5883\uFF0C\u5C06\u4F7F\u7528\u5F53\u524D\u7248\u672C\u91CD\u65B0\u68C0\u67E5"
   };
-  const progress = (stage) => console.log(`\u706B\u706B\uFF1A${labels[stage] ?? stage}`);
+  const installStages = ["preflight", "download", "install-runtime", "install-dependencies", "assemble-profiles", "verify"];
+  const progress = (stage) => {
+    const index = command === "start" ? installStages.indexOf(stage) : -1;
+    const step = index < 0 ? "" : `[${index + 1}/${installStages.length}] `;
+    console.log(`\u706B\u706B\uFF1A${step}${labels[stage] ?? stage}`);
+  };
+  const ui = installUI(assumeYes);
   if (command === "upgrade") {
-    const candidate = JSON.parse(await readFile7(releaseFile ?? join6(dirname5(fileURLToPath(import.meta.url)), "release.json"), "utf8"));
-    await upgrade(home, candidate, { fetcher: artifactSource(candidate, artifactDirectory), progress });
+    const candidate = selectRelease(JSON.parse(await readFile9(releaseFile ?? join8(dirname6(fileURLToPath2(import.meta.url)), "release.json"), "utf8")));
+    await upgrade(home, candidate, { fetcher: artifactSource(candidate, artifactDirectory), progress, ...ui });
     const current = await readInstallation(home);
     if (await control(home, current.releaseDigest, noOpen ? "status" : "open")) return;
-    await run(process.execPath, [join6(installationPaths(home, current.release).runtime, "lib/distribution/managed.js"), "start", home, ...noOpen ? ["--no-open"] : []], home);
+    await run(process.execPath, [join8(installationPaths(home, current.release).runtime, "lib/distribution/managed.js"), "start", home, ...noOpen ? ["--no-open"] : []], home);
     return;
   }
   if (command === "uninstall") {
@@ -1148,7 +1524,7 @@ async function main(args = process.argv.slice(2)) {
       return;
     }
     const paths = installationPaths(home, record.release);
-    const targets = [home, paths.directory, paths.environment, join6(home, "instances/default")];
+    const targets = [home, paths.directory, paths.environment, join8(home, "instances/default")];
     const resources = evaluateResources(await sampleResources(targets), record.release.budget, targets.map((path) => ({ path, bytes: 0 })), "start");
     console.log(JSON.stringify({
       home,
@@ -1169,33 +1545,34 @@ async function main(args = process.argv.slice(2)) {
     }
     const runtime = installationPaths(home, record.release).runtime;
     try {
-      await readFile7(join6(runtime, "lib/distribution/managed.js"));
+      await readFile9(join8(runtime, "lib/distribution/managed.js"));
     } catch (e) {
       if (e.code !== "ENOENT") throw e;
       record = void 0;
     }
   }
   if (!record || record.status !== "ready") {
-    let catalog = null;
-    if (!record || ["preflight", "download"].includes(record.stage)) {
+    const persisted = await readInstallation(home);
+    let source = persisted?.release;
+    if (!source) {
+      let catalog = null;
       try {
-        catalog = JSON.parse(await readFile7(releaseFile ?? join6(dirname5(fileURLToPath(import.meta.url)), "release.json"), "utf8"));
+        catalog = JSON.parse(await readFile9(releaseFile ?? join8(dirname6(fileURLToPath2(import.meta.url)), "release.json"), "utf8"));
       } catch (e) {
         if (e.code !== "ENOENT") throw e;
       }
+      source = selectRelease(catalog);
     }
-    const source = (await readInstallation(home))?.release ?? catalog;
     const fetcher = artifactSource(source, artifactDirectory);
-    const bundleDirectory = !releaseFile && !artifactDirectory ? join6(dirname5(fileURLToPath(import.meta.url)), "assets") : void 0;
-    record = await install(home, catalog, { fetcher, progress, bundleDirectory });
+    record = await install(home, source, { fetcher, progress, ...ui });
   }
   const installedHome = record.home;
-  await run(process.execPath, [join6(installationPaths(installedHome, record.release).runtime, "lib/distribution/managed.js"), "start", installedHome, ...noOpen ? ["--no-open"] : []], installedHome);
+  await run(process.execPath, [join8(installationPaths(installedHome, record.release).runtime, "lib/distribution/managed.js"), "start", installedHome, ...noOpen ? ["--no-open"] : []], installedHome);
 }
-if (process.argv[1] && await realpath5(resolve5(process.argv[1])).catch(() => "") === await realpath5(fileURLToPath(import.meta.url))) {
+if (process.argv[1] && await realpath5(resolve5(process.argv[1])).catch(() => "") === await realpath5(fileURLToPath2(import.meta.url))) {
   main().catch((error) => {
     console.error(error instanceof Error ? error.message : "\u5B89\u88C5\u6216\u542F\u52A8\u5931\u8D25");
-    process.exitCode = 1;
+    if (error?.code !== "INSTALL_CANCELLED") process.exitCode = 1;
   });
 }
 export {

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@pab-iprg/huohuo",
-  "version": "1.0.0-preview.3",
+  "version": "1.0.0-preview.5",
   "type": "module",
-  "description": "火火投研伙伴安装入口",
+  "description": "火火双平台安装入口（实验预览）",
   "bin": {
     "huohuo": "./cli.js"
   },
@@ -12,11 +12,14 @@
   "files": [
     "cli.js",
     "release.json",
-    "README.md",
-    "assets"
+    "README.md"
   ],
+  "optionalDependencies": {
+    "@pab-iprg/huohuo-assets-darwin-arm64": "1.0.0-preview.5",
+    "@pab-iprg/huohuo-assets-linux-x64": "1.0.0-preview.5"
+  },
   "publishConfig": {
     "access": "public",
-    "tag": "next"
+    "tag": "preview"
   }
 }

package/release.json

@@ -1,93 +1,205 @@
 {
+  "kind": "huohuo-release-catalog",
   "format": 1,
-  "bootstrapFormat": 1,
   "version": "1.0.0",
-  "nodeMajor": 24,
-  "npmMajor": 11,
-  "qualification": "qualified",
-  "platform": {
-    "os": "darwin",
-    "arch": "arm64",
-    "minimumOsRelease": "25.6.0"
-  },
-  "runtime": {
-    "name": "@huohuo/research-agent",
-    "version": "1.0.0",
-    "url": "https://bundled.invalid/99aad243ba1aa9749053a7c136aa6b8e4d8fe043075cb3dfca7853359cb94a76.tgz",
-    "sha256": "99aad243ba1aa9749053a7c136aa6b8e4d8fe043075cb3dfca7853359cb94a76",
-    "integrity": "sha512-mXfudYnjEC4Oqwrg6mrOjnu8Q+S5wAxbK/gTSeAyPTzPF5uj9jyqNaWLE+nXe+gc2IazdRRhBii917dFsLUZyA==",
-    "downloadBytes": 2543158,
-    "expandedBytes": 8239765,
-    "bundled": true
-  },
-  "python": {
-    "url": "https://github.com/astral-sh/python-build-standalone/releases/download/20261026/cpython-3.13.18%2B20261026-aarch64-apple-darwin-install_only_stripped.tar.gz",
-    "sha256": "8392b6ea51d94391befb2c31ebe75463f045d0b69dfcf5e1bb3234e1f5fa3405",
-    "downloadBytes": 25265774,
-    "expandedBytes": 66020864,
-    "redirectHosts": [
-      "release-assets.githubusercontent.com"
-    ],
-    "executable": "python/bin/python3",
-    "build": "cpython-3.13.18+20261026-aarch64-apple-darwin-install_only_stripped.tar.gz",
-    "license": "python/lib/python3.13/LICENSE.txt"
-  },
-  "pythonDependencies": {
-    "url": "https://bundled.invalid/4f008fe4491617729554e056ad59eee686ccc5d95c9f1d5259da705bf054ce21.tgz",
-    "sha256": "4f008fe4491617729554e056ad59eee686ccc5d95c9f1d5259da705bf054ce21",
-    "downloadBytes": 10235,
-    "expandedBytes": 15007,
-    "bundled": true
-  },
-  "dsh": {
-    "version": "0.2.1-rc.2",
-    "assemblySha256": "08cf11de70e49981b4891c0aaa2a5e7b872a95b6aa07557bb629713fa8f9e249"
-  },
-  "requirementsSha256": "57042fff45cee66fe33712472e2e5b88f03a084068ca20242588b2e18b3e167b",
-  "profilesSha256": "bdd628f3a599a69a9835db9904fb55d36c57e0b3486b4f3f7dbec8d8a47f36f0",
-  "budget": {
-    "minimumEffectiveMemoryBytes": 34359738368,
-    "startupHeadroomBytes": 134217728,
-    "heavyJobHeadroomBytes": 1073741824,
-    "diskReserveBytes": 1073741824,
-    "recoverySamples": 3,
-    "processTreeBudgetBytes": 17179869184,
-    "sampleIntervalMs": 2000,
-    "sampleMaxAgeMs": 10000,
-    "installTemporaryBytes": 1073741824,
-    "dependenciesBytes": 4294967296,
-    "backupBytes": 0
-  },
-  "schema": {
-    "minimum": 1,
-    "maximum": 1,
-    "migrationsSha256": "ba029fdbffa5320e61393b484d08accafce60e9aa8dacde5b6212fb79dd9146b",
-    "files": {
-      "001_init.sql": "b42b6192d872f0f65cfbbf9d0c7fb442d3aa49584a6cf321d3bcc641b31b70da",
-      "002_contact_decision.sql": "af82cb9975a09fa09c0f970b70d04a7b55a960d72e0853f4573d571efaa46f0a",
-      "003_schedules.sql": "2937f7be2693ce9b410ee9a73bd10c5e819c5081a10a6b3993c33f37ad42295f",
-      "004_condition_state.sql": "f081d250dd525ad57a450bd6bca59a75f8fb1428177d670ae9fa142ed79721d6",
-      "005_execution_handoff.sql": "ebf2e5c4890b7a73ae1ffb57a70bb15183f48a6c1fa2acf3a48b95ccb3d992b3",
-      "006_entity_confirmation.sql": "d25ee376e7f6dd55df2edeb68d7591ef5fbaa34eeb3eef662cd76e183526d3c0",
-      "007_research_tool_calls.sql": "df9c7d8d25b44b151f743e2d5167b34ae89c64e67423d8af554364fd792da942",
-      "008_followup_notifications.sql": "98865d811879afd679846087a5f01ee2db371dcb90381a9c400c940a5c1c4b37",
-      "008_investment.sql": "71cecf6215552c725797059efdcb501247e1225c7d9f662de606266d3a947e61",
-      "009_notification_channels.sql": "572424d739203a8514ae59920a0ad69cf83f278479b48d48becb88bddda25d9a",
-      "010_strategies.sql": "af023fab201db6bd2e15e2348125d112bc21cf3a59d8afd0a2d616fc05cee209",
-      "011_strategy_run_subjects.sql": "53a1c216ed775a06549dcc201f9494ceabe308bee6dc52a214b685cca2f2fe8d",
-      "012_strategy_schedule.sql": "ccddd81bb70d2c86356e6f1ad09132e7397837d17e926b515c8e281a362bdd58",
-      "014_industry_chain.sql": "b656efffe746d14ca350ea1c9ecfcce2d98b5753e4b2f862c75d0456a062fd4a",
-      "015_source_heads.sql": "652bf637892edbbe969ce5ed4ce45a4a0c43d03de395fce1b828fc4c0169f885",
-      "016_legacy_transfer.sql": "b6e3c214b103487d741226b0f83525e0cacbb0c440bd1935d0e963dc9b9bfd07",
-      "017_unified_strategy_work.sql": "8d055ca58f3e73482fb16c630c733ae93197244b37e4509cc90c7dec3bf88d60",
-      "018_personalization.sql": "7f62a4eb74707fb071f56d6057b6d6517ed7648af23ebe290f3be15d260a103c",
-      "019_position_risk.sql": "3c461fa435b352127fd4ee4e7ed3de2c924561a3727dce1535d7d3a47c436ca9",
-      "020_notification_tests.sql": "3eb0d72eadf04b074208dbe0ef6a72ee614ec11a15143108a2471568b7b4fb22",
-      "021_notification_priority.sql": "f742b4c4b796e918bfc6a08bac8c5ae206382075925acf7b1c430b033f5177e6",
-      "022_research_job_priority.sql": "fcb0c0af025806faab7cd403097a9d2c55e07331ab0a78b2926c1927a87f4ed4",
-      "023_adaptive_notifications.sql": "80630e2dad73844d48b265fbc33648b01d8321a6fd9a0587ef4dc01f362aadec",
-      "023_notification_attention.sql": "5dd85fb001192558211c7b69e3452984c52119f215750ed6283b296d3dccc842",
-      "024_t_trade_watch.sql": "aa38470ddab00e0cbca07ce6d5cc31399ba2b6e40c8d8d888e88ec093a9f89ef"
+  "releases": [
+    {
+      "format": 1,
+      "bootstrapFormat": 1,
+      "version": "1.0.0",
+      "nodeMajor": 24,
+      "npmMajor": 11,
+      "qualification": "controlled-acceptance-only",
+      "platform": {
+        "os": "darwin",
+        "arch": "arm64",
+        "minimumOsRelease": "25.6.0"
+      },
+      "runtime": {
+        "name": "@huohuo/research-agent",
+        "version": "1.0.0",
+        "url": "https://bundled.invalid/45b0bbe6c53759c5e1f50fbd506ea97ec74adf1f29b3ade98793210f3b66dfbc.tgz",
+        "bundled": true,
+        "sha256": "45b0bbe6c53759c5e1f50fbd506ea97ec74adf1f29b3ade98793210f3b66dfbc",
+        "integrity": "sha512-bFFRkVFn/4OgqU6CneroGm+qy0tP8hXaHZ4U0C6tW3DHGxvBX8c0gn0UTRYIRxrQUQ2QbcXbvcgAG7MsADw26A==",
+        "downloadBytes": 2609884,
+        "expandedBytes": 8326138
+      },
+      "python": {
+        "url": "https://github.com/astral-sh/python-build-standalone/releases/download/20261026/cpython-3.13.18%2B20261026-aarch64-apple-darwin-install_only_stripped.tar.gz",
+        "sha256": "8392b6ea51d94391befb2c31ebe75463f045d0b69dfcf5e1bb3234e1f5fa3405",
+        "downloadBytes": 25265774,
+        "expandedBytes": 66020864,
+        "redirectHosts": [
+          "release-assets.githubusercontent.com"
+        ],
+        "executable": "python/bin/python3",
+        "build": "cpython-3.13.18+20261026-aarch64-apple-darwin-install_only_stripped.tar.gz",
+        "license": "python/lib/python3.13/LICENSE.txt"
+      },
+      "pythonDependencies": {
+        "url": "https://bundled.invalid/61bbfd92aa43f2e1ae8e339a03e88efb145ae3266f00ef8fc979c8bc1ed502a5.tgz",
+        "bundled": true,
+        "sha256": "61bbfd92aa43f2e1ae8e339a03e88efb145ae3266f00ef8fc979c8bc1ed502a5",
+        "downloadBytes": 10215,
+        "expandedBytes": 20480,
+        "upstreamWheelCount": 39
+      },
+      "dsh": {
+        "version": "0.2.1-rc.2",
+        "assemblySha256": "08cf11de70e49981b4891c0aaa2a5e7b872a95b6aa07557bb629713fa8f9e249"
+      },
+      "requirementsSha256": "57042fff45cee66fe33712472e2e5b88f03a084068ca20242588b2e18b3e167b",
+      "profilesSha256": "aae1b5ee7f19d24d384a0f57de3e62ea9a1501e316193266d630f773dac058f1",
+      "budget": {
+        "minimumEffectiveMemoryBytes": 34359738368,
+        "startupHeadroomBytes": 134217728,
+        "heavyJobHeadroomBytes": 1073741824,
+        "diskReserveBytes": 1073741824,
+        "recoverySamples": 3,
+        "processTreeBudgetBytes": 17179869184,
+        "sampleIntervalMs": 2000,
+        "sampleMaxAgeMs": 10000,
+        "installTemporaryBytes": 1073741824,
+        "dependenciesBytes": 4294967296,
+        "backupBytes": 0,
+        "observedInstallRssBytes": 1904771072
+      },
+      "schema": {
+        "minimum": 1,
+        "maximum": 1,
+        "migrationsSha256": "ba029fdbffa5320e61393b484d08accafce60e9aa8dacde5b6212fb79dd9146b",
+        "files": {
+          "001_init.sql": "b42b6192d872f0f65cfbbf9d0c7fb442d3aa49584a6cf321d3bcc641b31b70da",
+          "002_contact_decision.sql": "af82cb9975a09fa09c0f970b70d04a7b55a960d72e0853f4573d571efaa46f0a",
+          "003_schedules.sql": "2937f7be2693ce9b410ee9a73bd10c5e819c5081a10a6b3993c33f37ad42295f",
+          "004_condition_state.sql": "f081d250dd525ad57a450bd6bca59a75f8fb1428177d670ae9fa142ed79721d6",
+          "005_execution_handoff.sql": "ebf2e5c4890b7a73ae1ffb57a70bb15183f48a6c1fa2acf3a48b95ccb3d992b3",
+          "006_entity_confirmation.sql": "d25ee376e7f6dd55df2edeb68d7591ef5fbaa34eeb3eef662cd76e183526d3c0",
+          "007_research_tool_calls.sql": "df9c7d8d25b44b151f743e2d5167b34ae89c64e67423d8af554364fd792da942",
+          "008_followup_notifications.sql": "98865d811879afd679846087a5f01ee2db371dcb90381a9c400c940a5c1c4b37",
+          "008_investment.sql": "71cecf6215552c725797059efdcb501247e1225c7d9f662de606266d3a947e61",
+          "009_notification_channels.sql": "572424d739203a8514ae59920a0ad69cf83f278479b48d48becb88bddda25d9a",
+          "010_strategies.sql": "af023fab201db6bd2e15e2348125d112bc21cf3a59d8afd0a2d616fc05cee209",
+          "011_strategy_run_subjects.sql": "53a1c216ed775a06549dcc201f9494ceabe308bee6dc52a214b685cca2f2fe8d",
+          "012_strategy_schedule.sql": "ccddd81bb70d2c86356e6f1ad09132e7397837d17e926b515c8e281a362bdd58",
+          "014_industry_chain.sql": "b656efffe746d14ca350ea1c9ecfcce2d98b5753e4b2f862c75d0456a062fd4a",
+          "015_source_heads.sql": "652bf637892edbbe969ce5ed4ce45a4a0c43d03de395fce1b828fc4c0169f885",
+          "016_legacy_transfer.sql": "b6e3c214b103487d741226b0f83525e0cacbb0c440bd1935d0e963dc9b9bfd07",
+          "017_unified_strategy_work.sql": "8d055ca58f3e73482fb16c630c733ae93197244b37e4509cc90c7dec3bf88d60",
+          "018_personalization.sql": "7f62a4eb74707fb071f56d6057b6d6517ed7648af23ebe290f3be15d260a103c",
+          "019_position_risk.sql": "3c461fa435b352127fd4ee4e7ed3de2c924561a3727dce1535d7d3a47c436ca9",
+          "020_notification_tests.sql": "3eb0d72eadf04b074208dbe0ef6a72ee614ec11a15143108a2471568b7b4fb22",
+          "021_notification_priority.sql": "f742b4c4b796e918bfc6a08bac8c5ae206382075925acf7b1c430b033f5177e6",
+          "022_research_job_priority.sql": "fcb0c0af025806faab7cd403097a9d2c55e07331ab0a78b2926c1927a87f4ed4",
+          "023_adaptive_notifications.sql": "80630e2dad73844d48b265fbc33648b01d8321a6fd9a0587ef4dc01f362aadec",
+          "023_notification_attention.sql": "5dd85fb001192558211c7b69e3452984c52119f215750ed6283b296d3dccc842",
+          "024_t_trade_watch.sql": "aa38470ddab00e0cbca07ce6d5cc31399ba2b6e40c8d8d888e88ec093a9f89ef"
+        }
+      },
+      "assetPackage": {
+        "name": "@pab-iprg/huohuo-assets-darwin-arm64",
+        "version": "1.0.0-preview.5"
+      }
+    },
+    {
+      "format": 1,
+      "bootstrapFormat": 1,
+      "version": "1.0.0",
+      "nodeMajor": 24,
+      "npmMajor": 11,
+      "qualification": "controlled-acceptance-only",
+      "platform": {
+        "os": "linux",
+        "arch": "x64",
+        "minimumOsRelease": "6.8.0",
+        "libc": "glibc"
+      },
+      "runtime": {
+        "name": "@huohuo/research-agent",
+        "version": "1.0.0",
+        "url": "https://bundled.invalid/4bab6aed6c844ab711d0a91b27c2e108ca8d4f4de1f4b30f7668b73f922d8500.tgz",
+        "bundled": true,
+        "sha256": "4bab6aed6c844ab711d0a91b27c2e108ca8d4f4de1f4b30f7668b73f922d8500",
+        "integrity": "sha512-Iu0NMfgVLZmPXcxcUfYbW48X0uvHFDUzpQWhPP6unz06v2G1f178m10ehU0pxNzJaUXkwg/p8OH5/DAeuungRg==",
+        "downloadBytes": 2609889,
+        "expandedBytes": 8326156
+      },
+      "python": {
+        "url": "https://github.com/astral-sh/python-build-standalone/releases/download/20261026/cpython-3.13.18%2B20261026-x86_64-unknown-linux-gnu-install_only_stripped.tar.gz",
+        "sha256": "df15fe60d3ff55bf9dcf25824b5572756bb8816ff93865a273d3301d7066a8b7",
+        "downloadBytes": 35395906,
+        "expandedBytes": 102403072,
+        "redirectHosts": [
+          "release-assets.githubusercontent.com"
+        ],
+        "executable": "python/bin/python3",
+        "build": "cpython-3.13.18+20261026-x86_64-unknown-linux-gnu-install_only_stripped.tar.gz",
+        "license": "python/lib/python3.13/LICENSE.txt"
+      },
+      "pythonDependencies": {
+        "url": "https://bundled.invalid/7e42648979228aa347ad334e4d40271a2c3dd78b76ebf6c5c557b0fd8fe36ec2.tgz",
+        "bundled": true,
+        "sha256": "7e42648979228aa347ad334e4d40271a2c3dd78b76ebf6c5c557b0fd8fe36ec2",
+        "downloadBytes": 10367,
+        "expandedBytes": 20480,
+        "upstreamWheelCount": 40
+      },
+      "dsh": {
+        "version": "0.2.1-rc.2",
+        "assemblySha256": "08cf11de70e49981b4891c0aaa2a5e7b872a95b6aa07557bb629713fa8f9e249"
+      },
+      "requirementsSha256": "d4ff8161886fc286e6f8ddfcd070ac5812528971affe7b87baa03662dd242d45",
+      "profilesSha256": "aae1b5ee7f19d24d384a0f57de3e62ea9a1501e316193266d630f773dac058f1",
+      "budget": {
+        "minimumEffectiveMemoryBytes": 8589934592,
+        "startupHeadroomBytes": 1073741824,
+        "heavyJobHeadroomBytes": 1073741824,
+        "processTreeBudgetBytes": 4294967296,
+        "diskReserveBytes": 1073741824,
+        "recoverySamples": 3,
+        "sampleIntervalMs": 2000,
+        "sampleMaxAgeMs": 10000,
+        "installTemporaryBytes": 1073741824,
+        "dependenciesBytes": 4294967296,
+        "backupBytes": 1073741824
+      },
+      "schema": {
+        "minimum": 1,
+        "maximum": 1,
+        "migrationsSha256": "ba029fdbffa5320e61393b484d08accafce60e9aa8dacde5b6212fb79dd9146b",
+        "files": {
+          "001_init.sql": "b42b6192d872f0f65cfbbf9d0c7fb442d3aa49584a6cf321d3bcc641b31b70da",
+          "002_contact_decision.sql": "af82cb9975a09fa09c0f970b70d04a7b55a960d72e0853f4573d571efaa46f0a",
+          "003_schedules.sql": "2937f7be2693ce9b410ee9a73bd10c5e819c5081a10a6b3993c33f37ad42295f",
+          "004_condition_state.sql": "f081d250dd525ad57a450bd6bca59a75f8fb1428177d670ae9fa142ed79721d6",
+          "005_execution_handoff.sql": "ebf2e5c4890b7a73ae1ffb57a70bb15183f48a6c1fa2acf3a48b95ccb3d992b3",
+          "006_entity_confirmation.sql": "d25ee376e7f6dd55df2edeb68d7591ef5fbaa34eeb3eef662cd76e183526d3c0",
+          "007_research_tool_calls.sql": "df9c7d8d25b44b151f743e2d5167b34ae89c64e67423d8af554364fd792da942",
+          "008_followup_notifications.sql": "98865d811879afd679846087a5f01ee2db371dcb90381a9c400c940a5c1c4b37",
+          "008_investment.sql": "71cecf6215552c725797059efdcb501247e1225c7d9f662de606266d3a947e61",
+          "009_notification_channels.sql": "572424d739203a8514ae59920a0ad69cf83f278479b48d48becb88bddda25d9a",
+          "010_strategies.sql": "af023fab201db6bd2e15e2348125d112bc21cf3a59d8afd0a2d616fc05cee209",
+          "011_strategy_run_subjects.sql": "53a1c216ed775a06549dcc201f9494ceabe308bee6dc52a214b685cca2f2fe8d",
+          "012_strategy_schedule.sql": "ccddd81bb70d2c86356e6f1ad09132e7397837d17e926b515c8e281a362bdd58",
+          "014_industry_chain.sql": "b656efffe746d14ca350ea1c9ecfcce2d98b5753e4b2f862c75d0456a062fd4a",
+          "015_source_heads.sql": "652bf637892edbbe969ce5ed4ce45a4a0c43d03de395fce1b828fc4c0169f885",
+          "016_legacy_transfer.sql": "b6e3c214b103487d741226b0f83525e0cacbb0c440bd1935d0e963dc9b9bfd07",
+          "017_unified_strategy_work.sql": "8d055ca58f3e73482fb16c630c733ae93197244b37e4509cc90c7dec3bf88d60",
+          "018_personalization.sql": "7f62a4eb74707fb071f56d6057b6d6517ed7648af23ebe290f3be15d260a103c",
+          "019_position_risk.sql": "3c461fa435b352127fd4ee4e7ed3de2c924561a3727dce1535d7d3a47c436ca9",
+          "020_notification_tests.sql": "3eb0d72eadf04b074208dbe0ef6a72ee614ec11a15143108a2471568b7b4fb22",
+          "021_notification_priority.sql": "f742b4c4b796e918bfc6a08bac8c5ae206382075925acf7b1c430b033f5177e6",
+          "022_research_job_priority.sql": "fcb0c0af025806faab7cd403097a9d2c55e07331ab0a78b2926c1927a87f4ed4",
+          "023_adaptive_notifications.sql": "80630e2dad73844d48b265fbc33648b01d8321a6fd9a0587ef4dc01f362aadec",
+          "023_notification_attention.sql": "5dd85fb001192558211c7b69e3452984c52119f215750ed6283b296d3dccc842",
+          "024_t_trade_watch.sql": "aa38470ddab00e0cbca07ce6d5cc31399ba2b6e40c8d8d888e88ec093a9f89ef"
+        }
+      },
+      "assetPackage": {
+        "name": "@pab-iprg/huohuo-assets-linux-x64",
+        "version": "1.0.0-preview.5"
+      }
     }
-  }
+  ]
 }