@walkhi/code-relax 0.1.0-beta.71 → 0.1.0-beta.76

package/dist/build-platform.json

@@ -1 +1 @@
-{"layout":"npm-platform-packages","version":"0.1.0-beta.71"}
+{"layout":"npm-platform-packages","version":"0.1.0-beta.76"}

package/dist/src/desktop-launcher.mjs

@@ -17,12 +17,21 @@ function desktopEnvironment(stateRoot, environment) {
 
 // Opening the optional UI does not start, restart or supervise the kernel.
 export async function startDesktop({ stateRoot, host, environment = process.env, restart = false }) {
-  const info = await host.inspect();
-  if (!info.desktop) throw new Error('未安装 Codex 桌面端。');
-  if (info.running && !restart) return { status: 'running', message: 'Codex 桌面端已启动。' };
-  if (info.running) await host.closeDesktop(info.desktop);
-  await host.startDesktop(info.desktop, desktopEnvironment(stateRoot, environment));
-  return { status: 'accepted', message: restart ? '已提交 Codex 桌面端重启请求。' : '已提交 Codex 桌面端启动请求。' };
+  let stage = 'inspect';
+  try {
+    const info = await host.inspect();
+    if (!info.desktop) throw new Error('未安装 Codex 桌面端。');
+    if (info.running && !restart) return { status: 'running', message: 'Codex 桌面端已启动。' };
+    if (info.running) { stage = 'close'; await host.closeDesktop(info.desktop); }
+    stage = 'activate';
+    await host.startDesktop(info.desktop, desktopEnvironment(stateRoot, environment));
+    return { status: 'accepted', message: restart ? '已提交 Codex 桌面端重启请求。' : '已提交 Codex 桌面端启动请求。' };
+  } catch (error) {
+    console.error(JSON.stringify({ time: new Date().toISOString(), event: 'desktop-operation-failed', restart, stage,
+      message: error.message, code: error.code, stderr: error.stderr }));
+    throw new Error(stage === 'close' ? '桌面端关闭失败，请查看工作站诊断日志。'
+      : stage === 'activate' ? '桌面端启动失败，请查看工作站诊断日志。' : '无法检查桌面端，请查看工作站诊断日志。', { cause: error });
+  }
 }
 
 export async function launchDesktop({ stateRoot, host, environment = process.env, wait = delay, timeout = 30000, recoveryId, progress = () => {}, service = lifecycle({ stateRoot, host: serviceHost }) }) {

package/dist/src/dots-chat-server.mjs

@@ -33,11 +33,13 @@ export class DotsChatServer extends HostedHistoryAppServer {
     this.observedThreads = new Set(); this.reconnectAttempts = 0;
     this.approvalTimeline = new DotsApprovalTimeline(this);
     this.chatActivity = new DotsRoomActivity(this);
+    this.backgroundActivity = new Map();
     this.chatActivity.on('unavailable', error => this.emit('activity-error', error));
     this.rooms.on('message', (topic, value) => this.roomNotification(topic, value));
     this.rooms.on('disconnected', reason => { this.invalidate(reason); this.scheduleReconnect(); });
-    this.hostDisconnected = () => { this.rooms.close(); this.invalidate({ source: 'hosted-app-server' }); };
-    this.hostConnected = () => { void this.restoreObservers().catch(error => this.emit('subscription-error', error)); };
+    this.hostDisconnected = () => { this.rooms.close(); this.invalidate({ source: 'hosted-app-server' }); this.scheduleReconnect(); };
+    this.hostConnected = () => { this.syncBackgroundActivity(); void this.restoreObservers().catch(error => this.emit('subscription-error', error)); };
+    this.profilesChanged = () => this.syncBackgroundActivity();
     this.hostNotification = ({ method, params }) => this.executionNotification(method, params);
     this.hostRequestsChanged = id => {
       this.emit('requests-changed', id);
@@ -51,6 +53,31 @@ export class DotsChatServer extends HostedHistoryAppServer {
     };
     transport.on('disconnected', this.hostDisconnected); transport.on('connected', this.hostConnected);
     transport.on('host-notification', this.hostNotification); transport.on('requests-changed', this.hostRequestsChanged);
+    transport.on('profiles-changed', this.profilesChanged);
+  }
+
+  startBackgroundActivity() {
+    if (this.closed || this.backgroundStarting) return;
+    this.backgroundEnabled = true;
+    this.backgroundStarting = this.transport.connect().then(() => {
+      if (this.closed) return;
+      this.syncBackgroundActivity();
+      this.transport.refreshLiveProfiles();
+    }).catch(error => { this.emit('activity-error', error); this.scheduleReconnect(); })
+      .finally(() => { this.backgroundStarting = null; });
+  }
+  syncBackgroundActivity() {
+    if (this.closed || !this.backgroundEnabled || !this.transport.ready) return;
+    const roots = new Set([...this.transport.profileNames.values()].map(profile => profile.activeRootThreadId).filter(Boolean));
+    for (const [id, release] of this.backgroundActivity) if (!roots.has(id)) {
+      release(); this.backgroundActivity.delete(id);
+    }
+    for (const id of roots) if (!this.backgroundActivity.has(id)) {
+      this.backgroundActivity.set(id, this.chatActivity.acquire(id, () => {}));
+      // Establish the existing bounded message window and durable cache without
+      // a phone consumer. Subsequent pushes use the normal incremental path.
+      void this.timeline(id).catch(error => this.emit('subscription-error', error));
+    }
   }
 
   get ready() { return this.transport?.ready === true && this.rooms?.ready === true; }
@@ -80,6 +107,7 @@ export class DotsChatServer extends HostedHistoryAppServer {
     this.traceSync('invalidated', null, reason);
     clearTimeout(this.reconnectTimer);
     this.epoch = randomUUID(); this.chatActivity.close(); this.approvalTimeline.clear();
+    this.backgroundActivity.clear();
     this.roomApprovalResponses.clear();
     for (const record of this.threads.values()) { record.needsReload = true; record.tokens.clear(); record.refresh = null; }
     for (const timer of this.windowSaves.values()) clearTimeout(timer); this.windowSaves.clear();
@@ -87,7 +115,7 @@ export class DotsChatServer extends HostedHistoryAppServer {
     this.windowLoads.clear(); this.historyLoads.clear(); this.emit('disconnected');
   }
   scheduleReconnect() {
-    if (this.closed || !this.transport.ready || !this.observedThreads.size || this.reconnectAttempts >= 5) return;
+    if (this.closed || (!this.observedThreads.size && !this.backgroundEnabled) || this.reconnectAttempts >= 5) return;
     clearTimeout(this.reconnectTimer);
     this.reconnectTimer = setTimeout(() => {
       this.reconnectTimer = null;
@@ -96,8 +124,10 @@ export class DotsChatServer extends HostedHistoryAppServer {
     this.reconnectTimer.unref();
   }
   async restoreObservers() {
-    if (!this.observedThreads.size || this.closed) return;
+    if ((!this.observedThreads.size && !this.backgroundEnabled) || this.closed) return;
     await this.connect();
+    this.syncBackgroundActivity();
+    if (this.backgroundEnabled) this.transport.refreshLiveProfiles();
     for (const id of this.observedThreads) await this.timeline(id);
     this.reconnectAttempts = 0;
   }
@@ -409,7 +439,8 @@ export class DotsChatServer extends HostedHistoryAppServer {
     if (epoch !== this.epoch) throw new Error('点点连接已变化，请核对后发送。');
     const result = await this.rooms.request(`/messaging/rooms/${encodeURIComponent(room.id)}/messages`, {
       method: 'POST', body: { content: { text: args.prompt, ...(attachments.length ? { attachments } : {}) },
-        request_id: requestId, idempotency_token: requestId } });
+        request_id: requestId, idempotency_token: requestId,
+        timezone_offset_min: new Date().getTimezoneOffset() } });
     if (epoch !== this.epoch || !result?.id) throw Object.assign(new Error('发送结果未确认，请核对消息。'), { deliveryUnknown: true });
     record.dirty++;
     void this.refreshMessages(args.threadId, record).catch(error => {
@@ -482,6 +513,7 @@ export class DotsChatServer extends HostedHistoryAppServer {
     }
   }
   acquireActivity(threadId, listener) { return this.chatActivity.acquire(threadId, listener); }
+  retryActivity(threadId) { return this.chatActivity.retryUnavailable(threadId); }
   acquirePanelActivity(threadId, listener) { return this.chatActivity.acquire(threadId, listener); }
   isHistorySyncing() { return false; }
   async readContext() { return { available: false }; }
@@ -493,6 +525,7 @@ export class DotsChatServer extends HostedHistoryAppServer {
     this.closed = true; clearTimeout(this.reconnectTimer); this.rooms.close(); this.invalidate(); this.chatActivity.dispose();
     this.transport.off('disconnected', this.hostDisconnected); this.transport.off('connected', this.hostConnected);
     this.transport.off('host-notification', this.hostNotification); this.transport.off('requests-changed', this.hostRequestsChanged);
+    this.transport.off('profiles-changed', this.profilesChanged);
     for (const timer of this.windowSaves.values()) clearTimeout(timer); this.windowSaves.clear();
   }
 }

package/dist/src/dots-room-activity.mjs

@@ -1,6 +1,6 @@
 import { EventEmitter } from 'node:events';
 
-// Desktop 26.1007.9446.0: room-live activity and responding heartbeats are
+// Desktop 26.1016.6573.0: room-live activity and responding heartbeats are
 // independent. Heartbeats expire after 10s; Dot reply handoff lasts at most 5s.
 const typingTimeout = 10000, handoffTimeout = 5000;
 const statusLabels = {
@@ -8,6 +8,7 @@ const statusLabels = {
   payment: '等待支付', 'needs input': '等待你的输入', paused: '已暂停',
 };
 const waitingStates = new Set(['payment', 'needs input', 'paused']);
+const retryableStatus = status => status == null || status === 408 || status === 429 || status >= 500;
 
 export class DotsRoomActivity extends EventEmitter {
   constructor(server) {
@@ -41,6 +42,13 @@ export class DotsRoomActivity extends EventEmitter {
       if (!watch.listeners.size) { this.watches.delete(threadId); this.stop(watch); }
     };
   }
+  retryUnavailable(threadId) {
+    const watch = this.watches.get(threadId);
+    if (!watch?.unavailable || !watch.listeners.size || watch.controller || watch.timer) return false;
+    watch.attempts = 0;
+    void this.start(watch);
+    return true;
+  }
   publish(watch, activity) {
     if (JSON.stringify(watch.activity) === JSON.stringify(activity)) return;
     watch.activity = activity;
@@ -100,14 +108,17 @@ export class DotsRoomActivity extends EventEmitter {
   }
   apply(watch, value) {
     if (value.subscription_id !== watch.subscriptionId || !Number.isSafeInteger(value.revision) || value.revision <= watch.revision) return;
-    watch.revision = value.revision;
     if (value.type === 'calpico-room-live-error') {
+      watch.revision = value.revision;
       this.fail(watch, new Error('点点活动暂不可用。'), value.code === 'temporarily_unavailable'); return;
     }
     if (value.type !== 'calpico-room-live-state' || !Array.isArray(value.threads)) return;
+    watch.revision = value.revision;
+    clearTimeout(watch.initialTimer); watch.initialTimer = null;
     const current = value.threads[0];
     watch.idle = value.threads.length === 0;
-    watch.attempts = 0; watch.unavailable = false; watch.liveActivity = null;
+    if (value.threads.some(thread => thread.stream_state === 'attached')) watch.attempts = 0;
+    watch.unavailable = false; watch.liveActivity = null;
     if (current?.stream_state !== 'attached') { this.refresh(watch); return; }
     if (current.turn_status === 'failed') {
       this.clearReply(watch); watch.liveActivity = { kind: 'error', label: '回复出错', spinning: false };
@@ -133,6 +144,11 @@ export class DotsRoomActivity extends EventEmitter {
     const generation = ++watch.generation, controller = new AbortController();
     watch.controller = controller; watch.pending = new Map(); watch.subscriptionId = null; watch.revision = -1;
     const current = () => this.watches.get(watch.threadId) === watch && generation === watch.generation && !controller.signal.aborted;
+    // Ready/keepalive on SSE does not establish delivery on the Celsius topic.
+    watch.initialTimer = setTimeout(() => {
+      if (current()) this.fail(watch, new Error('点点活动首次状态等待超时。'), true);
+    }, 30000);
+    watch.initialTimer.unref();
     try {
       await this.server.connect();
       const room = this.server.bindings.get(watch.threadId) || await this.server.room(watch.threadId);
@@ -155,9 +171,13 @@ export class DotsRoomActivity extends EventEmitter {
         },
       });
       if (current()) this.fail(watch, new Error('点点活动连接已结束。'), true);
-    } catch (error) { if (current()) this.fail(watch, error, ![401, 403, 404].includes(error.status)); }
+    } catch (error) { if (current()) this.fail(watch, error, retryableStatus(error.status)); }
   }
   fail(watch, error, retry) {
+    console.error(JSON.stringify({ time: new Date().toISOString(), event: 'dots-room-activity',
+      threadId: watch.threadId, roomId: watch.roomId, status: error.status || 0,
+      stage: watch.subscriptionId ? 'state' : 'subscribe', retry, attempts: watch.attempts,
+      responseKind: error.details?.responseKind || 'none' }));
     this.stop(watch, true); watch.unavailable = true; this.refresh(watch); this.emit('unavailable', error);
     if (retry && watch.listeners.size && this.server.ready && watch.attempts < 5) {
       watch.timer = setTimeout(() => { watch.timer = null; void this.start(watch); }, Math.min(30000, 1000 * 2 ** watch.attempts++));
@@ -166,6 +186,7 @@ export class DotsRoomActivity extends EventEmitter {
   }
   stop(watch, keepReply = false) {
     watch.generation++; clearTimeout(watch.timer); watch.timer = null;
+    clearTimeout(watch.initialTimer); watch.initialTimer = null;
     watch.controller?.abort(); watch.controller = null; watch.pending?.clear(); watch.liveActivity = null;
     watch.subscriptionId = null; watch.revision = -1; watch.idle = false;
     if (!keepReply) { this.clearReply(watch); watch.unavailable = false; watch.roomId = null; }

package/dist/src/dots-room-client.mjs

@@ -4,7 +4,7 @@ import { CelsiusClient } from './celsius-client.mjs';
 const topic = 'calpico-chatgpt-messaging';
 const identityKey = identity => JSON.stringify([identity?.accountId, identity?.userId]);
 
-// Desktop 26.1002.7124.0: the DM API and Celsius share the kernel account,
+// Desktop 26.1016.6573.0: the DM API and Celsius share the kernel account,
 // but are independent of the hosted execution socket. Never replay a POST.
 export class DotsRoomClient extends CelsiusClient {
   constructor(transport) {
@@ -30,7 +30,9 @@ export class DotsRoomClient extends CelsiusClient {
     const cancelled = () => controller.abort(signal.reason);
     signal?.addEventListener('abort', cancelled, { once: true });
     if (signal?.aborted) cancelled();
-    let sent = false, status, timer;
+    let sent = false, status, timer, responseKind = 'none';
+    const started = Date.now();
+    const clientId = method === 'POST' && /^[a-f0-9-]{36}$/i.test(body?.request_id || '') ? body.request_id : undefined;
     try {
       return await new Promise((resolve, reject) => {
         const session = http2.connect('https://chatgpt.com');
@@ -42,6 +44,10 @@ export class DotsRoomClient extends CelsiusClient {
           clearTimeout(timer); controller.signal.removeEventListener('abort', abort);
           request?.destroy(); session.destroy();
           if (error) {
+            error.details = { ...error.details, ...(status ? { upstreamStatus: status } : {}), responseKind };
+            if (!controller.signal.aborted) console.error(JSON.stringify({ time: new Date().toISOString(), event: 'dots-room-request', method,
+              route: route.split('?')[0], clientId, status: status || 0, responseKind,
+              ms: Date.now() - started, outcome: 'failed' }));
             if (method !== 'GET' && !onEvent) error.deliveryUnknown = sent && !(status >= 400 && status < 500 && status !== 408);
             reject(error);
           } else resolve(value);
@@ -50,7 +56,7 @@ export class DotsRoomClient extends CelsiusClient {
         controller.signal.addEventListener('abort', abort, { once: true });
         session.on('error', error => finish(error));
         if (controller.signal.aborted) { abort(); return; }
-        const roomRoute = /^\/messaging\/rooms\/([^/]+)\/messages$/.exec(route)?.[1];
+        const roomRoute = method === 'POST' ? /^\/messaging\/rooms\/([^/]+)\/messages$/.exec(route)?.[1] : null;
         request = session.request({ ':method': method, ':path': `/backend-api${route}`, ...auth.headers,
           accept: onEvent ? 'text/event-stream' : 'application/json',
           ...(body != null ? { 'content-type': contentType || 'application/json' } : {}),
@@ -59,13 +65,27 @@ export class DotsRoomClient extends CelsiusClient {
         request.setEncoding('utf8');
         request.on('response', headers => {
           status = headers[':status'];
-          if (roomRoute && typeof headers['x-openai-thread-route'] === 'string' && headers['x-openai-thread-route'].length <= 1024 && current()) this.routes.set(roomRoute, headers['x-openai-thread-route']);
+          const type = String(headers['content-type'] || '').split(';')[0].trim().toLowerCase();
+          responseKind = headers['cf-mitigated'] === 'challenge' ? 'challenge'
+            : type === 'application/json' ? 'json' : type === 'text/html' ? 'html' : type === 'text/event-stream' ? 'sse' : 'other';
+          if (roomRoute && current()) {
+            // Desktop replaces the route on every send response, including removal.
+            this.routes.delete(roomRoute);
+            const routeHint = headers['x-openai-thread-route'];
+            if (typeof routeHint === 'string' && routeHint && routeHint.length <= 1024) {
+              if (this.routes.size >= 128) this.routes.clear();
+              this.routes.set(roomRoute, routeHint);
+            }
+          }
           if (status < 200 || status >= 300) {
-            console.error(JSON.stringify({ event: 'dots-room-request', method, status, route: route.split('?')[0] }));
             const message = status === 401 ? '点点登录状态需要恢复，请重新连接。'
-              : status === 403 || status === 404 ? '点点消息暂不可用，请稍后重新同步。'
+              : status === 403 ? '点点服务拒绝访问（HTTP 403），请稍后重试。'
+                : status === 404 ? '点点消息暂不可用，请稍后重新同步。'
                 : status === 429 ? '点点暂时繁忙，请稍后再试。' : '点点请求尚未完成，请稍后核对。';
             finish(Object.assign(new Error(message), { status }));
+          } else if (roomRoute || onEvent) {
+            console.log(JSON.stringify({ time: new Date().toISOString(), event: 'dots-room-request', method,
+              route: route.split('?')[0], clientId, status, responseKind, ms: Date.now() - started, outcome: 'response' }));
           }
         });
         request.on('data', chunk => {

package/dist/src/dots-task-catalog.mjs

@@ -346,7 +346,10 @@ export class DotsAppServer extends HostedHistoryAppServer {
       const previous = this.profileNames.get(id);
       if (previous?.avatar && previous.avatarFileId === profile.avatarFileId) profile.avatar = previous.avatar;
     }
-    if (identity === this.profileIdentity) this.profileNames = names;
+    if (identity === this.profileIdentity) {
+      this.profileNames = names;
+      this.emit('profiles-changed');
+    }
   }
 
   refreshLiveProfiles() {

package/dist/src/lan-socket-server.mjs

@@ -48,7 +48,7 @@ export function attachLanSocket(server, { token, dispatch, authorizeDevice = ()
     target.handleUpgrade(request, socket, head, ws => target.emit('connection', ws));
   });
   uploadWss.on('connection', ws => {
-    let authenticated = false, stopped = false, identity = '', upload, purpose, chunk, uploadEntry, uploadId;
+    let authenticated = false, stopped = false, identity = '', upload, purpose, chunk, uploadEntry, uploadId, fileRelay = false;
     let release, discardUpload = false;
     const released = new Promise(resolve => { release = resolve; });
     let queued = 0;
@@ -98,6 +98,7 @@ export function attachLanSocket(server, { token, dispatch, authorizeDevice = ()
             if (supplied.length === expected.length && crypto.timingSafeEqual(supplied, expected)) {
               identity = typeof message.relayClientId === 'string' && message.relayClientId.length <= 200
                 ? `relay:${message.relayClientId}` : 'local-token';
+              fileRelay = message.fileRelay === true;
             }
           }
           if (identity && purpose === 'upload') {
@@ -146,6 +147,7 @@ export function attachLanSocket(server, { token, dispatch, authorizeDevice = ()
           return;
         }
         if (purpose === 'download') {
+          if (fileRelay && /^\/api\/desktop\/frames\//.test(message.path || '')) throw new Error('桌面画面仅支持直连');
           if (message.type !== 'read' || typeof message.path !== 'string' || message.path.length > 12000 ||
               !/^\/api\/(?:images\/[a-f0-9]{64}|files\/(?:local|[a-f0-9]{64})|code\/(?:image|binary)|desktop\/frames\/[a-f0-9]{32})(?:\?|$)/.test(message.path) || message.path.includes('#')) throw new Error('无效的文件读取请求');
           await dispatch({ method: 'GET', url: message.path, headers: {}, socketRequest: true, fileTransfer: true }, {

package/dist/src/managed-app-server.mjs

@@ -35,7 +35,8 @@ export function availableManagedPort() {
 export class ManagedAppServer extends EventEmitter {
   constructor({ stateRoot, host, environment = process.env, available = managedPortAvailable,
     wait = delay, timeout = 30_000, now = Date.now, client = new SharedAppServer(`ws://127.0.0.1:${defaultManagedPort}`),
-    selectPort = availableManagedPort, configureEnvironment = configureManagedEnvironment, resolveRuntime = resolveCodexRuntime }) {
+    selectPort = availableManagedPort, configureEnvironment = configureManagedEnvironment, resolveRuntime = resolveCodexRuntime,
+    diagnose = () => {} }) {
     super();
     this.stateRoot = stateRoot;
     this.host = host;
@@ -44,6 +45,7 @@ export class ManagedAppServer extends EventEmitter {
     this.selectPort = selectPort;
     this.configureEnvironment = configureEnvironment;
     this.resolveRuntime = resolveRuntime;
+    this.diagnose = diagnose;
     this.wait = wait;
     this.timeout = timeout;
     this.now = now;
@@ -111,6 +113,13 @@ export class ManagedAppServer extends EventEmitter {
         throw new Error(`运行中的 Codex 内核目录已被移除或缺少配套 code-mode-host：${actual.executable}；请确认重启内核。`);
       }
       if (!actual) {
+        const selection = { reason: this.restarting ? 'confirmed-restart' : record?.pid ? 'previous-process-exited' : 'no-running-kernel',
+          version: runtime.version, source: runtime.source, executable: runtime.executable };
+        const selectionSignature = JSON.stringify(selection);
+        if (selectionSignature !== this.diagnosticSelectionSignature) {
+          this.diagnosticSelectionSignature = selectionSignature;
+          this.diagnose('kernel-start-selected', selection);
+        }
         fs.rmSync(this.pendingPath, { force: true });
         const childEnvironment = { ...this.environment, CODEX_HOME: runtime.codexHome, RUST_LOG: 'warn' };
         for (const key of ['CODEX_APP_SERVER_WS_URL', 'CODEX_APP_SERVER_FORCE_CLI', 'CODEX_APP_TOOLS_PIPE_PATH']) delete childEnvironment[key];
@@ -128,6 +137,8 @@ export class ManagedAppServer extends EventEmitter {
           writeRecord(this.pendingPath, { phase: 'spawning', url, executable: runtime.executable, startedAt: new Date().toISOString() });
           const pid = await this.host.start(runtime.executable, ['app-server', '--listen', url], childEnvironment,
             [path.join(this.stateRoot, 'managed-app-server.stdout.log'), path.join(this.stateRoot, 'managed-app-server.stderr.log')]);
+          this.diagnose('kernel-spawned', { pid, executable: runtime.executable, selectedVersion: runtime.version,
+            source: runtime.source, attempt: attempt + 1 });
           const started = await this.host.process(pid);
           if (!started) {
             fs.rmSync(this.pendingPath, { force: true });
@@ -355,6 +366,20 @@ export class ManagedAppServer extends EventEmitter {
     const changed = JSON.stringify(value) !== JSON.stringify(this.state);
     this.state = value;
     if (changed) this.emit('state', this.snapshot());
+    // Retry transitions remain visible to health consumers; diagnostic output
+    // records a repeated failure once until it changes or the kernel recovers.
+    if (value.state === 'starting' && this.diagnosticState?.state === 'failed') return;
+    const details = { state: value.state, ready: value.ready, pid: value.pid ?? null, created: value.created ?? null,
+      version: value.ready && this.client.ready ? this.client.serverVersion || null : null,
+      executable: value.executable || null, selectedVersion: value.selectedVersion || null,
+      preferredExecutable: value.preferredExecutable || null, source: value.source || null,
+      updatePending: value.updatePending === true, error: value.error || null };
+    const signature = JSON.stringify(details);
+    if (signature === this.diagnosticStateSignature) return;
+    this.diagnosticStateSignature = signature;
+    this.diagnosticState = details;
+    if (value.ready) this.diagnosticSelectionSignature = null;
+    this.diagnose('kernel-state', { ...details, retryAt: value.retryAt || null });
   }
 
   close() {

package/dist/src/runtime-discovery.mjs

@@ -3,8 +3,8 @@ import { discoverCodex, resolveCodexRuntime, runtimeFingerprint, runtimeInstalla
 // Advisory discovery is independent of execution health. Failure here must never
 // disable an already running app-server or cause an automatic process restart.
 export class RuntimeDiscovery {
-  constructor({ stateRoot, host, url, interval = 60000 }) {
-    Object.assign(this, { stateRoot, host, url, interval });
+  constructor({ stateRoot, host, url, interval = 60000, diagnose = () => {} }) {
+    Object.assign(this, { stateRoot, host, url, interval, diagnose });
     this.state = {};
   }
   start() { this.stopped = false; void this.tick(); }
@@ -13,19 +13,29 @@ export class RuntimeDiscovery {
     const errors = [];
     try {
       const candidates = discoverCodex();
-      const signature = JSON.stringify([await runtimeInstallationFingerprint(), candidates.map(candidate => {
+      const installation = await runtimeInstallationFingerprint();
+      const fingerprints = candidates.map(candidate => {
         try { return [candidate.executable, runtimeFingerprint(candidate.executable)]; }
         catch (error) { return [candidate.executable, error.message]; }
-      })]);
+      });
+      const signature = JSON.stringify([installation, fingerprints]);
+      if (signature !== this.diagnosticCandidateSignature) {
+        this.diagnosticCandidateSignature = signature;
+        this.diagnose('runtime-candidates', { installation, candidates: candidates.map((candidate, index) => ({
+          executable: candidate.executable, source: candidate.source, fingerprint: fingerprints[index][1] })) });
+      }
       if (signature !== this.signature) {
-        await resolveCodexRuntime(this.stateRoot, { refresh: true });
+        const selected = await resolveCodexRuntime(this.stateRoot, { refresh: true });
         this.signature = signature;
+        this.diagnose('runtime-selected', { version: selected.version, source: selected.source,
+          executable: selected.executable, runningKernelPreserved: true });
       }
     } catch (error) { errors.push(error.message); }
     try {
       if (this.host.desktopIntegration === false) {
         this.state = { desktop: { state: 'unsupported', integrationSupported: false }, checkedAt: new Date().toISOString() };
         if (errors.length) this.state.discoveryError = errors.join('\n');
+        this.diagnoseState();
         return this.state;
       }
       const desktop = await this.host.inspect();
@@ -38,8 +48,18 @@ export class RuntimeDiscovery {
       this.state = { checkedAt: new Date().toISOString() };
     }
     if (errors.length) this.state.discoveryError = errors.join('\n');
+    this.diagnoseState();
     return this.state;
   }
+  diagnoseState() {
+    const details = { desktop: this.state.desktop || null,
+      desktopRestartRecommended: this.state.desktopRestartRecommended === true,
+      discoveryError: this.state.discoveryError || null, runningKernelPreserved: true };
+    const signature = JSON.stringify(details);
+    if (signature === this.diagnosticStateSignature) return;
+    this.diagnosticStateSignature = signature;
+    this.diagnose('runtime-discovery', details);
+  }
   async tick() {
     await this.sample();
     if (!this.stopped) { this.timer = setTimeout(() => this.tick(), this.interval); this.timer.unref?.(); }

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

@@ -3,7 +3,7 @@ import { EventEmitter } from 'node:events';
 import fs from 'node:fs';
 import WebSocket from 'ws';
 import { decode, loopbackUrl, relayAddress, send } from './wire.mjs';
-import { routedFileBytes, parseFileBytes } from './file-wire.mjs';
+import { routedFileBytes, parseFileBytes, sendFileFrame } from './file-wire.mjs';
 import { attachRtcFile } from './rtc-file-bridge.mjs';
 import { createP2pProbe, validProbeSignal } from './p2p-probe.mjs';
 import { createWindowsRouteHelper } from './windows-route-helper.mjs';
@@ -217,23 +217,26 @@ export function connectBridgeRelay({ relayUrl, hostKey, bridgeUrl, bridgeToken,
         const message = decode(bytes, binary);
         if (message.type === 'file-host-ready') return;
         if (message.type === 'file-open') {
+          if (typeof message.clientId !== 'string' || !/^[\w-]{16,128}$/.test(message.clientId)) throw new Error('Invalid file client identity');
           const connection = bridgeConnection?.() || { url: bridgeUrl, token: bridgeToken };
           const url = new URL(connection.url); url.pathname = '/api/file-transfer';
           loopbackUrl(url.href, '/api/file-transfer');
           const socket = new WebSocket(url.href, { maxPayload: 512 * 1024, perMessageDeflate: false });
           fileLocals.set(message.session, socket);
-          socket.on('open', () => send(socket, { type: 'auth', token: connection.token, purpose: message.purpose }));
+          socket.on('open', () => send(socket, { type: 'auth', token: connection.token, purpose: message.purpose,
+            uploadSessionId: message.uploadSessionId, resumeUpload: message.resumeUpload,
+            relayClientId: message.clientId, fileRelay: true }));
           socket.on('error', error => events.emit('diagnostic', `Local file receiver: ${error.message}`));
           socket.on('close', () => {
             if (fileLocals.get(message.session) !== socket) return;
             fileLocals.delete(message.session);
-            send(receiver, { type: 'file-close', session: message.session });
+            sendFileFrame(receiver, { type: 'file-close', session: message.session });
           });
           socket.on('message', (data, isBinary) => {
             if (fileLocals.get(message.session) !== socket) return socket.terminate();
-            if (receiver.readyState !== WebSocket.OPEN || receiver.bufferedAmount > 1024 * 1024) return socket.close(1013, 'File receiver too slow');
-            if (isBinary) receiver.send(routedFileBytes(message.session, data));
-            else send(receiver, { type: 'file-frame', session: message.session, payload: data.toString() });
+            if (receiver.readyState !== WebSocket.OPEN) return socket.close(1011, 'File receiver unavailable');
+            if (isBinary) sendFileFrame(receiver, routedFileBytes(message.session, data));
+            else sendFileFrame(receiver, { type: 'file-frame', session: message.session, payload: data.toString() });
           });
         } else if (message.type === 'file-frame') {
           const socket = fileLocals.get(message.session);

package/dist/src/self-relay/file-wire.mjs

@@ -11,3 +11,66 @@ export function parseFileBytes(bytes) {
   if (!/^[a-f0-9-]{36}$/.test(session)) throw new Error('Invalid file session');
   return { session, data: bytes.subarray(36) };
 }
+
+const senders = new WeakMap();
+// A workstation multiplexes up to eight three-chunk windows. Keep that burst
+// bounded without dropping every transfer when one shared socket gets busy.
+export function sendFileFrame(socket, data, { bytesPerSecond = 0, session = data?.session } = {}) {
+  if (!socket || socket.readyState !== socket.OPEN) return false;
+  let state = senders.get(socket);
+  if (!state) {
+    state = { queue: [], bytes: 0, active: false, nextAt: 0, timer: null, closed: false, bytesPerSecond };
+    senders.set(socket, state);
+    socket.once('close', () => {
+      state.closed = true; clearTimeout(state.timer); state.queue.length = 0; state.bytes = 0;
+    });
+  }
+  if (state.closeAfter) return false;
+  const payload = typeof data === 'string' || Buffer.isBuffer(data) ? data : JSON.stringify(data);
+  const size = Buffer.byteLength(payload);
+  if (size > 512 * 1024 || state.bytes + size > 8 * 1024 * 1024 || state.queue.length >= 128) {
+    socket.close(1013, 'File receiver too slow'); return false;
+  }
+  state.queue.push({ payload, size, session }); state.bytes += size;
+  const pump = () => {
+    if (state.active || state.closed || socket.readyState !== socket.OPEN) return;
+    if (!state.queue.length) {
+      if (state.closeAfter) socket.close(state.closeAfter.code, state.closeAfter.reason);
+      return;
+    }
+    const wait = state.nextAt - performance.now();
+    if (wait > 1) {
+      if (!state.timer) state.timer = setTimeout(() => { state.timer = null; pump(); }, wait);
+      return;
+    }
+    const frame = state.queue.shift(); state.active = true;
+    if (state.bytesPerSecond) state.nextAt = performance.now() + frame.size * 1000 / state.bytesPerSecond;
+    socket.send(frame.payload, error => {
+      if (state.closed) return;
+      state.bytes -= frame.size; state.active = false;
+      if (error) { socket.close(1011, 'File delivery failed'); return; }
+      pump();
+    });
+  };
+  state.pump = pump;
+  pump();
+  return true;
+}
+
+// Preserve an error/ack already queued before ending this file connection.
+// Revocation and account expiry deliberately use immediate socket.close instead.
+export function closeFileSocket(socket, code, reason) {
+  const state = senders.get(socket);
+  if (!state) { socket.close(code, reason); return; }
+  state.closeAfter = { code, reason };
+  state.pump();
+}
+
+export function discardFileSession(socket, session) {
+  const state = senders.get(socket);
+  if (!state) return;
+  state.queue = state.queue.filter(frame => {
+    if (frame.session !== session) return true;
+    state.bytes -= frame.size; return false;
+  });
+}

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

@@ -9,7 +9,7 @@ import { deviceStore, validId } from './device-store.mjs';
 import { randomUUID, timingSafeEqual } from 'node:crypto';
 import { WebSocketServer } from 'ws';
 import { secret, digest, matches, validSecret, send, decode } from './wire.mjs';
-import { routedFileBytes, parseFileBytes } from './file-wire.mjs';
+import { routedFileBytes, parseFileBytes, sendFileFrame, closeFileSocket, discardFileSession } from './file-wire.mjs';
 import { readDebugAllowlist, debugAllowed } from './debug-allowlist.mjs';
 import { validProbeSignal } from './p2p-probe.mjs';
 import { MAX_ADMIN_REQUEST_BYTES, relayAdminState } from './admin-state.mjs';
@@ -137,7 +137,10 @@ export async function startSelfRelay({ port = 0, hostKey = secret(), pairingTtlM
       observer?.ws.close(4401, 'Device authorization revoked');
       for (const [key, upload] of room.uploadClients || []) if (upload.clientId === message.id) {
         room.uploadClients.delete(key);
-        if (room.uploadHost) send(room.uploadHost, { type: 'file-close', session: upload.session });
+        if (room.uploadHost) {
+          discardFileSession(room.uploadHost, upload.session);
+          send(room.uploadHost, { type: 'file-close', session: upload.session });
+        }
         upload.ws.close(4401, 'Device authorization revoked');
       }
       for (const [socket, id] of room.deviceManagers || []) if (id === message.id) {
@@ -245,7 +248,10 @@ export async function startSelfRelay({ port = 0, hostKey = secret(), pairingTtlM
         for (const [clientId, upload] of room.uploadClients) {
           if (upload.userId !== userId) continue;
           room.uploadClients.delete(clientId);
-          if (room.uploadHost) send(room.uploadHost, { type: 'file-close', session: upload.session });
+          if (room.uploadHost) {
+            discardFileSession(room.uploadHost, upload.session);
+            send(room.uploadHost, { type: 'file-close', session: upload.session });
+          }
           upload.ws.close(4431, 'Account cancelled');
         }
       }
@@ -438,7 +444,10 @@ export async function startSelfRelay({ port = 0, hostKey = secret(), pairingTtlM
         if (room.host) send(room.host, { type: 'detach', session });
       } else if (role === 'file-client' && room?.uploadClients.get(session)?.ws === ws) {
         room.uploadClients.delete(session);
-        if (room.uploadHost) send(room.uploadHost, { type: 'file-close', session });
+        if (room.uploadHost) {
+          discardFileSession(room.uploadHost, session);
+          send(room.uploadHost, { type: 'file-close', session });
+        }
       }
       ws.close(4431, 'Account session invalid');
     }
@@ -491,7 +500,7 @@ export async function startSelfRelay({ port = 0, hostKey = secret(), pairingTtlM
         for (const client of room.uploadClients?.values() || []) client.ws.close(code === 4432 ? 4432 : 4410, code === 4432 ? 'File receiver inbound queue limit exceeded' : 'File receiver offline');
       } else if (role === 'file-client' && room?.uploadClients?.get(session)?.ws === ws) {
         room.uploadClients.delete(session);
-        if (room.uploadHost) send(room.uploadHost, { type: 'file-close', session });
+        if (room.uploadHost) sendFileFrame(room.uploadHost, { type: 'file-close', session }, { bytesPerSecond: 4 * 1024 * 1024 });
       }
     });
     let messageTail = Promise.resolve();
@@ -533,13 +542,11 @@ export async function startSelfRelay({ port = 0, hostKey = secret(), pairingTtlM
             const frame = parseFileBytes(bytes);
             const client = room.uploadClients.get(frame.session);
             if (!client || client.ws.readyState !== ws.OPEN) return;
-            if (client.ws.bufferedAmount > 1024 * 1024) return client.ws.close(1013, 'File receiver too slow');
-            client.ws.send(frame.data); return;
+            sendFileFrame(client.ws, frame.data, { bytesPerSecond: 1024 * 1024 }); return;
           }
           if (role === 'file-client' && room.uploadClients?.get(session)?.ws === ws) {
             if (room.uploadHost?.readyState !== ws.OPEN) return fail(4410, 'File receiver offline');
-            if (room.uploadHost.bufferedAmount > 1024 * 1024) return fail(1013, 'File receiver too slow');
-            room.uploadHost.send(routedFileBytes(session, bytes)); return;
+            sendFileFrame(room.uploadHost, routedFileBytes(session, bytes), { bytesPerSecond: 4 * 1024 * 1024, session }); return;
           }
           return fail(1008, 'Invalid binary frame');
         }
@@ -577,16 +584,31 @@ export async function startSelfRelay({ port = 0, hostKey = secret(), pairingTtlM
                 !matches(message.credential, client.hash)) return fail();
             room.uploadClients ||= new Map();
             if (!['upload', 'download'].includes(message.purpose)) return fail(1008, 'Invalid file purpose');
-            const same = [...room.uploadClients.values()].filter(item => item.clientId === message.clientId && item.purpose === message.purpose);
-            const all = [...rooms.values()].flatMap(item => [...(item.uploadClients?.values() || [])]);
+            if (message.purpose === 'upload' && (typeof message.uploadSessionId !== 'string' ||
+                !/^[a-f0-9-]{36}$/.test(message.uploadSessionId) || typeof message.resumeUpload !== 'boolean')) {
+              return fail(1008, 'Invalid upload session');
+            }
+            if (!await recordConnection(room, message.clientId, new Date().toISOString(), deviceInfo(message))) return fail(4401, 'Device authorization revoked');
+            if (ws.readyState !== ws.OPEN || !accountConnection.valid()) return;
+            if (room.host?.readyState !== ws.OPEN || room.uploadHost?.readyState !== ws.OPEN) return fail(4410, 'File receiver offline');
+            if (room.status !== 'active' || !room.clients.some(item => item.id === message.clientId && matches(message.credential, item.hash))) return fail(4401, 'Device authorization revoked');
+            const replacing = message.purpose === 'upload' ? [...room.uploadClients.values()].filter(item =>
+              item.clientId === message.clientId && item.uploadSessionId === message.uploadSessionId) : [];
+            const same = [...room.uploadClients.values()].filter(item => item.clientId === message.clientId && item.purpose === message.purpose && !replacing.includes(item));
+            const all = [...rooms.values()].flatMap(item => [...(item.uploadClients?.values() || [])]).filter(item => !replacing.includes(item));
             if (same.length >= (message.purpose === 'upload' ? 1 : 3) ||
                 all.length >= 8 || (message.purpose === 'upload' && all.filter(item => item.purpose === 'upload').length >= 2)) {
               return fail(4429, 'Too many file transfers');
             }
+            for (const old of replacing) {
+              room.uploadClients.delete(old.session);
+              sendFileFrame(room.uploadHost, { type: 'file-close', session: old.session }, { bytesPerSecond: 4 * 1024 * 1024 });
+              old.ws.close(4409, 'Upload connection replaced');
+            }
             role = 'file-client'; clientId = message.clientId; session = randomUUID(); clearTimeout(authTimer);
-            if (!await recordConnection(room, clientId, new Date().toISOString(), deviceInfo(message))) return fail(4401, 'Device authorization revoked');
-            room.uploadClients.set(session, { ws, session, clientId, userId, purpose: message.purpose });
-            send(room.uploadHost, { type: 'file-open', session, purpose: message.purpose }); return;
+            room.uploadClients.set(session, { ws, session, clientId, userId, purpose: message.purpose, uploadSessionId: message.uploadSessionId });
+            sendFileFrame(room.uploadHost, { type: 'file-open', session, purpose: message.purpose, clientId,
+              uploadSessionId: message.uploadSessionId, resumeUpload: message.resumeUpload }, { bytesPerSecond: 4 * 1024 * 1024 }); return;
           }
           if (message.type === 'host') {
             const durable = message.deviceId !== undefined;
@@ -881,7 +903,13 @@ export async function startSelfRelay({ port = 0, hostKey = secret(), pairingTtlM
               connection.ws.close(4401, 'Device authorization revoked');
             }
             room.connections.clear();
-            for (const client of room.uploadClients?.values() || []) client.ws.close(4401, 'Device authorization revoked');
+            for (const client of room.uploadClients?.values() || []) {
+              if (room.uploadHost) {
+                discardFileSession(room.uploadHost, client.session);
+                send(room.uploadHost, { type: 'file-close', session: client.session });
+              }
+              client.ws.close(4401, 'Device authorization revoked');
+            }
             room.uploadClients?.clear();
             for (const observer of room.observers.values()) observer.ws.close(4401, 'Device authorization revoked');
             room.observers.clear();
@@ -909,14 +937,13 @@ export async function startSelfRelay({ port = 0, hostKey = secret(), pairingTtlM
           const client = room.uploadClients.get(message.session);
           if (!client) return;
           if (message.type === 'file-frame' && typeof message.payload === 'string' && message.payload.length <= 512 * 1024) {
-            if (client.ws.bufferedAmount > 1024 * 1024) return client.ws.close(1013, 'File receiver too slow');
-            send(client.ws, { type: 'file-frame', payload: message.payload });
-          } else if (message.type === 'file-close') client.ws.close(1011, 'File receiver unavailable');
+            sendFileFrame(client.ws, { type: 'file-frame', payload: message.payload }, { bytesPerSecond: 1024 * 1024 });
+          } else if (message.type === 'file-close') closeFileSocket(client.ws, 1011, 'File receiver unavailable');
           else fail(1008, 'Invalid file frame');
         } else if (role === 'file-client' && room.uploadClients?.get(session)?.ws === ws) {
           if (message.type !== 'file-frame' || typeof message.payload !== 'string' || message.payload.length > 512 * 1024) return fail(1008, 'Invalid file frame');
-          if (room.uploadHost?.bufferedAmount > 1024 * 1024) return fail(1013, 'File receiver too slow');
-          send(room.uploadHost, { type: 'file-frame', session, payload: message.payload });
+          if (room.uploadHost?.readyState !== ws.OPEN) return fail(4410, 'File receiver offline');
+          sendFileFrame(room.uploadHost, { type: 'file-frame', session, payload: message.payload }, { bytesPerSecond: 4 * 1024 * 1024 });
         } else if (role === 'observer' && room.observers.get(clientId)?.ws === ws && message.type === 'official-computer') {
           const computer = normalizeOfficialComputer(message);
           await commit(room, { officialComputer: computer });

package/dist/src/server.mjs

@@ -95,6 +95,11 @@ const options = parseOptions(process.argv.slice(2));
 const runtimeVersion = readRuntimeVersion();
 const serviceInstanceId = crypto.randomUUID();
 
+function runtimeDiagnostic(event, details) {
+  console.log('[CodeRelax:runtime]', JSON.stringify({ at: new Date().toISOString(),
+    serviceVersion: runtimeVersion, servicePid: process.pid, serviceInstanceId, event, ...details }));
+}
+
 const webRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', 'web');
 const projectRoot = os.homedir();
 const { codexDataRoot, stateRoot, sessionsRoot, uploadsRoot } = runtimePaths();
@@ -115,13 +120,15 @@ const sessionPathCache = new Map();
 const sessionSettingsCache = new Map();
 const liveActivityCache = new Map();
 let sharedServer = null;
-const managedAppServer = new ManagedAppServer({ stateRoot, host: desktopHost });
+const managedAppServer = new ManagedAppServer({ stateRoot, host: desktopHost, diagnose: runtimeDiagnostic });
 const hostedHistoryCache = new HostedHistoryCache(stateRoot);
 const dotsServer = new DotsAppServer(managedAppServer.client, desktopDotsProfiles(codexDataRoot, stateRoot), hostedHistoryCache, { uploadsRoot });
 const dotsImages = new DotsMessageImages({ localServer: managedAppServer.client, identity: () => dotsServer.profileIdentity,
   cache: attachmentCache, capabilityKey: imageCapabilityKey, maxEntries: MAX_CACHED_ATTACHMENTS, maxBytes: MAX_ATTACHMENT_BYTES });
 const dotsChat = new DotsChatServer(dotsServer, undefined, { uploadsRoot });
-const runtimeDiscovery = new RuntimeDiscovery({ stateRoot, host: desktopHost, url: () => managedAppServer.snapshot().url });
+managedAppServer.on('state', state => { if (state.ready) dotsChat.startBackgroundActivity(); });
+const runtimeDiscovery = new RuntimeDiscovery({ stateRoot, host: desktopHost,
+  url: () => managedAppServer.snapshot().url, diagnose: runtimeDiagnostic });
 const relayManager = createRelayManager(stateRoot);
 let sharedCatalog = null, executionMode = 'ordinary';
 function selectSharedExecution(enabled) {
@@ -286,8 +293,9 @@ async function handleRequest(request, response) {
     if (request.method === 'POST' && ['/api/desktop/start', '/api/desktop/restart'].includes(url.pathname)) {
       const body = await readJsonBody(request);
       if (body.confirmed !== true) throw new RequestError(400, '请确认启动桌面端。');
-      const result = await startDesktop({ stateRoot, host: desktopHost, restart: url.pathname === '/api/desktop/restart' });
-      const observed = await runtimeDiscovery.sample();
+      let result, observed;
+      try { result = await startDesktop({ stateRoot, host: desktopHost, restart: url.pathname === '/api/desktop/restart' }); }
+      finally { observed = await runtimeDiscovery.sample(); }
       sendJson(response, 202, { ...result, desktop: observed.desktop, checkedAt: observed.checkedAt }); return;
     }
     if (request.method === 'POST' && url.pathname === '/api/shared-recovery') {
@@ -483,6 +491,12 @@ async function handleRequest(request, response) {
       return;
     }
 
+    const dotsActivityRetryMatch = /^\/api\/threads\/([^/]+)\/dots-activity\/retry$/.exec(url.pathname);
+    if (request.method === 'POST' && dotsActivityRetryMatch) {
+      if (!rootChat) throw new RequestError(405, '只有点点主聊天提供活动状态。');
+      sendJson(response, 200, { started: dotsChat.retryActivity(decodeURIComponent(dotsActivityRetryMatch[1])) });
+      return;
+    }
     const dotsActivityMatch = /^\/api\/threads\/([^/]+)\/dots-activity-events$/.exec(url.pathname);
     if (request.method === 'GET' && dotsActivityMatch) {
       if (!rootChat) throw new RequestError(405, '只有点点主聊天提供此活动面板。');
@@ -1077,6 +1091,7 @@ const lanSocket = attachLanSocket(server, { token: options.token, dispatch: hand
 
 let control;
 const powerManager = createPowerManager(stateRoot);
+runtimeDiagnostic('service.starting', { platform: process.platform, nodeVersion: process.version });
 void managedAppServer.start();
 executionHealth.start();
 runtimeDiscovery.start();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@walkhi/code-relax",
-  "version": "0.1.0-beta.71",
+  "version": "0.1.0-beta.76",
   "private": false,
   "license": "UNLICENSED",
   "type": "module",
@@ -41,8 +41,8 @@
     "tag": "beta"
   },
   "optionalDependencies": {
-    "@walkhi/code-relax-native-win32-x64": "0.1.0-beta.71",
-    "@walkhi/code-relax-native-darwin-arm64": "0.1.0-beta.71",
-    "@walkhi/code-relax-native-darwin-x64": "0.1.0-beta.71"
+    "@walkhi/code-relax-native-win32-x64": "0.1.0-beta.76",
+    "@walkhi/code-relax-native-darwin-arm64": "0.1.0-beta.76",
+    "@walkhi/code-relax-native-darwin-x64": "0.1.0-beta.76"
   }
 }