@walkhi/code-relax 0.1.0-beta.45 → 0.1.0-beta.50

package/dist/bin/codex-remote.mjs

@@ -290,7 +290,6 @@ async function main() {
     let stoppedForUpdate = false;
     const installed = await installService(packageRoot(path.dirname(fileURLToPath(import.meta.url))), serviceRoot, executable, physicalStateRoot, {
       beforeActivate: async () => {
-        if (desktopNeedsRestart) await desktopHost.closeDesktop(desktopBeforeSetup.desktop);
         stoppedForUpdate = resumeAfterUpdate;
         if (previousRelay.running && legacyRelaySession) {
           await controlRequest(legacyRelaySession, 'POST');

package/dist/bin/release-upload-server.mjs

@@ -12,6 +12,7 @@ import { fileURLToPath } from 'node:url';
 import { verifyReleaseIdentity, createUploadSigner } from '../relay-admin/release-oidc.mjs';
 import { androidReleaseStorage } from '../relay-admin/android-release-storage.mjs';
 import { readAndroidCatalog } from '../src/self-relay/android-releases.mjs';
+import { updatePublicWorkstations } from '../src/self-relay/public-releases.mjs';
 
 import { readHarmonyConfig, validateHarmonyMetadata, checkHarmonyVersion, verifyHarmony, activateHarmony } from '../relay-admin/harmony-release.mjs';
 
@@ -56,8 +57,23 @@ let busy = false;
 const server = http.createServer(async (req, res) => {
   const reply = (code, data) => { if (!res.destroyed) { res.writeHead(code, { 'Content-Type': 'application/json', 'Cache-Control': 'no-store' }); res.end(JSON.stringify(data)); } };
   let claims;
-  try { claims = await verifyReleaseIdentity((req.headers.authorization || '').replace(/^Bearer /, '')); }
+  const npmStatus = req.url === '/code-relax/publish/npm/status';
+  try { claims = await verifyReleaseIdentity((req.headers.authorization || '').replace(/^Bearer /, ''), npmStatus ? 'npm' : 'mobile'); }
   catch { reply(401, { ok: false, error: 'OIDC_REJECTED' }); return; }
+  if (npmStatus) {
+    try {
+      if (req.method !== 'POST') { reply(405, { ok: false, error: 'METHOD_NOT_ALLOWED' }); return; }
+      const { version } = await readJson(req);
+      const response = await fetch('https://registry.npmjs.org/@walkhi%2fcode-relax', { signal: AbortSignal.timeout(15000) });
+      if (!response.ok) throw Error('Registry unavailable');
+      const metadata = await response.json();
+      if (metadata['dist-tags']?.latest !== version || metadata['dist-tags']?.beta !== version
+        || !metadata.versions?.[version]) { reply(409, { ok: false, error: 'NPM_VERSION_MISMATCH' }); return; }
+      updatePublicWorkstations(version);
+      reply(200, { ok: true, version });
+    } catch { reply(500, { ok: false, error: 'NPM_STATUS_SYNC_FAILED' }); }
+    return;
+  }
   const target = /^\/code-relax\/publish\/(android|hap)\/intents(?:\/|$)/.exec(req.url || '')?.[1];
   if (!target) { reply(404, { ok: false, error: 'NOT_FOUND' }); return; }
   const prefix = `/code-relax/publish/${target}/intents`;

package/dist/build-platform.json

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

package/dist/shared/app-server-events.cjs

@@ -335,27 +335,37 @@
     }
     return optionsCache.context(threadId, contexts.get(threadId));
   }
-  async function createThread(request, target, input, settings, additionalContext) {
-    const { thread } = await request('thread/start', target);
-    const result = started => ({ threadId:thread.id, turnId:started?.turn?.id || null });
-    try {
-      const started = await request('turn/start', { threadId:thread.id, input,
-        ...mobileTurnSource(settings.clientUserMessageId, settings.containsVoiceInput),
-        ...(additionalContext ? { additionalContext: { ...additionalContext,
-          ...mobileTurnSource(settings.clientUserMessageId, settings.containsVoiceInput).additionalContext } } : {}),
-        ...(settings.clientUserMessageId ? { clientUserMessageId:settings.clientUserMessageId } : {}),
-        ...(settings.model ? { model:settings.model } : {}),
-        ...(settings.thinking ? { effort:settings.thinking } : {}),
-        ...(settings.serviceTier !== undefined ? { serviceTier:settings.serviceTier } : {}) });
-      return result(started);
-    } catch (error) {
-      // The known thread and the late first turn together form one creation receipt.
-      if (error.deliveryResult) error.deliveryResult = error.deliveryResult.then(result, lateError => {
-        // The thread already exists even if its first turn was rejected.
-        throw Object.assign(new Error(lateError.message || '新对话首条消息未确认'), { cause: lateError, deliveryUnknown: true });
-      });
+  async function createThread(request, target, input, settings, additionalContext, onThreadCreated = () => {}) {
+    let response;
+    try { response = await request('thread/start', target); }
+    catch (error) {
+      if (error.deliveryResult) error.deliveryResult = error.deliveryResult.then(result => startFirstTurn(result.thread))
+        .catch(lateError => { if (lateError.deliveryResult) return lateError.deliveryResult; throw lateError; });
       throw error;
     }
+    return startFirstTurn(response.thread);
+    async function startFirstTurn(thread) {
+      onThreadCreated(thread.id);
+      const result = started => ({ threadId:thread.id, turnId:started?.turn?.id || null });
+      try {
+        const started = await request('turn/start', { threadId:thread.id, input,
+          ...mobileTurnSource(settings.clientUserMessageId, settings.containsVoiceInput),
+          ...(additionalContext ? { additionalContext: { ...additionalContext,
+            ...mobileTurnSource(settings.clientUserMessageId, settings.containsVoiceInput).additionalContext } } : {}),
+          ...(settings.clientUserMessageId ? { clientUserMessageId:settings.clientUserMessageId } : {}),
+          ...(settings.model ? { model:settings.model } : {}),
+          ...(settings.thinking ? { effort:settings.thinking } : {}),
+          ...(settings.serviceTier !== undefined ? { serviceTier:settings.serviceTier } : {}) });
+        return result(started);
+      } catch (error) {
+        // The known thread and the late first turn together form one creation receipt.
+        if (error.deliveryResult) error.deliveryResult = error.deliveryResult.then(result, lateError => {
+          // The thread already exists even if its first turn was rejected.
+          throw Object.assign(new Error(lateError.message || '新对话首条消息未确认'), { cause: lateError, deliveryUnknown: true });
+        });
+        throw error;
+      }
+    }
   }
   function projectThreadTarget(project) {
     const roots = project.roots.map(root => root.path);

package/dist/shared/message-delivery.cjs

@@ -21,9 +21,24 @@
   class Store {
     constructor() { this.entries = new Map(); }
     key(scope, clientId) { return JSON.stringify([scope, clientId]); }
+    beginCreation(scope, clientId) {
+      const entry = this.entries.get(this.key(scope, clientId));
+      let finish;
+      entry.creationReady = new Promise(resolve => { finish = resolve; });
+      return threadId => {
+        if (threadId) entry.createdThreadId = threadId;
+        finish();
+      };
+    }
+    async creationBindings() {
+      await Promise.all([...this.entries.values()].map(entry => entry.creationReady));
+      return new Map([...this.entries].filter(([, entry]) => entry.createdThreadId)
+        .map(([key, entry]) => [entry.createdThreadId, JSON.parse(key)[1]]));
+    }
     status(scope, clientId) {
       const entry = this.entries.get(this.key(scope, clientId));
       return entry ? { state: entry.state, ...(entry.result ? { result: entry.result } : {}),
+        ...(entry.createdThreadId ? { createdThreadId: entry.createdThreadId } : {}),
         ...(entry.error ? { error: entry.error.message } : {}) } : { state: 'unknown' };
     }
     async reconcile(scope, clientId, inspect) {

package/dist/shared/server-requests.cjs

@@ -6,6 +6,7 @@
   const file = 'item/fileChange/requestApproval';
   const input = 'item/tool/requestUserInput';
   const elicitation = 'mcpServer/elicitation/request';
+  const permissions = 'item/permissions/requestApproval';
   const equal = (a, b) => JSON.stringify(a) === JSON.stringify(b);
   const approvalId = request => 'approval:' + (request.params.turnId || '') + ':' + typeof request.id + ':' + request.id;
   function confirmation(request) {
@@ -98,10 +99,86 @@
       _meta: decision === 'allowAlways' ? { persist: 'always' }
         : decision === 'allowSession' ? { persist: 'session' } : null };
   }
+  function externalAction(request) {
+    const p = request.params || {};
+    if (request.method !== elicitation || p.mode !== 'url') return null;
+    try {
+      const url = new URL(p.url);
+      if (url.protocol !== 'https:' || url.username || url.password) return null;
+      if (p.serverName !== 'codex_apps') return { url: url.href, connector: null };
+      const connector = p._meta?._codex_apps?.connector_auth_failure;
+      const trusted = host => ['chatgpt.com', 'chatgpt-staging.com'].some(domain => host === domain || host.endsWith('.' + domain));
+      if (!trusted(url.hostname) || connector?.is_auth_failure !== true
+        || typeof connector.connector_id !== 'string' || typeof connector.connector_name !== 'string'
+        || typeof connector.install_url !== 'string' || connector.connection_consent != null) return null;
+      return { url: url.href, connector };
+    } catch { return null; }
+  }
+  function elicitationResult(action, content = null) { return { action, content: action === 'accept' ? content : null, _meta: null }; }
+  function fieldOptions(field) {
+    const schema = field.type === 'array' ? field.items : field;
+    if (Array.isArray(schema?.enum)) return schema.enum.map((value, index) => ({ value, label: schema.enumNames?.[index] || value }));
+    const options = schema?.oneOf || schema?.anyOf;
+    return Array.isArray(options) ? options.map(option => ({ value: option.const, label: option.title || option.const })) : null;
+  }
+  function formSchema(request) {
+    const p = request.params || {}, meta = p._meta || {}, schema = p.requestedSchema;
+    // Specialized approvals, credentials and OpenAI forms have their own response contracts.
+    if (request.method !== elicitation || p.mode !== 'form' || meta.codex_approval_kind
+      || meta['openai/elicitation'] || meta['openai/confirmation'] || schema?.type !== 'object'
+      || ['browser', 'browser-use'].includes(p.serverName)
+      || !schema.properties || typeof schema.properties !== 'object' || Array.isArray(schema.properties)
+      || Object.keys(schema).some(key => !['$schema', 'type', 'properties', 'required'].includes(key))) return null;
+    const known = ['type', 'title', 'description', 'default', 'minLength', 'maxLength', 'format', 'minimum', 'maximum', 'enum', 'enumNames', 'oneOf', 'items', 'minItems', 'maxItems'];
+    for (const field of Object.values(schema.properties)) {
+      if (!field || Object.keys(field).some(key => !known.includes(key))
+        || !['string', 'number', 'integer', 'boolean', 'array'].includes(field.type)) return null;
+      const options = fieldOptions(field);
+      if ((field.type === 'array' || field.enum != null || field.oneOf != null) && !options
+        || options && (!options.length || options.some(option => typeof option.value !== 'string' || typeof option.label !== 'string'))) return null;
+      if (field.format && !['email', 'uri', 'date', 'date-time'].includes(field.format)) return null;
+    }
+    if (schema.required != null && (!Array.isArray(schema.required) || schema.required.some(key => !Object.hasOwn(schema.properties, key)))) return null;
+    return schema;
+  }
+  function validateForm(schema, values) {
+    if (!values || typeof values !== 'object' || Array.isArray(values)
+      || Object.keys(values).some(key => !Object.hasOwn(schema.properties, key))) throw new Error('表单内容无效');
+    for (const [key, field] of Object.entries(schema.properties)) {
+      const value = values[key], label = field.title || key;
+      if (value === undefined) { if (schema.required?.includes(key)) throw new Error(`请填写${label}`); continue; }
+      let valid = field.type === 'array' ? Array.isArray(value) : typeof value === (field.type === 'integer' ? 'number' : field.type);
+      if (typeof value === 'number') valid &&= Number.isFinite(value) && (field.type !== 'integer' || Number.isInteger(value))
+        && (field.minimum == null || value >= field.minimum) && (field.maximum == null || value <= field.maximum);
+      if (typeof value === 'string') {
+        valid &&= (field.minLength == null || [...value].length >= field.minLength) && (field.maxLength == null || [...value].length <= field.maxLength);
+        if (field.format === 'email') valid &&= /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value);
+        if (field.format === 'uri') { try { new URL(value); } catch { valid = false; } }
+        if (field.format === 'date') valid &&= /^\d{4}-\d{2}-\d{2}$/.test(value) && !Number.isNaN(Date.parse(value));
+        if (field.format === 'date-time') valid &&= /^\d{4}-\d{2}-\d{2}T.+(?:Z|[+-]\d{2}:\d{2})$/.test(value) && !Number.isNaN(Date.parse(value));
+      }
+      const options = fieldOptions(field);
+      if (Array.isArray(value)) valid &&= new Set(value).size === value.length && (field.minItems == null || value.length >= field.minItems)
+        && (field.maxItems == null || value.length <= field.maxItems) && value.every(item => options?.some(option => option.value === item));
+      else if (options) valid &&= options.some(option => option.value === value);
+      if (!valid) throw new Error(`${label}的内容不符合请求要求`);
+    }
+  }
+  function permissionResult(request, decision) {
+    return { permissions: decision === 'decline' ? {} : request.params.permissions, scope: decision === 'acceptForSession' ? 'session' : 'turn' };
+  }
+  function blocksComposer(request) {
+    if (externalAction(request)) return false;
+    return request.method === input || Boolean(formSchema(request))
+      || request.method !== elicitation && decisions(request).length > 0
+      || request.method === elicitation && decisions(request).some(value => value !== 'cancel');
+  }
   function decisions(request) {
     if (confirmation(request)) return ['decline', 'accept'];
     if (request.method === command) return request.params.availableDecisions ?? ['accept', 'acceptForSession', 'decline', 'cancel'];
     if (request.method === file) return ['accept', 'acceptForSession', 'decline', 'cancel'];
+    if (request.method === permissions && request.params.permissions) return ['accept', 'acceptForSession', 'decline'];
+    if (externalAction(request)) return ['decline', 'accept'];
     const action = browserAction(request);
     if (action) return ['allowOnce', ...(action.session ? ['allowSession'] : []), ...(action.persistent ? ['allowAlways'] : []), 'cancel'];
     const app = computerAppAccess(request);
@@ -110,9 +187,24 @@
     if (browser) return browser.persistent ? ['allowOnce', 'allowSite', 'allowAllSites', 'decline'] : ['allowOnce', 'decline'];
     const tool = mcpToolApproval(request);
     if (tool) return ['decline', 'allowOnce', ...(tool.session ? ['allowSession'] : []), ...(tool.persistent ? ['allowAlways'] : [])];
-    return [];
+    return request.method === elicitation ? ['cancel'] : [];
   }
   function validate(request, result) {
+    if (request.method === elicitation && equal(result, elicitationResult('cancel'))) return;
+    if (externalAction(request)) {
+      if (!['accept', 'decline'].some(action => equal(result, elicitationResult(action)))) throw new Error('外部操作结果无效');
+      return;
+    }
+    const schema = formSchema(request);
+    if (schema) {
+      if (equal(result, elicitationResult('decline'))) return;
+      if (result?.action !== 'accept' || result._meta !== null || Object.keys(result).length !== 3) throw new Error('表单响应格式无效');
+      validateForm(schema, result.content); return;
+    }
+    if (request.method === permissions) {
+      if (!decisions(request).some(decision => equal(result, permissionResult(request, decision)))) throw new Error('权限决定不属于当前请求');
+      return;
+    }
     if (confirmation(request)) {
       if (!decisions(request).some(decision => equal(confirmationResult(request, decision), result))) throw new Error('确认结果不属于当前请求');
       return;
@@ -215,5 +307,5 @@
       return { submitted: true };
     }
   }
-  return { Store, decisions, validate, command, file, input, elicitation, browserAccess, browserAction, browserActionResult, computerAppAccess, computerAppResult, mcpToolApproval, mcpToolResult, confirmation, confirmationResult };
+  return { Store, decisions, validate, command, file, input, elicitation, permissions, externalAction, elicitationResult, formSchema, fieldOptions, validateForm, permissionResult, blocksComposer, browserAccess, browserAction, browserActionResult, computerAppAccess, computerAppResult, mcpToolApproval, mcpToolResult, confirmation, confirmationResult };
 });

package/dist/src/desktop-launcher.mjs

@@ -1,16 +1,36 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { setTimeout as delay } from 'node:timers/promises';
-import { readRecord } from './service-lifecycle.mjs';
-import { ManagedAppServer, managedPortAvailable as portAvailable } from './managed-app-server.mjs';
+import { readRecord, lifecycle } from './service-lifecycle.mjs';
+import * as serviceHost from './platform/service-host.mjs';
+import { managedPortAvailable as portAvailable } from './managed-app-server.mjs';
+import { readManagedEndpoint } from './managed-endpoint.mjs';
 export { portAvailable };
-export async function launchDesktop({ stateRoot, host, environment = process.env, available = portAvailable, wait = delay, timeout = 30000, recoveryId, progress = () => {} }) {
+function desktopEnvironment(stateRoot, environment) {
+  const childEnv = { ...environment };
+  for (const key of ['CODEX_APP_SERVER_WS_URL', 'CODEX_APP_SERVER_FORCE_CLI', 'CODEX_APP_TOOLS_PIPE_PATH']) delete childEnv[key];
+  const runtime = readRecord(path.join(stateRoot, 'codex-runtime.json'));
+  if (runtime?.codexHome) childEnv.CODEX_HOME = runtime.codexHome;
+  childEnv.CODEX_APP_SERVER_WS_URL = readManagedEndpoint(stateRoot);
+  return childEnv;
+}
+
+// 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 桌面端启动请求。' };
+}
+
+export async function launchDesktop({ stateRoot, host, environment = process.env, wait = delay, timeout = 30000, recoveryId, progress = () => {}, service = lifecycle({ stateRoot, host: serviceHost }) }) {
   fs.mkdirSync(stateRoot, { recursive: true });
   const recovery = readRecord(path.join(stateRoot, 'shared-recovery.lock'));
   if (recovery && recovery.operationId !== recoveryId) throw new Error('Codex 内核正在启动，请用 relax doctor 查看恢复状态。');
   const lock = path.join(stateRoot, 'desktop-launch.lock');
   let descriptor;
-  let managed;
   try { descriptor = fs.openSync(lock, 'wx'); }
   catch (error) {
     if (error.code === 'EEXIST') throw new Error('另一个 Desktop 启动操作正在进行；若上次异常退出，请确认没有启动器运行后移除 desktop-launch.lock。');
@@ -24,14 +44,10 @@ export async function launchDesktop({ stateRoot, host, environment = process.env
       if (connected) return { reused: true };
       throw new Error('请先保存任务并完全退出 Codex Desktop，再接入 Codex 内核；不会自动结束正在运行的任务。');
     }
-    const childEnv = { ...environment };
-    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 || 'Codex 内核未就绪。');
-    const runtime = readRecord(path.join(stateRoot, 'codex-runtime.json'));
-    if (runtime?.codexHome) childEnv.CODEX_HOME = runtime.codexHome;
-    childEnv.CODEX_APP_SERVER_WS_URL = managed.snapshot().url;
+    const health = await service.status();
+    if (!health.running || !health.managedAppServer?.ready) throw new Error(health.managedAppServer?.error || '工作站 Codex 内核未就绪。');
+    const childEnv = desktopEnvironment(stateRoot, environment);
     progress('starting-desktop');
     await host.startDesktop(info.desktop, childEnv);
     const deadline = Date.now() + timeout;
@@ -42,5 +58,5 @@ export async function launchDesktop({ stateRoot, host, environment = process.env
       await wait(500);
     }
     return { reused: false };
-  } finally { managed?.close(); fs.closeSync(descriptor); fs.rmSync(lock, { force: true }); }
+  } finally { fs.closeSync(descriptor); fs.rmSync(lock, { force: true }); }
 }

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

@@ -426,7 +426,7 @@ export class DotsChatServer extends HostedHistoryAppServer {
     const current = await this.rooms.request(`${route}?inspect=true`), request = current.elicitation;
     if (epoch !== this.epoch || this.bindings.get(threadId) !== room || request?.request_id !== body.id
       || request.params?.threadId !== request.thread_id || typeof current.request_fingerprint !== 'string') throw new Error('确认请求已变化，请重新核对。');
-    if (!serverRequests.confirmation({ method: serverRequests.elicitation, params: request.params })) throw new Error('此房间请求尚未支持');
+    if (!request.params || typeof request.params.mode !== 'string') throw new Error('此房间请求格式无效');
     const key = JSON.stringify([room.id, body.roomMessageId, body.id]);
     return { requestId: request.request_id, params: request.params, fingerprint: current.request_fingerprint,
       status: current.runtime_status, canRespond: current.can_respond === true && current.runtime_status === 'pending',

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

@@ -137,6 +137,8 @@ export class DotsRoomActivity extends EventEmitter {
       await this.server.rooms.request(`/messaging/rooms/${encodeURIComponent(room.id)}/live`, {
         method: 'POST', signal: controller.signal, onEvent: value => {
           if (!current()) return;
+          // The live SSE sends {} keepalives after ready; they carry no identity.
+          if (value && typeof value === 'object' && !Array.isArray(value) && Object.keys(value).length === 0) return;
           if (value?.type !== 'calpico-room-live-ready' || value.version !== 1 || value.room_id !== room.id
             || typeof value.subscription_id !== 'string' || watch.subscriptionId && watch.subscriptionId !== value.subscription_id) {
             throw new Error('点点活动订阅身份无效。');

package/dist/src/platform/windows/desktop-info.ps1

@@ -35,4 +35,4 @@ $package = Get-AppxPackage OpenAI.Codex | Select-Object -First 1
 if (-not $package) { @{ desktop=$null; running=$false } | ConvertTo-Json -Compress; exit }
 $desktop = Join-Path $package.InstallLocation 'app/ChatGPT.exe'
 $running = @(Get-Process ChatGPT -ErrorAction SilentlyContinue | Where-Object { $_.Path -eq $desktop })
-@{ desktop=$desktop; running=($running.Count -gt 0); hasWindow=(@($running | Where-Object { $_.MainWindowHandle -ne 0 }).Count -gt 0) } | ConvertTo-Json -Compress
+@{ desktop=$desktop; version=$package.Version.ToString(); running=($running.Count -gt 0); hasWindow=(@($running | Where-Object { $_.MainWindowHandle -ne 0 }).Count -gt 0) } | ConvertTo-Json -Compress

package/dist/src/runtime-discovery.mjs

@@ -31,7 +31,7 @@ export class RuntimeDiscovery {
       const desktop = await this.host.inspect();
       const attached = desktop.running && await this.host.sharedServiceUrl() === (typeof this.url === 'function' ? this.url() : this.url);
       this.state = { desktop: { state: !desktop.running ? 'stopped' : attached ? 'managed' : 'ordinary',
-        installed: Boolean(desktop.desktop), attachedToManagedServer: Boolean(attached) },
+        installed: Boolean(desktop.desktop), version: desktop.version || '', attachedToManagedServer: Boolean(attached) },
         desktopRestartRecommended: Boolean(desktop.running && !attached), checkedAt: new Date().toISOString() };
     } catch (error) {
       errors.push(error.message);

package/dist/src/self-relay/public-releases.mjs

@@ -26,10 +26,7 @@ export function updatePublicHarmony(release, file = publicManifestFile) {
 }
 
 function updateMobileManifest(platform, release, file) {
-  const lock = file + '.lock', temporary = file + '.new';
-  const handle = fs.openSync(lock, 'wx', 0o600);
-  try {
-    const manifest = readPublicManifest(file);
+  return updatePublicManifest(manifest => {
     if (manifest[platform].versionCode > release.versionCode) throw new Error('Public Android version would go backwards');
     manifest[platform] = { status: 'published', statusText: { zh: '', en: '' }, version: release.versionName,
       versionCode: release.versionCode, size: release.size, sha256: release.sha256,
@@ -39,6 +36,24 @@ function updateMobileManifest(platform, release, file) {
       manifest.harmonyos.url = 'https://www.coderelax.cn/code-relax/install';
       manifest.harmonyos.manifestUrl = release.manifestUrl;
     }
+  }, file);
+}
+
+export function updatePublicWorkstations(version, file = publicManifestFile) {
+  if (!/^\d+\.\d+\.\d+-beta\.\d+$/.test(version)) throw Error('Invalid npm version');
+  return updatePublicManifest(manifest => {
+    for (const platform of ['windows', 'macos', 'linux']) {
+      if (manifest[platform].status === 'published') manifest[platform].version = version;
+    }
+  }, file);
+}
+
+export function updatePublicManifest(update, file = publicManifestFile) {
+  const lock = file + '.lock', temporary = file + '.new';
+  const handle = fs.openSync(lock, 'wx', 0o600);
+  try {
+    const manifest = readPublicManifest(file);
+    update(manifest);
     const owner = fs.statSync(file);
     fs.writeFileSync(temporary, JSON.stringify(manifest, null, 2) + '\n', { mode: owner.mode & 0o777 });
     fs.chmodSync(temporary, owner.mode & 0o777);

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

@@ -989,7 +989,7 @@ function controlPayload(value) {
     const message = JSON.parse(value);
     if (message.type === 'unsubscribe') return true;
     return ['request', 'subscribe'].includes(message.type) && typeof message.path === 'string' &&
-      (message.path === '/api/health' || message.path === '/api/desktop/start' || message.path.startsWith('/api/shared-recovery'));
+      (message.path === '/api/health' || ['/api/desktop/start', '/api/desktop/restart'].includes(message.path) || message.path.startsWith('/api/shared-recovery'));
   } catch { return false; }
 }
 

package/dist/src/server.mjs

@@ -38,6 +38,7 @@ import { DotsMessageImages } from './dots-message-images.mjs';
 import { desktopDotsProfiles } from './platform/windows/dots-profile.mjs';
 import { readPlanPricing } from './plan-pricing.mjs';
 import { requestRecovery, recoveryStatus } from './shared-recovery.mjs';
+import { startDesktop } from './desktop-launcher.mjs';
 import { requestServiceRestart } from './service-restart.mjs';
 import { checkServiceUpdate, requestServiceUpdate, serviceUpdateStatus } from './service-update.mjs';
 import { TurnModelHistory } from './turn-model-history.mjs';
@@ -261,10 +262,17 @@ async function handleRequest(request, response) {
     if (request.method === 'GET' && url.pathname === '/api/shared-recovery') {
       sendJson(response, 200, await recoveryStatus(stateRoot)); return;
     }
-    if (request.method === 'POST' && ['/api/shared-recovery', '/api/desktop/start'].includes(url.pathname)) {
+    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' });
+      await runtimeDiscovery.sample();
+      sendJson(response, 202, result); return;
+    }
+    if (request.method === 'POST' && url.pathname === '/api/shared-recovery') {
       const body = await readJsonBody(request);
       if (body.confirmed !== true || typeof body.operationId !== 'string') throw new RequestError(400, '请确认重新打开当前 Codex 并接入 Codex 内核后再继续。');
-      sendJson(response, 202, await requestRecovery(stateRoot, { ...body, startOnly: url.pathname === '/api/desktop/start' })); return;
+      sendJson(response, 202, await requestRecovery(stateRoot, body)); return;
     }
     if (url.pathname === '/api/service/update' && request.method === 'GET') {
       sendJson(response, 200, await checkServiceUpdate(stateRoot)); return;
@@ -494,7 +502,13 @@ async function handleRequest(request, response) {
       const archived = url.searchParams.get('archived') === 'true';
       const scope = url.searchParams.get('scope') || 'all';
       if (!['all', 'local', 'durable'].includes(scope)) { sendJson(response, 400, { error: '无效的会话列表范围' }); return; }
-      sendJson(response, 200, await sharedCatalog.threads(limit, archived, scope, url.searchParams.get('refresh') === '1'));
+      const catalog = await sharedCatalog.threads(limit, archived, scope, url.searchParams.get('refresh') === '1');
+      const creations = await messageReceipts.creationBindings();
+      for (const thread of [...(catalog.threads || []), ...(catalog.pinnedThreads || [])]) {
+        const clientId = creations.get(thread.id);
+        if (clientId && (thread.hostId || 'local') === 'local') thread.creationClientId = clientId;
+      }
+      sendJson(response, 200, catalog);
       return;
     }
 
@@ -708,13 +722,23 @@ async function handleRequest(request, response) {
 
     const createStatusMatch = /^\/api\/projects\/([^/]+)\/threads\/([a-f0-9]{32})\/status$/.exec(url.pathname);
     if (request.method === 'GET' && createStatusMatch) {
-      sendJson(response, 200, messageReceipts.status(['project', decodeURIComponent(createStatusMatch[1])], createStatusMatch[2])); return;
+      const creationScope = ['project', decodeURIComponent(createStatusMatch[1])], clientId = createStatusMatch[2];
+      let status = messageReceipts.status(creationScope, clientId);
+      if (status.state === 'unknown' && status.createdThreadId) {
+        const threadId = status.createdThreadId;
+        status = await messageReceipts.reconcile(creationScope, clientId, async () => {
+          const found = await sharedServer.findSentMessage(threadId, clientId);
+          return found ? { threadId, hostId: 'local', turnId: found.data?.turnId } : null;
+        });
+      }
+      sendJson(response, 200, status); return;
     }
     const createThreadMatch = /^\/api\/projects\/([^/]+)\/threads$/.exec(url.pathname);
     if (request.method === 'POST' && createThreadMatch) {
       const projectId = decodeURIComponent(createThreadMatch[1]);
       const body = await readJsonBody(request);
       const result = await messageReceipts.submit(['project', projectId], body.clientUserMessageId, async () => {
+        const bindCreation = messageReceipts.beginCreation(['project', projectId], body.clientUserMessageId);
         try {
           await requireExecutionWritable();
           if (body.transport === 'app-server' || (body.hostId && body.hostId !== 'local')) {
@@ -735,7 +759,7 @@ async function handleRequest(request, response) {
           }
           const { input } = appServerTurnArguments('', body);
           messageSubmissionStarted = true;
-          const created = await appServerEvents.createThread(rpc, target, input, body);
+          const created = await appServerEvents.createThread(rpc, target, input, body, undefined, bindCreation);
           const prompt = input.filter(part => part.type === 'text').map(part => part.text).join('\n');
           void generateAndSetThreadTitle({
             request: rpc,
@@ -749,8 +773,10 @@ async function handleRequest(request, response) {
           }).catch(error => console.error(`生成对话标题失败：${error.message}`));
           return { ...created, hostId:'local' };
         } catch (error) {
-          error.deliveryUnknown = messageSubmissionStarted;
-          if (error.deliveryResult) error.deliveryResult = error.deliveryResult.then(created => ({ ...created, hostId: 'local' }));
+          error.deliveryUnknown = Boolean(messageReceipts.status(['project', projectId], body.clientUserMessageId).createdThreadId)
+            || messageSubmissionStarted && !messageDelivery.rejectedBeforeSubmission(error);
+          if (error.deliveryResult) error.deliveryResult = error.deliveryResult.then(created => ({ ...created, hostId: 'local' })).finally(() => bindCreation());
+          else bindCreation();
           throw error;
         }
       });

package/dist/src/service-doctor.mjs

@@ -59,7 +59,18 @@ export async function doctor({ paths, host, service, skillTarget, ensureAutostar
       : `已安装版本 ${installedVersion}，但无法确认运行服务版本；请保留诊断结果核查，不能据此认定旧进程或自动重启。`);
     if (state.running) add('execution', state.execution?.ready === true && state.execution?.canWrite === true ? 'ok' : 'error',
       state.execution?.ready === true && state.execution?.canWrite === true
-        ? 'Codex 完整控制已就绪且可写。' : 'Codex 完整控制尚未确认就绪且可写；请查看内核和连接诊断，不能仅凭服务在线判定健康。');
+        ? 'Codex 完整控制通道已就绪；单个对话的写入权限需在打开该对话时确认。' : 'Codex 完整控制尚未确认就绪且可写；请查看内核和连接诊断，不能仅凭服务在线判定健康。');
+    if (state.running && state.desktop) {
+      const descriptions = {
+        managed: '桌面端已接入 Code Relax 内核。',
+        ordinary: '桌面端正在独立运行，未接入 Code Relax 内核；若同一对话报写入冲突，请核对桌面端占用。',
+        stopped: '桌面端未启动；手机可独立使用已就绪的内核。',
+        unsupported: '当前平台未提供桌面端接入。',
+      };
+      add('desktop', 'ok', state.desktop.installed === false && state.desktop.state !== 'unsupported'
+        ? '未安装桌面端；手机可独立使用已就绪的内核。'
+        : descriptions[state.desktop.state] || '桌面端接入状态暂未确认。');
+    }
     const currentVersion = state.managedAppServer?.version || null;
     const selectedVersion = state.managedAppServer?.selectedVersion || null;
     if (state.managedAppServer) kernelUpdate = { pending: state.managedAppServer.updatePending === true,
@@ -91,13 +102,20 @@ export async function doctor({ paths, host, service, skillTarget, ensureAutostar
     collectedAt: new Date().toISOString(), platform: process.platform, arch: process.arch, osRelease: os.release(),
     nodeVersion: process.version, nodeExecutable: process.execPath, serviceRoot: paths.serviceRoot,
     servicePid: serviceState?.pid || null, port: serviceState?.port || null, serviceVersion: serviceState?.version || null,
+    kernel: serviceState?.managedAppServer ? {
+      version: serviceState.managedAppServer.version || null,
+      executable: serviceState.managedAppServer.executable || null,
+      selectedVersion: serviceState.managedAppServer.selectedVersion || null,
+      preferredExecutable: serviceState.managedAppServer.preferredExecutable || null,
+      selectedSource: serviceState.managedAppServer.source || null,
+    } : null,
   } } : {}) };
 }
 
 export function formatDoctorOutput(result, detail = false) {
   const labels = { 'keep-awake': '保持唤醒', installation: '安装文件', 'bridge-runtime': '运行环境', network: '局域网',
     autostart: '登录自启动', service: '工作站服务', 'managed-app-server': 'Codex 内核',
-    execution: '完整控制', 'package-version': '安装包版本', 'service-version': '服务版本', 'managed-app-server-update': 'Codex 更新',
+    execution: '完整控制', desktop: 'Codex 桌面端', 'package-version': '安装包版本', 'service-version': '服务版本', 'managed-app-server-update': 'Codex 更新',
     'managed-app-server-launcher': '工作站更新', skill: 'Codex Skill' };
   const byId = id => result.checks.find(item => item.id === id);
   const summary = (id, success) => {
@@ -106,7 +124,7 @@ export function formatDoctorOutput(result, detail = false) {
   };
   const issues = result.checks.filter(item => item.status !== 'ok');
   const lines = [result.ready ? '工作站检查通过。' : '工作站检查发现问题。',
-    summary('installation', '完整'), summary('package-version', 'CLI 与固定服务一致'), summary('service', '正在运行'), summary('managed-app-server', '已就绪'), summary('execution', '已就绪且可写')];
+    summary('installation', '完整'), summary('package-version', 'CLI 与固定服务一致'), summary('service', '正在运行'), summary('managed-app-server', '已就绪'), summary('execution', '通道已就绪（不代表每个对话均可写）')];
   if (issues.length) lines.push('', '需要处理或留意：', ...issues.map(item => `- ${labels[item.id] || item.id}：${item.message}`));
   if (detail) {
     const info = result.diagnostics || {};
@@ -115,6 +133,9 @@ export function formatDoctorOutput(result, detail = false) {
       `Node：${info.nodeVersion || process.version}；${info.nodeExecutable || process.execPath}`,
       `服务目录：${info.serviceRoot || '未知'}`, `服务进程：${info.servicePid || '未运行'}；端口：${info.port || '未知'}`, '');
     lines.push('', '检查详情：', ...result.checks.filter(item => item.status === 'ok').map(item => `- ${labels[item.id] || item.id}：${item.message}`));
+    if (info.kernel) lines.push('',
+      `运行内核：${info.kernel.version || '未知'}；${info.kernel.executable || '路径未知'}`,
+      `候选内核：${info.kernel.selectedVersion || '未知'}；来源 ${info.kernel.selectedSource || '未知'}；${info.kernel.preferredExecutable || '路径未知'}`);
     const recovery = result.desktopRecovery;
     if (recovery && !['none', 'unsupported'].includes(recovery.status)) {
       const status = { failed: '未完成', completed: '已完成', succeeded: '已完成', running: '进行中', unknown: '无法读取' }[recovery.status] || recovery.status;

package/dist/src/service-restart.mjs

@@ -20,12 +20,12 @@ export async function requestServiceRestart(stateRoot) {
   const lock = path.join(stateRoot, 'service-restart.lock');
   const operationId = randomUUID();
   const owner = await processIdentity(process.pid);
-  if (!owner) throw new Error('无法确认服务重启请求进程。');
+  if (!owner) throw new Error('无法确认桌面服务重启请求进程。');
   const previous = readRecord(lock);
   if (previous) {
     const actual = previous.owner?.pid ? await processIdentity(previous.owner.pid) : null;
     if (sameProcess(previous.owner, actual) || readRecord(lock)?.operationId !== previous.operationId) {
-      throw new Error('工作站服务已在重启中。');
+      throw new Error('桌面服务已在重启中。');
     }
     fs.rmSync(lock);
   }
@@ -36,18 +36,18 @@ export async function requestServiceRestart(stateRoot) {
     // Publish a complete record exclusively; a crash cannot leave a half-written lock.
     fs.linkSync(temporary, lock);
   } catch (error) {
-    if (error.code === 'EEXIST') throw new Error('工作站服务已在重启中。');
+    if (error.code === 'EEXIST') throw new Error('桌面服务已在重启中。');
     throw error;
   } finally { fs.rmSync(temporary, { force: true }); }
   try {
     const log = path.join(stateRoot, 'service-restart.log');
     const pid = await startBackground(process.execPath, [script, '--worker', stateRoot, operationId], process.env, [log, log]);
     const worker = await processIdentity(pid);
-    if (!worker) throw new Error('服务重启进程未启动。');
+    if (!worker) throw new Error('桌面服务重启进程未启动。');
     const current = readRecord(lock);
-    if (current?.operationId !== operationId) throw new Error('服务重启实例已失效。');
+    if (current?.operationId !== operationId) throw new Error('桌面服务重启实例已失效。');
     writeRecord(lock, { ...current, owner: worker });
-    return { operationId, status: 'scheduled', message: '工作站服务重启已安排。' };
+    return { operationId, status: 'scheduled', message: '桌面服务重启已安排。' };
   } catch (error) {
     const current = readRecord(lock);
     if (current?.operationId === operationId && sameProcess(current.owner, owner)) fs.rmSync(lock, { force: true });
@@ -61,9 +61,9 @@ async function run(stateRoot, operationId) {
     const deadline = Date.now() + 30000;
     while (true) {
       const record = readRecord(lock);
-      if (record?.operationId !== operationId) throw new Error('服务重启实例已失效。');
+      if (record?.operationId !== operationId) throw new Error('桌面服务重启实例已失效。');
       if (record.owner?.pid === process.pid) break;
-      if (Date.now() >= deadline) throw new Error('服务重启进程交接超时。');
+      if (Date.now() >= deadline) throw new Error('桌面服务重启进程交接超时。');
       await delay(100);
     }
     const service = lifecycle({ stateRoot, host });

package/dist/src/service-update-worker.mjs

@@ -31,9 +31,9 @@ try {
   const code = await new Promise((resolve, reject) => {
     child.once('error', reject); child.once('exit', (code, signal) => resolve(code ?? `signal ${signal}`));
   });
-  if (code !== 0) throw new Error(`npm 安装失败（${code}），请查看工作站更新日志。`);
+  if (code !== 0) throw new Error(`npm 安装失败（${code}），请查看桌面服务更新日志。`);
   const installed = JSON.parse(fs.readFileSync(path.join(job.serviceRoot, 'installation.json'), 'utf8'));
-  if (installed.version !== job.targetVersion) throw new Error('安装结束，但工作站版本与目标版本不一致。');
+  if (installed.version !== job.targetVersion) throw new Error('安装结束，但桌面服务版本与目标版本不一致。');
   update({ status: 'completed', finishedAt: new Date().toISOString(), installedVersion: installed.version });
 } catch (error) {
   console.error(error.stack || error.message);

package/dist/src/service-update.mjs

@@ -13,7 +13,7 @@ export function publicUpdateOperation(record, installedVersion) {
   if (!record) return null;
   return { operationId: record.operationId, targetVersion: record.targetVersion,
     status: record.status, targetInstalled: Boolean(installedVersion && installedVersion === record.targetVersion),
-    error: record.status === 'failed' ? '上次更新未完整完成，请查看工作站更新日志。' : null,
+    error: record.status === 'failed' ? '上次更新未完整完成，请查看桌面服务更新日志。' : null,
     installedVersion: record.installedVersion || null };
 }
 export function serviceUpdateStatus(root) {
@@ -25,7 +25,7 @@ export function serviceUpdateStatus(root) {
 }
 export async function checkServiceUpdate(root) {
   const result = await fetch('https://registry.npmjs.org/@walkhi%2fcode-relax/latest', { signal: AbortSignal.timeout(12000) });
-  if (!result.ok) throw new Error(`查询工作站版本失败：HTTP ${result.status}`);
+  if (!result.ok) throw new Error(`查询桌面服务版本失败：HTTP ${result.status}`);
   const latest = await result.json();
   if (!versionPattern.test(latest.version || '')) throw new Error('npm 返回的版本号无效');
   return { ...serviceUpdateStatus(root), latestVersion: latest.version };
@@ -33,9 +33,9 @@ export async function checkServiceUpdate(root) {
 let scheduling = false;
 export async function requestServiceUpdate(root, body) {
   if (body.confirmed !== true || !/^[0-9a-f-]{36}$/i.test(body.operationId || '') || !versionPattern.test(body.targetVersion || '')) {
-    throw new Error('请确认工作站更新及目标版本后再继续。');
+    throw new Error('请确认桌面服务更新及目标版本后再继续。');
   }
-  if (scheduling) throw new Error('工作站更新正在安排。');
+  if (scheduling) throw new Error('桌面服务更新正在安排。');
   scheduling = true;
   try {
     const previous = readRecord(statusPath(root));
@@ -43,14 +43,14 @@ export async function requestServiceUpdate(root, body) {
     if (previous && ['scheduled', 'running'].includes(previous.status)) {
       const actual = previous.owner?.pid ? await desktopHost.process(previous.owner.pid) : null;
       if (actual && actual.created === previous.owner.created && actual.executable === previous.owner.executable) {
-        throw new Error('工作站已有更新正在执行。');
+        throw new Error('桌面服务已有更新正在执行。');
       }
       writeRecord(statusPath(root), { ...previous, status: 'failed', error: '更新进程已退出，未确认安装完成。' });
     }
     const latest = await checkServiceUpdate(root);
     if (!latest.supported) throw new Error('当前安装缺少 npm 路径，请先安装支持手机更新的过渡版。');
     if (latest.latestVersion !== body.targetVersion) throw new Error('最新版本已变化，请重新检查后确认。');
-    if (latest.currentVersion === body.targetVersion) throw new Error('工作站已是此版本。');
+    if (latest.currentVersion === body.targetVersion) throw new Error('桌面服务已是此版本。');
     const installed = installation();
     const directory = path.join(root, 'service-updates', body.operationId);
     fs.mkdirSync(directory, { recursive: true, mode: 0o700 });
@@ -70,7 +70,7 @@ export async function requestServiceUpdate(root, body) {
         pid: owner.pid, created: owner.created, executable: owner.executable } });
     } catch (error) {
       writeRecord(statusPath(root), { ...readRecord(statusPath(root)), status: 'failed', error: error.message });
-      throw new Error('工作站更新启动未完成，请查看工作站更新日志；结果确认前不要重复提交。');
+      throw new Error('桌面服务更新启动未完成，请查看桌面服务更新日志；结果确认前不要重复提交。');
     }
     return serviceUpdateStatus(root);
   } finally { scheduling = false; }

package/dist/src/shared-recovery.mjs

@@ -24,12 +24,20 @@ export const recoveryWarning = 'Codex Desktop 需要重新打开，才能接入
 
 export async function recoveryStatus(stateRoot, host = desktopHost) {
   if (host.desktopIntegration === false) return { status: 'unsupported', message: '此平台尚不支持 Desktop 自动接入。' };
-  const record = readRecord(recordPath(stateRoot));
+  let record = readRecord(recordPath(stateRoot));
   if (!record) return { status: 'none', message: '尚未执行 Desktop 接入流程。' };
   const lostWorker = active(record) && (record.worker
     ? !sameProcess(record.worker, await host.process(record.worker.pid))
     : Date.now() - Date.parse(record.startedAt) > 30000);
   if (lostWorker) {
+    // Process lookup is asynchronous: the worker may have committed its result
+    // while it was running. Never replace that result with a stale failure.
+    const latest = readRecord(recordPath(stateRoot));
+    if (latest?.operationId !== record.operationId || !active(latest)) {
+      const { worker, oldService, desktop, ...publicRecord } = latest || {};
+      return publicRecord;
+    }
+    record = latest;
     record.status = 'failed'; record.error = '独立恢复进程已退出，恢复未完成。';
     record.steps = record.steps?.map(step => ({ ...step, status: step.status === 'running' ? 'failed' : step.status }));
     writeRecord(recordPath(stateRoot), record);
@@ -51,7 +59,7 @@ export async function planRecovery(stateRoot, host, available = portAvailable) {
   return { desktop: info.desktop, action };
 }
 
-export async function requestRecovery(stateRoot, { confirmed, operationId = randomUUID(), startOnly = false } = {}, host = desktopHost) {
+export async function requestRecovery(stateRoot, { confirmed, operationId = randomUUID() } = {}, host = desktopHost) {
   if (host.desktopIntegration === false) throw new Error('此平台尚不支持 Desktop 自动接入。');
   if (confirmed !== true) throw new Error(recoveryWarning + ' 请明确确认后再执行。');
   if (!/^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/i.test(operationId)) throw new Error('无效的恢复操作编号。');
@@ -60,13 +68,12 @@ export async function requestRecovery(stateRoot, { confirmed, operationId = rand
   if (previous.operationId === operationId) return previous;
   if (active(previous)) throw new Error('已有恢复操作正在执行，请查看恢复状态。');
   const planned = await planRecovery(stateRoot, host);
-  if (startOnly && (await host.inspect()).running) throw new Error('Codex 桌面端已经启动，未执行重启。');
   let lock;
   try { lock = fs.openSync(lockPath(stateRoot), 'wx'); }
   catch (error) { if (error.code === 'EEXIST') throw new Error('已有恢复操作，请先查看恢复状态。'); throw error; }
   fs.writeFileSync(lock, JSON.stringify({ operationId })); fs.closeSync(lock);
   const record = { operationId, status: 'scheduled', stage: 'prepared', startedAt: new Date().toISOString(),
-    message: 'Codex 连接请求已接受，电脑管理连接保持运行。', startOnly, steps: recoverySteps().filter(step => !startOnly || step.id !== 'stopping-desktop'), ...planned };
+    message: 'Codex 连接请求已接受，电脑管理连接保持运行。', steps: recoverySteps(), ...planned };
   try {
     writeRecord(recordPath(stateRoot), record);
     const log = path.join(stateRoot, 'shared-recovery.log');
@@ -104,9 +111,7 @@ export async function runRecovery(stateRoot, operationId, dependencies = {}) {
     const planned = await planRecovery(stateRoot, host, available);
     record = { ...record, ...planned };
     if (fs.existsSync(path.join(stateRoot, 'desktop-launch.lock'))) throw new Error('Desktop 正在启动，未与启动操作并行恢复。');
-    if (record.startOnly) {
-      if ((await host.inspect()).running) throw new Error('Codex 桌面端已经启动，未执行重启。');
-    } else { stage('stopping-desktop'); await host.closeDesktop(record.desktop); }
+    stage('stopping-desktop'); await host.closeDesktop(record.desktop);
     await waitFor(async () => !(await host.inspect()).running, '当前 Codex Desktop 未退出，未继续接入 Codex 内核。');
     stage('starting-app-server'); await start({ stateRoot, host, recoveryId: operationId, progress: stage });
     stage('checking-execution');

package/dist/src/shared-thread-stream.mjs

@@ -126,10 +126,11 @@ export async function streamSharedThread(response, threadId, client, normalize,
       const delivered = subscription.snapshot ? normalized : catchup ? await normalize(catchup) : null;
       const sent = Boolean(delivered) && !closed;
       if (sent) await emit('update', delivered);
-      // A timestamp-confirmed cache only needs the new subscription boundary,
-      // never an empty replacement window or a repeated body snapshot.
-      if (subscription.confirmed && !closed) await emit('sync-ready', {
-        thread: normalized.thread, sync: normalized.sync,
+      // Confirm every handoff after its catchup/snapshot has been delivered.
+      // This also releases a cached selection with a valid, unchanged token;
+      // transport subscription alone does not confirm the message boundary.
+      if (!closed) await emit('sync-ready', {
+        thread: { ...normalized.thread, turns: [] }, sync: normalized.sync,
       });
       client.traceSync?.('stream-initial-sent', threadId, { ms: Math.round(performance.now() - started), closed,
         snapshot: subscription.snapshot, catchup: Boolean(catchup), sent, seq: normalized.sync?.seq,

package/package.json

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