@walkhi/code-relax 0.1.0-beta.15 → 0.1.0-beta.17

package/README.md

@@ -1,6 +1,6 @@
-# Code Relax Bridge（Windows 私测包）
+# Code Relax 桌面服务（Windows 私测包）
 
-Bridge 让 HarmonyOS 客户端控制 Windows 上的受管 Codex 内核。当前要求 Windows x64、Node >=22.12，以及已登录的 Codex Desktop 配套内核或独立 Codex CLI；npm 包不包含 Node，也不修改官方程序文件。
+桌面服务让 HarmonyOS 客户端控制 Windows 上的Codex 内核。当前要求 Windows x64、Node >=22.12，以及已登录的 Codex Desktop 配套内核或独立 Codex CLI；npm 包不包含 Node，也不修改官方程序文件。
 
 ## 安装
 
@@ -10,38 +10,38 @@ Bridge 让 HarmonyOS 客户端控制 Windows 上的受管 Codex 内核。当前
 npm i -g @walkhi/code-relax@beta --allow-scripts=@walkhi/code-relax --foreground-scripts
 ```
 
-首次安装前先保存工作，并从 Codex 菜单或 Windows 托盘完全退出 Codex。更新无需先停止正在运行的 Bridge；安装器会短暂停止、替换并恢复服务。npm 全局安装会自动执行 `setup` 和 Skill 安装。`setup` 将完整服务部署到 `%LOCALAPPDATA%\Programs\CodexRemote\service`，记录安装所用 Node 的绝对路径，不复制 Node。配置、日志和二维码以 `installation.json.stateRoot` 为准，通常位于 `%LOCALAPPDATA%\CodexRemote`，MSIX 环境可能解析到包缓存目录；附件位于 `%ProgramData%\CodexRemote\attachments`。
+首次安装前先保存工作，并从 Codex 菜单或 Windows 托盘完全退出 Codex。更新无需先停止正在运行的桌面服务；安装器会短暂停止、替换并恢复服务。npm 全局安装会自动执行 `setup` 和 Skill 安装。`setup` 将完整服务部署到 `%LOCALAPPDATA%\Programs\CodexRemote\service`，记录安装所用 Node 的绝对路径，不复制 Node。配置、日志和二维码以 `installation.json.stateRoot` 为准，通常位于 `%LOCALAPPDATA%\CodexRemote`，MSIX 环境可能解析到包缓存目录；附件位于 `%ProgramData%\CodexRemote\attachments`。
 
-`setup` 立即启动 Bridge 和固定 45839 受管 app-server，并启用当前用户登录自启；自启不打开 Codex。受管实例健康后配置当前用户 `CODEX_APP_SERVER_WS_URL`，之后正常启动的 Desktop 自动接入。若安装时 Desktop 仍未接入，安装器会关闭并重新打开 Desktop；安装前应保存工作。普通更新无接入或启动链迁移需求时复用现有内核。
+`setup` 立即启动桌面服务和固定 45839 Codex 内核，并启用当前用户登录自启；自启不打开 Codex。Codex 内核健康后配置当前用户 `CODEX_APP_SERVER_WS_URL`，之后正常启动的 Desktop 自动接入。若安装时 Desktop 仍未接入，安装器会关闭并重新打开 Desktop；安装前应保存工作。普通更新无接入或启动链迁移需求时复用现有内核。
 
 ## Codex 内核
 
 ```powershell
-relax start           # 启动/复用 Bridge、受管 Codex 内核和已配置中继
+relax start           # 启动/复用桌面服务、Codex 内核和已配置的 Code Relax 中继
 relax pair            # 启动/复用服务并打开配对二维码
 relax doctor          # 集中查看服务、登录自启和最近恢复结果
 ```
 
-Codex 内核由官方 `codex app-server --listen ws://127.0.0.1:45839` 提供执行服务，Desktop 和 Bridge 均可连接；它只监听回环地址。Bridge 独立报告内核健康、Desktop 接入和手机可写状态；Desktop 退出后，手机仍可操作内核中的任务。同一 thread 已被另一个实例持有时，手机只读且可重新检测。
+Codex 内核由官方 `codex app-server --listen ws://127.0.0.1:45839` 提供执行服务，Desktop 和桌面服务均可连接；它只监听回环地址。桌面服务独立报告内核健康、Desktop 接入和手机可写状态；Desktop 退出后，手机仍可操作内核中的任务。同一 thread 已被另一个实例持有时，手机只读且可重新检测。
 
-手机工作站详情可确认让 Desktop 接入 Codex 内核，独立进程逐步执行并保留 Bridge/中继连接，见[启用流程](../docs/shared-recovery.md)。本机恢复命令为 `relax desktop-recover --confirm`，查看恢复结果用 `relax doctor`。Bridge 状态匹配且健康时直接复用；未知进程占用 45831/45839 时拒绝接管。
+手机工作站详情可确认让 Desktop 接入Codex 内核，独立进程逐步执行并保留桌面服务/中继连接，见[启用流程](../docs/shared-recovery.md)。本机恢复命令为 `relax desktop-recover --confirm`，查看恢复结果用 `relax doctor`。桌面服务状态匹配且健康时直接复用；未知进程占用 45831/45839 时拒绝接管。
 
-受管 app-server 通过隐藏控制台启动，使后续控制台子进程继承隐藏窗口。手机的项目、任务列表和新建任务均使用受管内核，不依赖 Desktop 工具管道；项目和任务 ID 保持原生值。
+Codex 内核通过隐藏控制台启动，使后续控制台子进程继承隐藏窗口。手机的项目、任务列表和新建任务均使用Codex 内核，不依赖 Desktop 工具管道；项目和任务 ID 保持原生值。
 
-受管 app-server 未就绪时，手机停留在连接界面并显示“Codex 内核未就绪”；Bridge 保留健康和恢复接口，聊天请求返回错误。
+Codex 内核未就绪时，手机停留在连接界面并显示“Codex 内核未就绪”；桌面服务保留健康和恢复接口，聊天请求返回错误。
 
 ## Code Relax 中继
 
-私有中继仍需要本机 Bridge：
+私有中继仍需要本机桌面服务：
 
 ```powershell
 relax start --json
 relax pair --json
 ```
 
-`start` 启动内核和 Bridge，并在 Bridge 内恢复已配置中继。每台移动设备通过 `pair` 配对一次；新增设备不替换已有设备。Bridge 把 Windows hostname 和当前 Wi-Fi/有线网络候选经已认证 WebSocket 临时发送给手机，手机本地保存电脑名，只在设备身份验证通过后保存可达地址；服务器不持久化这些 Code Relax 中继 hostname、IP 或网络名。OpenAI 官方认证和设备配对仍直接访问 OpenAI；完成后，手机使用统一配对产生的设备凭据，通过独立元数据 WebSocket 把官方环境 ID、名称和 hostname 写入设备记录，不上传 OpenAI access token、配对码或登录态。
+`start` 启动内核和桌面服务，并在桌面服务内恢复已配置中继。每台移动设备通过 `pair` 配对一次；新增设备不替换已有设备。桌面服务把 Windows hostname 和当前 Wi-Fi/有线网络候选经已认证 WebSocket 临时发送给手机，手机本地保存电脑名，只在设备身份验证通过后保存可达地址；服务器不持久化这些 Code Relax 中继 hostname、IP 或网络名。OpenAI 官方认证和设备配对仍直接访问 OpenAI；完成后，手机使用统一配对产生的设备凭据，通过独立元数据 WebSocket 把官方环境 ID、名称和 hostname 写入设备记录，不上传 OpenAI access token、配对码或登录态。
 
-Bridge 的局域网端口仅提供鉴权 WebSocket，普通 HTTP 请求返回 404；手机聊天页面随 HAP 安装。
+桌面服务的局域网端口仅提供鉴权 WebSocket，普通 HTTP 请求返回 404；手机聊天页面随 HAP 安装。
 
 ## 更新与卸载
 
@@ -51,7 +51,7 @@ Bridge 的局域网端口仅提供鉴权 WebSocket，普通 HTTP 请求返回 40
 npm i -g @walkhi/code-relax@beta --allow-scripts=@walkhi/code-relax --foreground-scripts
 ```
 
-`setup` 先暂存并校验新版本，再短暂停止 Bridge/中继完成切换；原服务此前正在运行时会自动恢复，新版本启动失败则回滚并启动旧版本。无需提前停止服务。Node 路径变化或原 Node 被删除后需重新 setup。升级可能因 Node 可执行文件路径变化而再次触发 Windows 防火墙授权。
+`setup` 先暂存并校验新版本，再短暂停止桌面服务/中继完成切换；原服务此前正在运行时会自动恢复，新版本启动失败则回滚并启动旧版本。无需提前停止服务。Node 路径变化或原 Node 被删除后需重新 setup。升级可能因 Node 可执行文件路径变化而再次触发 Windows 防火墙授权。
 
 卸载：
 
@@ -60,7 +60,7 @@ relax uninstall
 npm uninstall -g @walkhi/code-relax
 ```
 
-`uninstall` 停止 Bridge 后先核对并清理 Code Relax 所有的当前用户 `CODEX_APP_SERVER_WS_URL`；用户后来修改或不归属 Code Relax 的值会保留。随后删除固定程序和本包管理且未修改的 Skill；保留其他配置、Token、日志、长期设备凭据、附件和自定义 Skill。它不卸载 Node、Codex Desktop，也不强制结束完整控制的执行进程。
+`uninstall` 停止桌面服务后先核对并清理 Code Relax 所有的当前用户 `CODEX_APP_SERVER_WS_URL`；用户后来修改或不归属 Code Relax 的值会保留。随后删除固定程序和本包管理且未修改的 Skill；保留其他配置、Token、日志、长期设备凭据、附件和自定义 Skill。它不卸载 Node、Codex Desktop，也不强制结束完整控制的执行进程。
 
 ## 发布边界
 

package/dist/bin/codex-remote.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { phonePairingSteps, desktopSetupSteps, pairingDisplayText } from '../src/onboarding.mjs';
-import { lifecycle, readRecord } from '../src/service-lifecycle.mjs';
+import { lifecycle, readRecord, writeRecord } from '../src/service-lifecycle.mjs';
 import { runtimePaths } from '../src/platform/windows/runtime-paths.mjs';
 import * as host from '../src/platform/windows/service-host.mjs';
 import { installService, uninstallService, packageRoot } from '../src/service-install.mjs';
@@ -23,17 +23,27 @@ import { processAlive } from '../src/background-process.mjs';
 const help = `Code Relax（Windows）
 用法：relax <命令> [--json]；下列命令均可用
 常用指令：
-  start   启动或复用 Bridge 和 Codex 内核，并恢复已配置的私有中继
-  pair    启动或复用工作站服务，并打开一次性配对二维码
+  start   启动或复用桌面服务和 Codex 内核，并恢复已配置的 Code Relax 中继
+  pair    启动或复用桌面服务，并打开一次性配对二维码
 维护指令：
-  setup   部署并启动固定目录服务、受管 app-server 和登录自启动；安全配置 Desktop 后续接入
+  setup   部署并启动桌面服务、Codex 内核和登录自启动；安全配置 Desktop 后续接入
   doctor  检查服务、登录自启、最近恢复结果、网络和 Skill
   desktop-recover --confirm 重新打开 Desktop 并接入 Codex 内核；不强制重启已有内核
   uninstall 停止并移除固定目录服务和本包 Skill，清理自有 Desktop 环境变量，保留其他配置与附件
 默认监听 0.0.0.0，移动端与电脑需在同一受信任局域网。
---json 输出机器可读结果；统一二维码不含 LAN 地址、Bridge Token 或中继地址。`;
+--json 输出机器可读结果；统一二维码不含 LAN 地址、桌面服务凭据或中继地址。`;
+
+function currentNodeExecutable() {
+  const link = process.env.NVM_SYMLINK && path.join(process.env.NVM_SYMLINK, 'node.exe');
+  if (link && fs.existsSync(link)) {
+    try {
+      if (fs.realpathSync(link).toLowerCase() === fs.realpathSync(process.execPath).toLowerCase()) return link;
+    } catch {}
+  }
+  return process.execPath;
+}
 
-async function main() {
+async function main() {
   const [command, ...flags] = process.argv.slice(2);
   if (!command || command === '--help' || command === '-h') {
     console.log(help);
@@ -46,11 +56,20 @@ async function main() {
   if (process.platform !== 'win32') throw new Error('当前被控端仅支持 Windows。');
   const json = flags.includes('--json');
   const paths = runtimePaths();
-  const { stateRoot, serviceRoot } = paths;
-  const installedEntry = path.join(serviceRoot, 'dist/bin/codex-remote.mjs');
-  if (['desktop-recover', 'start', 'pair'].includes(command) && path.resolve(fileURLToPath(import.meta.url)).toLowerCase() !== installedEntry.toLowerCase()) {
+  const { stateRoot, serviceRoot } = paths;
+  const installedEntry = path.join(serviceRoot, 'dist/bin/codex-remote.mjs');
+  const installationPath = path.join(serviceRoot, 'installation.json');
+  const [nodeMajor, nodeMinor] = process.versions.node.split('.').map(Number);
+  const currentNodeSupported = nodeMajor > 22 || (nodeMajor === 22 && nodeMinor >= 12);
+  const installed = path.resolve(fileURLToPath(import.meta.url)).toLowerCase() === installedEntry.toLowerCase();
+  const installation = readRecord(installationPath);
+  if (installation?.nodeExecutable && !fs.existsSync(installation.nodeExecutable) && currentNodeSupported
+    && ['start', 'pair', 'doctor'].includes(command)) {
+    writeRecord(installationPath, { ...installation, nodeExecutable: currentNodeExecutable() });
+  }
+  if (['desktop-recover', 'start', 'pair'].includes(command) && !installed) {
     if (!fs.existsSync(installedEntry)) throw new Error('尚未部署服务，请先执行 relax setup。');
-    const executable = readRecord(path.join(serviceRoot, 'installation.json'))?.nodeExecutable;
+    const executable = readRecord(installationPath)?.nodeExecutable;
     if (!executable || !fs.existsSync(executable)) throw new Error('安装时选用的 Node 不存在，请重新执行 relax setup。');
     const child = spawn(executable, [installedEntry, command, ...flags], { stdio: 'inherit', windowsHide: true });
     const code = await new Promise((resolve, reject) => { child.once('error', reject); child.once('exit', resolve); });
@@ -59,21 +78,12 @@ async function main() {
   }
   const service = lifecycle({ stateRoot, host });
   const ensureAutostart = async () => {
-    const installation = readRecord(path.join(serviceRoot, 'installation.json'));
-    if (!installation?.nodeExecutable) throw new Error('请先执行 setup。');
-    const current = await residentStartup({ serviceRoot, nodeExecutable: installation.nodeExecutable }, 'status');
+    const currentInstallation = readRecord(installationPath);
+    if (!currentInstallation?.nodeExecutable) throw new Error('请先执行 setup。');
+    const startup = { serviceRoot, nodeExecutable: currentInstallation.nodeExecutable };
+    const current = await residentStartup(startup, 'status');
     if (current.enabled) return { ...current, repaired: false };
-    const running = await service.status();
-    if (!running.running) await service.start();
-    const deadline = Date.now() + 35000;
-    while (true) {
-      const ready = await service.status();
-      if (ready.running && ready.managedAppServer?.ready) break;
-      if (Date.now() >= deadline) throw new Error('Codex 内核未就绪，未启用 Desktop 自动接入。');
-      await delay(250);
-    }
-    const result = await residentStartup({ serviceRoot, nodeExecutable: installation.nodeExecutable }, 'enable');
-    if ((await desktopHost.inspect()).desktop) await configureManagedEnvironment(stateRoot);
+    const result = await residentStartup(startup, 'enable');
     return { ...result, repaired: true };
   };
   if (command === 'desktop-recover') {
@@ -83,13 +93,13 @@ async function main() {
     return;
   }
   if (command === 'pair') {
+    await ensureAutostart();
     let bridge = await service.status();
     if (!bridge.running) {
       await service.start();
       bridge = await service.status();
     }
     if (!bridge.running) throw new Error('Code Relax 工作站服务未能启动。');
-    await ensureAutostart();
     const result = await selfRelay('relay-pair', stateRoot);
     if (!json && result.qrPath) {
       const viewer = spawn('explorer.exe', [result.qrPath], { detached: true, stdio: 'ignore', windowsHide: true });
@@ -142,7 +152,7 @@ async function main() {
     const legacyRelaySession = readRecord(path.join(stateRoot, 'self-relay-session.json'));
     const previousRelay = legacyRelaySession ? await controlRequest(legacyRelaySession) : await selfRelay('relay-status', stateRoot);
     const resumeAfterUpdate = previous.processRunning || previousRelay.running;
-    const executable = fs.realpathSync(process.execPath);
+    const executable = currentNodeExecutable();
     const startInstalled = async () => {
       const entry = path.join(serviceRoot, 'dist/bin/codex-remote.mjs');
       const child = spawn(executable, [entry, 'start', '--json'], { windowsHide: true, stdio: ['ignore', 'ignore', 'pipe'] });
@@ -152,7 +162,7 @@ async function main() {
       if (code) {
         try { await selfRelay('relay-stop', stateRoot); } catch {}
         try { await service.stop(); } catch {}
-        throw new Error(errors.trim().replace(/^(?:Code Relax：)+/u, '') || 'Bridge 启动失败');
+        throw new Error(errors.trim().replace(/^(?:Code Relax：)+/u, '') || '桌面服务启动失败');
       }
     };
     let stoppedForUpdate = false;
@@ -173,6 +183,7 @@ async function main() {
       verifyActivation: async () => { await startInstalled(); },
       restoreActivation: async () => { if (stoppedForUpdate) await startInstalled(); },
     });
+    const autostart = await residentStartup(installed, 'enable');
     const deadline = Date.now() + 35_000;
     let bridge = await service.status();
     while (bridge.running && !['ready', 'failed'].includes(bridge.managedAppServer?.state) && Date.now() < deadline) {
@@ -180,7 +191,7 @@ async function main() {
       bridge = await service.status();
     }
     if (!bridge.running || bridge.managedAppServer?.state !== 'ready') {
-      throw new Error(bridge.managedAppServer?.error || 'Bridge 已安装，但受管 app-server 未就绪；未写入 Desktop 环境变量。');
+      throw new Error(bridge.managedAppServer?.error || '桌面服务已安装，但 Codex 内核未就绪；未写入 Desktop 环境变量。');
     }
     const environment = desktopBeforeSetup.desktop
       ? await configureManagedEnvironment(physicalStateRoot) : { configured: false, reason: 'desktop-not-installed' };
@@ -203,11 +214,11 @@ async function main() {
         await delay(250);
         bridge = await service.status();
         if (bridge.managedAppServer?.restart?.status === 'failed') {
-          throw new Error(bridge.managedAppServer.restart.error || '受管 app-server 启动链迁移失败。');
+          throw new Error(bridge.managedAppServer.restart.error || 'Codex 内核启动链迁移失败。');
         }
       } while (Date.now() < migrationDeadline && (!bridge.running || bridge.managedAppServer?.state !== 'ready' || bridge.managedAppServer.launcherRestartRequired));
       if (!bridge.running || bridge.managedAppServer?.state !== 'ready' || bridge.managedAppServer.launcherRestartRequired) {
-        throw new Error('受管 app-server 未在 40 秒内完成启动链迁移。');
+        throw new Error('Codex 内核未在 40 秒内完成启动链迁移。');
       }
       managedAppServerMigrated = true;
       managedAppServerMigration.restarted = true;
@@ -218,7 +229,6 @@ async function main() {
         bridge = await service.status();
       }
     }
-    const autostart = await ensureAutostart();
     const skill = installSkill(path.join(serviceRoot, 'dist/skills/code-relax/SKILL.md'));
     if (desktopNeedsAttach && !desktopRestarted) {
       const currentDesktop = await desktopHost.inspect();
@@ -242,15 +252,15 @@ async function main() {
     installed.desktopRestartReason = desktopRestartReason;
     const migrationText = managedAppServerMigrated ? '已自动重建旧启动链的 app-server；安装前尚未完成的任务可能已中断。\n' : '';
     const restartText = desktopRestarted
-      ? 'Codex Desktop 已干净重启并重新接入受管 app-server。'
-      : desktopBeforeSetup.desktop ? 'Codex Desktop 使用同一受管 app-server；移动端控制不依赖 Desktop 是否打开。'
+      ? 'Codex Desktop 已干净重启并重新接入 Codex 内核。'
+      : desktopBeforeSetup.desktop ? 'Codex Desktop 使用同一 Codex 内核；移动端控制不依赖 Desktop 是否打开。'
       : '使用独立 Codex CLI；无需安装 Codex Desktop。';
-    console.log(json ? JSON.stringify({ ...installed, nextSteps: desktopSetupSteps, displayText: `${migrationText}${desktopSetupSteps.join('\n')}\n${restartText}` }) : `服务已安装：${installed.serviceRoot}\n使用已安装的 Node：${installed.nodeExecutable}\n受管 app-server 已就绪；首次联网可能需要 Windows 防火墙授权。\n${migrationText}${desktopSetupSteps.join('\n')}\n${restartText}`);
+    console.log(json ? JSON.stringify({ ...installed, nextSteps: desktopSetupSteps, displayText: `${migrationText}${desktopSetupSteps.join('\n')}\n${restartText}` }) : `桌面服务已安装：${installed.serviceRoot}\n使用已安装的 Node：${installed.nodeExecutable}\nCodex 内核已就绪；首次联网可能需要 Windows 防火墙授权。\n${migrationText}${desktopSetupSteps.join('\n')}\n${restartText}`);
     return;
   }
-  if (!json && command === 'start') console.log('正在检查电脑连接并准备 Bridge…');
-  const result = await service[command]();
+  if (!json && command === 'start') console.log('正在检查电脑连接并准备桌面服务…');
   await ensureAutostart();
+  const result = await service[command]();
   const { accessUrl, qrPath: _legacyQrPath, ...metadata } = result;
   const notice = '本机服务检查通过，移动端连通性尚未验证。若电脑弹出 Node 网络访问提示，请先处理 Windows 防火墙授权，再用移动端连接。';
   let relay;
@@ -263,7 +273,7 @@ async function main() {
     lanAccess: 'unverified', notice };
   if (json) console.log(JSON.stringify(output));
   else {
-    console.log('电脑连接检查通过 · Bridge 已就绪');
+    console.log('电脑连接检查通过 · 桌面服务已就绪');
     console.log(`局域网模式：监听 0.0.0.0:${result.port}，连接地址 ${output.address}，PID ${result.pid}`);
     if (relay?.qrPath) console.log(`配对二维码：${relay.qrPath}`);
     console.log(displayText);

package/dist/bin/self-relay-demo.mjs

@@ -25,7 +25,7 @@ try {
   const health = await client.request('/api/health');
   if (health.status !== 200 || health.body.transportMode !== mode) throw new Error('Relay validation failed');
   console.log(JSON.stringify({ ok: true, simulated: true, mode, relay: demo.relay.url,
-    bridge: demo.bridgeUrl, message: '中继 → 连接器 → 模拟 Bridge 已连通；未连接 Codex，未执行任务。' }, null, 2));
+    bridge: demo.bridgeUrl, message: '中继 → 连接器 → 模拟桌面服务已连通；未连接 Codex，未执行任务。' }, null, 2));
   if (!process.argv.includes('--check')) {
     console.log('验证连接保持运行。Ctrl+C 停止全部模拟进程内服务。');
     await new Promise(resolve => { process.once('SIGINT', resolve); process.once('SIGTERM', resolve); });

package/dist/skills/code-relax/SKILL.md

@@ -1,17 +1,17 @@
 ---
 name: code-relax
-description: 启动、检查或停止 Code Relax 工作站服务，生成并展示配对二维码。
+description: 启动或检查 Code Relax 桌面服务，生成并展示配对二维码。
 ---
 
 # Code Relax
 
-- `relax start --json` 启动 Bridge 和受管 Codex 内核，无需打开 Desktop；支持纯 CLI 安装。Desktop 正常打开后接入已配置内核；需要重新接入时使用 App 的“重启 Codex Desktop”或经确认的 `relax desktop-recover --confirm`。已配置 Code Relax 中继时，启动命令同时恢复中继连接器和已有设备授权。
+- `relax start --json` 启动桌面服务和 Codex 内核，无需打开 Desktop；支持纯 CLI 安装。Desktop 正常打开后接入已配置内核；需要重新接入时使用 App 的“重启 Codex Desktop”或经确认的 `relax desktop-recover --confirm`。已配置 Code Relax 中继时，启动命令同时恢复中继连接器和已有设备授权。
 - npm 全局安装会自动执行服务部署和 Skill 安装；修复安装时运行 `relax setup --json`。
-- `setup` 默认启用当前用户登录启动工作站服务，不自动打开 Codex；`start`、`pair`、`setup` 和 `doctor` 在自启缺失时自动恢复。恢复完整控制会保留 Bridge 和中继，但仍须明确确认可能中断全部完整控制任务。
+- `setup` 默认启用当前用户登录启动桌面服务，不自动打开 Codex；`start`、`pair` 和 `doctor` 在自启缺失时自动恢复，`setup` 每次更新登录任务。恢复 Codex Desktop 接入会保留桌面服务和中继，但仍须明确确认可能中断正在运行的任务。
 - 用户要求启动 Code Relax 时，执行一次 `relax start --json`。用户要求二维码或当前启动结果包含二维码时，展示 CLI 返回的 `qrPath` 和 `displayText`；没有设备授权时可用 `relax pair --json` 生成新的配对二维码。
-- 配对二维码是短期 HTTPS 邀请，不属于工作站或某一台移动设备，也不含 LAN IP、端口、Bridge Token 或中继地址。新增设备不撤销已有设备。
+- 配对二维码是短期 HTTPS 邀请，不属于工作站或某一台移动设备，也不含 LAN IP、端口、桌面服务凭据或中继地址。新增设备不撤销已有设备。
 - 已授权设备可直接使用 Code Relax 中继。App 以工作站名显示已配对电脑，进入后选择局域网、Code Relax 中继或 OpenAI 中继。启动命令会经已认证中继临时刷新当前 LAN 候选；App 只保存设备凭据验证成功的网络记录。
-- `status --json` 查询工作站服务；`stop --json` 停止 Bridge，不停止受管 Codex 内核。中继连接由 Bridge 管理，不提供单独的中继 CLI 命令。
+- `relax doctor --json` 检查桌面服务、Codex 内核和登录自启动状态。中继连接由桌面服务管理，不提供单独的中继 CLI 命令。
 - 启动或配对成功后，将 `qrPath` 以 Markdown 图片嵌入回复，并逐字展示 `displayText`。不要把二维码内容、Token 或 Base64 写进消息。
 - 不自动修改防火墙或发送测试消息。`lanAccess: unverified` 或 `mobileAccess: unverified` 只表示设备链路尚未现场验证。
 - 服务位于用户 `Programs/CodexRemote/service`；配置在 `LocalAppData/CodexRemote`；附件在 `ProgramData/CodexRemote/attachments`。不要删除配置、附件或凭据来排障。

package/dist/src/desktop-launcher.mjs

@@ -28,7 +28,7 @@ export async function launchDesktop({ stateRoot, host, environment = process.env
     for (const key of ['CODEX_APP_SERVER_WS_URL', 'CODEX_APP_SERVER_FORCE_CLI', 'CODEX_APP_TOOLS_PIPE_PATH']) delete childEnv[key];
     progress('starting-app-server');
     managed = new ManagedAppServer({ stateRoot, host, environment, available, wait, timeout });
-    if (!await managed.start()) throw new Error(managed.snapshot().error || '受管 app-server 未就绪。');
+    if (!await managed.start()) throw new Error(managed.snapshot().error || 'Codex 内核未就绪。');
     const runtime = readRecord(path.join(stateRoot, 'codex-runtime.json'));
     if (runtime?.codexHome) childEnv.CODEX_HOME = runtime.codexHome;
     childEnv.CODEX_APP_SERVER_WS_URL = sharedUrl;

package/dist/src/onboarding.mjs

@@ -1,29 +1,29 @@
 export const connectionModesText = [
   '可选连接模式：',
   '• 局域网：启动时会把当前 Wi-Fi/有线网络候选临时发给已配对设备；App 验证后保存，也可手动输入 IP。',
-  '• 私有中继：同一设备授权可跨网络长期重连；Codex 内核就绪后才能进入聊天。',
-  '• OpenAI 官方中继：在已配对电脑内使用官方账号和设备授权；认证仍直连 OpenAI。',
+  '• Code Relax 中继：同一设备授权可跨网络长期重连；Codex 内核就绪后才能进入聊天。',
+  '• OpenAI 中继：在已配对电脑内使用官方账号和设备授权；认证仍直连 OpenAI。',
 ].join('\n');
 
 export function phonePairingSteps(transportMode, paired = false) {
   const mode = transportMode === 'lan-shared' ? '局域网 · Codex 内核已就绪' : '局域网（Codex 内核未就绪）';
   return paired ? [
-    `已有移动设备授权。移动端可继续使用私有中继；${mode} 会显示验证成功的当前网络和历史记录。`,
+    `已有移动设备授权。移动端可继续使用 Code Relax 中继；${mode} 会显示验证成功的当前网络和历史记录。`,
     '添加另一台设备时执行 relax pair；每台设备只需扫码配对一次。',
   ] : [
     '请先在移动端安装 Code Relax。当前为鸿蒙 HarmonyOS 7 私测版，调试 HAP 需通过 DevEco/调试设备安装，尚无商店下载入口。',
     '使用 App 扫描配对二维码；每台移动设备只需配对一次。',
-    `配对后可直接使用私有中继；${mode} 会接收并验证当前网络候选，也可手动输入 IP。`,
+    `配对后可直接使用 Code Relax 中继；${mode} 会接收并验证当前网络候选，也可手动输入 IP。`,
   ];
 }
 export const desktopSetupSteps = [
   'Code Relax Skill 已随 npm 包自动安装。',
-  '安装完成后 Bridge 和受管 app-server 已启动，并默认在当前用户登录时启动。',
+  '安装完成后桌面服务和 Codex 内核已启动，并默认在当前用户登录时启动。',
   'CLI 用户无需安装 Desktop；已安装 Desktop 时，安装器负责将运行中的 Desktop 接入同一内核。',
   '尚无设备授权时执行 relax pair，打开并扫描配对二维码。',
   '统一配对先建立电脑记录；进入该电脑后可另行完成 OpenAI 官方 Remote 配对。',
 ];
 
 export function pairingDisplayText(nextSteps, notice) {
-  return ['Bridge 已就绪，请在移动端完成连接。', connectionModesText, ...nextSteps.map((step, index) => `${index + 1}. ${step}`), notice].join('\n\n');
+  return ['桌面服务已就绪，请在移动端完成连接。', connectionModesText, ...nextSteps.map((step, index) => `${index + 1}. ${step}`), notice].join('\n\n');
 }

package/dist/src/platform/windows/resident-start.js

@@ -2,7 +2,19 @@
 // short-lived CLI has handed the resident service to the background broker.
 if (WScript.Arguments.length !== 2) WScript.Quit(2);
 var shell = new ActiveXObject('WScript.Shell');
+var files = new ActiveXObject('Scripting.FileSystemObject');
 var node = WScript.Arguments.Item(0);
 var entry = WScript.Arguments.Item(1);
+if (!files.FileExists(node)) {
+  var directories = shell.Environment('PROCESS').Item('PATH').split(';');
+  node = '';
+  for (var i = 0; i < directories.length; i++) {
+    var directory = directories[i].replace(/^"|"$/g, '');
+    if (!directory) continue;
+    var candidate = files.BuildPath(directory, 'node.exe');
+    if (files.FileExists(candidate)) { node = candidate; break; }
+  }
+  if (!node) WScript.Quit(2);
+}
 var command = '"' + node + '" "' + entry + '" start --json';
 WScript.Quit(shell.Run(command, 0, true));

package/dist/src/platform/windows/resident-startup.ps1

@@ -1,8 +1,9 @@
-param([string]$NodePath, [string]$Entry, [ValidateSet('enable','disable','status')][string]$Action='status')
+param([string]$NodePath, [string]$Entry, [ValidateSet('enable','disable','status')][string]$Action='status')
 $ErrorActionPreference = 'Stop'
 [Console]::OutputEncoding = New-Object System.Text.UTF8Encoding($false)
 
-$taskName = 'Code Relax Bridge'
+$taskName = 'Code Relax 桌面服务'
+$legacyTaskName = 'Code Relax Bridge'
 $taskSource = '@walkhi/code-relax'
 $taskPath = '\' + $taskName
 $launcher = Join-Path $PSScriptRoot 'resident-start.js'
@@ -14,9 +15,13 @@ $scheduler = New-Object -ComObject 'Schedule.Service'
 $scheduler.Connect()
 $root = $scheduler.GetFolder('\')
 $registered = @($root.GetTasks(1) | Where-Object { $_.Name -eq $taskName } | Select-Object -First 1)
+$legacyRegistered = @($root.GetTasks(1) | Where-Object { $_.Name -eq $legacyTaskName } | Select-Object -First 1)
 if ($registered.Count -gt 0 -and $registered[0].Definition.RegistrationInfo.Source -ne $taskSource) {
     throw 'Scheduled task is not owned by this installation.'
 }
+if ($legacyRegistered.Count -gt 0 -and $legacyRegistered[0].Definition.RegistrationInfo.Source -ne $taskSource) {
+    throw 'Legacy scheduled task is not owned by this installation.'
+}
 
 # Remove only the legacy shortcut created by this package. A Startup LNK that
 # launches hidden PowerShell with ExecutionPolicy Bypass triggers AV heuristics.
@@ -35,7 +40,7 @@ if ($Action -eq 'enable') {
     if (-not (Test-Path -LiteralPath $NodePath) -or -not (Test-Path -LiteralPath $Entry) -or
         -not (Test-Path -LiteralPath $launcher) -or -not (Test-Path -LiteralPath $wscript)) { throw 'Installed runtime is missing.' }
     $definition = $scheduler.NewTask(0)
-    $definition.RegistrationInfo.Description = 'Start the Code Relax Bridge when this user signs in.'
+    $definition.RegistrationInfo.Description = 'Start the Code Relax desktop service when this user signs in.'
     $definition.RegistrationInfo.Source = $taskSource
     $definition.Principal.UserId = $currentUser
     $definition.Principal.LogonType = 3 # TASK_LOGON_INTERACTIVE_TOKEN
@@ -55,16 +60,24 @@ if ($Action -eq 'enable') {
     $exec.Arguments = $arguments
     $exec.WorkingDirectory = $env:USERPROFILE
     [void]$root.RegisterTaskDefinition($taskName, $definition, 6, $null, $null, 3, $null) # TASK_CREATE_OR_UPDATE
-} elseif ($Action -eq 'disable' -and $registered.Count -gt 0) {
-    $root.DeleteTask($taskName, 0)
+    if ($legacyRegistered.Count -gt 0) { $root.DeleteTask($legacyTaskName, 0) }
+} elseif ($Action -eq 'disable') {
+    if ($registered.Count -gt 0) { $root.DeleteTask($taskName, 0) }
+    if ($legacyRegistered.Count -gt 0) { $root.DeleteTask($legacyTaskName, 0) }
 }
 if ($Action -ne 'status' -and $legacyExists) { Remove-Item -LiteralPath $legacyPath }
 
 $active = @($root.GetTasks(1) | Where-Object { $_.Name -eq $taskName } | Select-Object -First 1)
 $taskEnabled = $active.Count -gt 0 -and $active[0].Enabled
+$taskCurrent = $false
+if ($taskEnabled) {
+    $taskAction = $active[0].Definition.Actions.Item(1)
+    $taskCurrent = $taskAction.Path -ieq $wscript -and $taskAction.Arguments -ieq $arguments
+}
 @{
-    enabled=($taskEnabled -or ($Action -eq 'status' -and $legacyExists))
-    path=$(if ($taskEnabled) { 'Task Scheduler:' + $taskPath } elseif ($legacyExists) { $legacyPath } else { 'Task Scheduler:' + $taskPath })
+    enabled=($taskCurrent -and $legacyRegistered.Count -eq 0)
+    taskPresent=$taskEnabled
+    path=$(if ($taskEnabled) { 'Task Scheduler:' + $taskPath } elseif ($legacyRegistered.Count -gt 0) { 'Task Scheduler:\' + $legacyTaskName } elseif ($legacyExists) { $legacyPath } else { 'Task Scheduler:' + $taskPath })
     scope='current-user-logon'
-    mechanism=$(if ($taskEnabled) { 'task-scheduler' } elseif ($legacyExists) { 'legacy-startup-shortcut' } else { 'task-scheduler' })
+    mechanism=$(if ($taskCurrent -and $legacyRegistered.Count -eq 0) { 'task-scheduler' } elseif ($taskEnabled -or $legacyRegistered.Count -gt 0) { 'stale-task-scheduler' } elseif ($legacyExists) { 'legacy-startup-shortcut' } else { 'task-scheduler' })
 } | ConvertTo-Json -Compress

package/dist/src/platform/windows/user-environment.mjs

@@ -15,7 +15,7 @@ export async function configureManagedEnvironment(stateRoot) {
   const ownershipPath = path.join(stateRoot, ownershipFile);
   const ownership = readRecord(ownershipPath);
   if (current.forceCliUser === '1' || current.forceCliMachine === '1') {
-    throw new Error('CODEX_APP_SERVER_FORCE_CLI=1 会让 Codex 忽略受管 app-server；未修改该配置。');
+    throw new Error('CODEX_APP_SERVER_FORCE_CLI=1 会让 Codex 忽略当前内核地址；未修改该配置。');
   }
   if (current.userValue && current.userValue !== managedAppServerUrl) {
     throw new Error(`用户已有 CODEX_APP_SERVER_WS_URL=${current.userValue}；未覆盖该配置。`);

package/dist/src/self-relay/connector.mjs

@@ -9,7 +9,7 @@ import { createWindowsRouteHelper } from './windows-route-helper.mjs';
 // The LAN token never travels to the relay. No requests are replayed after a close.
 export function connectBridgeRelay({ relayUrl, hostKey, bridgeUrl, bridgeToken, identity, bridgeConnection, hostName = 'Codex-PC', lanCandidates = [], p2pProbe = false, iceServers = [], p2pWindowsRouteHelper = false, p2pWindowsRouteHelperToken = '' }) {
   relayAddress(relayUrl); loopbackUrl(bridgeUrl, '/api/socket');
-  if (!bridgeToken) throw new Error('Bridge token required');
+  if (!bridgeToken) throw new Error('Desktop service credential required');
   const events = new EventEmitter();
   const remote = new WebSocket(relayUrl, { maxPayload: 64 * 1024 * 1024, perMessageDeflate: {
     serverNoContextTakeover: true, clientNoContextTakeover: true,
@@ -114,18 +114,18 @@ export function connectBridgeRelay({ relayUrl, hostKey, bridgeUrl, bridgeToken,
             loopbackUrl(connection.url, '/api/socket');
           } catch {
             send(remote, { type: 'detach', session: message.session }); dropLocal(message.session); events.emit('detached', { session: message.session });
-            events.emit('diagnostic', 'Local Bridge connection not ready'); return;
+            events.emit('diagnostic', 'Local desktop service connection not ready'); return;
           }
           const socket = current.socket = new WebSocket(connection.url, { maxPayload: 64 * 1024 * 1024, perMessageDeflate: false });
           current.forwardToBridge = payload => {
-            if (locals.get(message.session) !== current || !current.ready) throw new Error('Local Bridge connection not ready');
+            if (locals.get(message.session) !== current || !current.ready) throw new Error('Local desktop service connection not ready');
             const request = decode(payload, false);
             if (!['request', 'subscribe', 'unsubscribe'].includes(request.type)) throw new Error('Unsupported LAN message');
             send(socket, request);
           };
           current.timer = setTimeout(() => socket.terminate(), 5000);
           socket.on('open', () => send(socket, { type: 'auth', token: connection.token }));
-          socket.on('error', error => events.emit('diagnostic', `Local Bridge: ${error.message}`));
+          socket.on('error', error => events.emit('diagnostic', `Local desktop service: ${error.message}`));
           socket.on('close', () => {
             if (locals.get(message.session)?.socket !== socket) return;
             send(remote, { type: 'detach', session: message.session }); dropLocal(message.session); events.emit('detached', { session: message.session });
@@ -135,7 +135,7 @@ export function connectBridgeRelay({ relayUrl, hostKey, bridgeUrl, bridgeToken,
             try {
               const response = decode(data, isBinary);
               if (!current.ready) {
-                if (response.type !== 'ready') throw new Error('Local Bridge authentication failed');
+                if (response.type !== 'ready') throw new Error('Local desktop service authentication failed');
                 clearTimeout(current.timer); current.ready = true; send(remote, { type: 'ready', session: message.session });
               } else {
                 const payload = data.toString();

package/dist/src/self-relay/demo.mjs

@@ -18,7 +18,7 @@ export async function startRelayDemo({ mode = 'lan-shared', pairingTtlMs, dispat
       reply.startEvents(); reply.event('update', { thread: { id: 'demo' }, simulated: true }); return;
     }
     if (request.url === '/api/demo/stop') return reply.json(200, { stopped: true, simulated: true });
-    reply.json(404, { error: '模拟 Bridge 不执行真实任务' });
+    reply.json(404, { error: '模拟桌面服务不执行真实任务' });
   } });
   await new Promise(resolve => bridge.listen(0, '127.0.0.1', resolve));
   const relay = remoteRelay ? { ...remoteRelay, async close() {} } : await startSelfRelay({ pairingTtlMs, ...relayOptions });

package/dist/src/self-relay/lifecycle.mjs

@@ -56,9 +56,9 @@ async function registrationKey(config) {
 export async function selfRelay(command, stateRoot) {
   const session = readRecord(path.join(stateRoot, 'bridge-session.json'));
   if (!session) {
-    if (command === 'relay-status') return { running: false, displayText: 'Bridge 未运行。' };
+    if (command === 'relay-status') return { running: false, displayText: '桌面服务未运行。' };
     if (command === 'relay-stop') return { stopped: true, displayText: '中继连接已停止。' };
-    throw new Error('Bridge 尚未运行，请先执行 relax start。');
+    throw new Error('桌面服务尚未运行，请先执行 relax start。');
   }
   return controlRequest(session, 'POST', command);
 }
@@ -67,7 +67,7 @@ async function createRelayRuntime(stateRoot) {
   const config = await loadConfig(stateRoot);
   const session = () => readRecord(path.join(stateRoot, 'bridge-session.json'));
   let health = await serviceHealth(session());
-  if (health?.status !== 'ok') throw new Error('Bridge 尚未运行，请先执行 relax start --json。');
+  if (health?.status !== 'ok') throw new Error('桌面服务尚未运行，请先执行 relax start --json。');
   const stored = await credentialStore('load');
   const identities = stored.record || { version: 1, servers: {} };
   const validate = value => {
@@ -218,7 +218,7 @@ export function createRelayManager(stateRoot) {
       if (command === 'relay-status') return current ? current.inspect() : { running: false, displayText: '中继连接未运行。' };
       if (command === 'relay-stop') {
         await current?.shutdown(); current = undefined;
-        return { stopped: true, displayText: '中继连接已停止；Bridge 和 Codex 保持运行。' };
+        return { stopped: true, displayText: '中继连接已停止；桌面服务和 Codex 内核保持运行。' };
       }
       if (!current) {
         if (command === 'relay-revoke') throw new Error('请先启动中继连接，再撤销移动端授权。');

package/dist/src/server.mjs

@@ -505,7 +505,7 @@ void managedAppServer.start();
 executionHealth.start();
 runtimeDiscovery.start();
 server.on('error', error => {
-  console.error('Bridge 监听失败：', error.message);
+  console.error('桌面服务监听失败：', error.message);
   process.exit(1);
 });
 server.listen(options.port, options.lan ? '0.0.0.0' : '127.0.0.1', async () => {
@@ -528,10 +528,10 @@ server.listen(options.port, options.lan ? '0.0.0.0' : '127.0.0.1', async () => {
         pid: process.pid, controlPort: control.port });
     }
   } catch (error) {
-    console.error('Bridge 管理通道启动失败：', error.message);
+    console.error('桌面服务管理通道启动失败：', error.message);
     process.exit(1);
   }
-  console.log(`Code Relax Bridge 已启动：http://127.0.0.1:${options.port}/`);
+  console.log(`Code Relax 桌面服务已启动：http://127.0.0.1:${options.port}/`);
   if (options.lan) {
     console.log('LAN 模式使用鉴权 WebSocket，仅适合受信任局域网测试，不要暴露到公网。');
   }

package/dist/src/service-control.mjs

@@ -29,7 +29,7 @@ export async function openControl({ instanceId, secret, shutdown, status = () =>
     }
     if (request.method === 'POST') response.once('finish', () => {
       Promise.resolve(shutdown()).catch(error => {
-        console.error('Bridge 关闭失败：', error.message);
+        console.error('桌面服务关闭失败：', error.message);
         process.exitCode = 1;
       });
     });
@@ -56,16 +56,16 @@ export function controlRequest(session, method = 'GET', action = '') {
       response.on('end', () => {
         try {
           if (response.statusCode === 409) throw new Error(JSON.parse(body).error);
-          if (response.statusCode !== 200) throw new Error('Bridge 管理通道身份验证失败。');
+          if (response.statusCode !== 200) throw new Error('桌面服务管理通道身份验证失败。');
           const identity = JSON.parse(body);
           if (identity.instanceId !== session.instanceId || identity.pid !== session.pid) {
-            throw new Error('Bridge 实例身份不匹配。');
+            throw new Error('桌面服务实例身份不匹配。');
           }
           resolve(identity);
         } catch (error) { reject(error); }
       });
     });
-    request.on('timeout', () => request.destroy(new Error('Bridge 管理通道响应超时。')));
+    request.on('timeout', () => request.destroy(new Error('桌面服务管理通道响应超时。')));
     request.on('error', reject);
     request.end();
   });

package/dist/src/service-doctor.mjs

@@ -20,7 +20,7 @@ export async function doctor({ paths, host, service, skillTarget, ensureAutostar
   });
   await check('bridge-runtime', async () => {
     await host.bridgeEnvironment();
-    add('bridge-runtime', 'ok', 'Bridge 启动环境已就绪；实际任务操作尚未验证。');
+    add('bridge-runtime', 'ok', '桌面服务启动环境已就绪；实际任务操作尚未验证。');
   });
   await check('network', async () => {
     const address = await host.lanAddress();
@@ -37,10 +37,10 @@ export async function doctor({ paths, host, service, skillTarget, ensureAutostar
       ? `本机服务正常：${state.mode}，端口 ${state.port}，运行版本：${state.version || '未知'}` : '服务未就绪；安装后执行 relax start。');
     if (state.running && installedVersion && state.version !== installedVersion) add('service-version', 'warning', state.version
       ? `已安装版本 ${installedVersion}，但当前运行版本为 ${state.version}；请重新执行安装或重启工作站服务。`
-      : `已安装版本 ${installedVersion}，但当前运行 Bridge 未报告版本，可能仍是旧进程；请重新执行安装或重启工作站服务。`);
+      : `已安装版本 ${installedVersion}，但当前运行的桌面服务未报告版本，可能仍是旧进程；请重新执行安装或重启桌面服务。`);
     if (state.running) add('managed-app-server', state.managedAppServer?.state === 'ready' ? 'ok' : 'error',
-      state.managedAppServer?.state === 'ready' ? '受管 app-server 已就绪。'
-        : state.managedAppServer?.error || '受管 app-server 尚未就绪。');
+      state.managedAppServer?.state === 'ready' ? 'Codex 内核已就绪。'
+        : state.managedAppServer?.error || 'Codex 内核尚未就绪。');
     if (state.managedAppServer?.updatePending) add('managed-app-server-update', 'warning',
       '已选择另一版本 CLI；当前 app-server 继续完成任务，下次内核启动时采用选定版本。');
     if (state.managedAppServer?.launcherRestartRequired) add('managed-app-server-launcher', 'warning',

package/dist/src/service-health.mjs

@@ -14,7 +14,7 @@ export function serviceHealth(session) {
       socket.terminate();
       if (error) reject(error); else resolve(value);
     };
-    const timer = setTimeout(() => finish(new Error('Bridge 健康检查超时。')), 6000);
+    const timer = setTimeout(() => finish(new Error('桌面服务健康检查超时。')), 6000);
     socket.on('open', () => socket.send(JSON.stringify({ type: 'auth', token })));
     socket.on('message', data => {
       try {
@@ -28,6 +28,6 @@ export function serviceHealth(session) {
     });
     socket.on('error', error => finish(error.code === 'ECONNREFUSED' ? null : error));
     socket.on('close', code => finish(new Error(code === 1008
-      ? 'Bridge 健康检查鉴权失败。' : 'Bridge 健康检查连接已断开。')));
+      ? '桌面服务健康检查鉴权失败。' : '桌面服务健康检查连接已断开。')));
   });
 }

package/dist/src/service-lifecycle.mjs

@@ -27,7 +27,7 @@ export function lifecycle({ stateRoot, host }) {
 
   async function alive(session) {
     if (!session?.controlPort || !session.instanceId || !session.controlSecret) {
-      if (await health(session)) throw new Error('当前为旧版 Bridge，请先使用旧版停止入口结束服务，再启动新版。');
+      if (await health(session)) throw new Error('当前为旧版桌面服务，请先使用旧版停止入口结束服务，再启动新版。');
       return false;
     }
     try { await controlRequest(session); return true; }
@@ -35,7 +35,7 @@ export function lifecycle({ stateRoot, host }) {
   }
   async function stop() {
     const session = readRecord(sessionPath);
-    if (!await alive(session)) return { stopped: true, message: 'Bridge 已停止。' };
+    if (!await alive(session)) return { stopped: true, message: '桌面服务已停止。' };
     await controlRequest(session, 'POST');
     const deadline = Date.now() + 10000;
     while (true) {
@@ -45,10 +45,10 @@ export function lifecycle({ stateRoot, host }) {
         // Verify refusal on the next connection; never resend the shutdown request.
         if (error.code !== 'ECONNRESET') throw error;
       }
-      if (Date.now() > deadline) throw new Error('Bridge 未在 10 秒内退出；未强杀进程。');
+      if (Date.now() > deadline) throw new Error('桌面服务未在 10 秒内退出；未强杀进程。');
       await delay(100);
     }
-    return { stopped: true, message: 'Bridge 已正常关闭。' };
+    return { stopped: true, message: '桌面服务已正常关闭。' };
   }
   async function status() {
     const session = readRecord(sessionPath);
@@ -78,7 +78,7 @@ export function lifecycle({ stateRoot, host }) {
   }
   async function restartManagedAppServer() {
     const session = readRecord(sessionPath);
-    if (!await alive(session)) throw new Error('Bridge 尚未运行，无法迁移受管 app-server。');
+    if (!await alive(session)) throw new Error('桌面服务尚未运行，无法迁移 Codex 内核。');
     return controlRequest(session, 'POST', 'restart-managed-app-server');
   }
   async function start() {
@@ -110,11 +110,11 @@ export function lifecycle({ stateRoot, host }) {
       const deadline = Date.now() + 10000;
       let ready;
       while (!(ready = readRecord(readyPath))) {
-        if (!processAlive(pid)) throw new Error('Bridge 启动失败，请查看 bridge.stderr.log。');
-        if (Date.now() > deadline) throw new Error('Bridge 未在 10 秒内就绪。');
+        if (!processAlive(pid)) throw new Error('桌面服务启动失败，请查看 bridge.stderr.log。');
+        if (Date.now() > deadline) throw new Error('桌面服务未在 10 秒内就绪。');
         await delay(100);
       }
-      if (ready.instanceId !== instanceId || ready.pid !== pid) throw new Error('Bridge 启动实例不匹配。');
+      if (ready.instanceId !== instanceId || ready.pid !== pid) throw new Error('桌面服务启动实例不匹配。');
       session = { ...ready, controlSecret, executablePath: executable, scriptPath, port: config.port,
         lan: true, appServer: false, accessUrl: `http://${address}:${config.port}/?token=${config.token}`,
         startedAt: new Date().toISOString() };

package/dist/src/shared-recovery.mjs

@@ -111,7 +111,7 @@ export async function runRecovery(stateRoot, operationId, dependencies = {}) {
     await waitFor(async () => {
       const health = await service.status();
       return health.running && health.mode === 'lan-shared' && health.execution?.ready === true;
-    }, 'Codex 内核未就绪；Bridge 和中继管理连接仍保留。');
+    }, 'Codex 内核未就绪；桌面服务和中继连接仍保留。');
     record = { ...record, status: 'completed', stage: 'ready', steps: record.steps.map(step => ({ ...step, status: 'completed' })),
       message: 'Codex Desktop 已接入 Codex 内核；移动端控制保持就绪，原任务未自动重发。' };
   } catch (error) { record = { ...record, status: 'failed', error: error.message,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@walkhi/code-relax",
-  "version": "0.1.0-beta.15",
+  "version": "0.1.0-beta.17",
   "license": "UNLICENSED",
   "type": "module",
   "scripts": {

package/tools/postinstall.mjs

@@ -59,9 +59,9 @@ export function formatSetupOutput(output, previous = {}) {
         ? `未重启（PID ${pid}，启动代次 ${migration.launcherRevision ?? '未知'} 已是最新）`
         : `已启动（PID ${pid}，启动代次 ${migration.launcherRevision ?? '未知'}）`;
     return `Code Relax ${result.version || '未知版本'} 安装成功。\n`
-      + `受管 app-server：${appServer}\n`
-      + `Bridge：${result.restarted ? '已恢复并健康' : '已启动并健康'}\n`
-      + `${result.desktopRestarted ? `Codex Desktop：已干净重启并重新接入（${result.desktopRestartReason === 'attach-managed-server' ? '接入受管内核' : 'app-server 迁移'}）\n` : ''}`
+      + `Codex 内核：${appServer}\n`
+      + `桌面服务：${result.restarted ? '已恢复并健康' : '已启动并健康'}\n`
+      + `${result.desktopRestarted ? `Codex Desktop：已干净重启并重新接入（${result.desktopRestartReason === 'attach-managed-server' ? '接入 Codex 内核' : '内核迁移'}）\n` : ''}`
       + `${result.desktopRestartRecommended ? 'Codex Desktop：建议完全退出后重新打开。\n' : ''}`;
   } catch { return output; }
 }