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

package/dist/src/server.mjs

@@ -1,155 +1,273 @@
 import crypto from 'node:crypto';
+import { RustDeskVideoProbe } from './platform/windows/rustdesk-video-probe.mjs';
 import fs from 'node:fs';
 import http from 'node:http';
-import net from 'node:net';
+import { createPowerManager } from './service-power.mjs';
 import path from 'node:path';
 import os from 'node:os';
 import { fileURLToPath } from 'node:url';
-import vm from 'node:vm';
-import sharp from 'sharp';
+import vm from 'node:vm';
+import sharp from 'sharp';
 import { attachLanSocket } from './lan-socket-server.mjs';
-import { validateInlineImage, persistLegacyImage } from './message-images.mjs';
-import { ThreadWriterConflictError } from './shared-app-server.mjs';
-import { ManagedAppServer, managedAppServerUrl } from './managed-app-server.mjs';
-import { streamSharedThread } from './shared-thread-stream.mjs';
-import { AppServerClient } from './app-server-client.mjs';
-import { AppServerTaskStore, AppServerTaskTransport } from './app-server-tasks.mjs';
-import { supplementThreadCatalog } from './thread-catalog.mjs';
+import { connectionReporting } from './self-relay/connection-reporting.mjs';
+import fileMentions from '../shared/file-mentions.cjs';
+import fileCitations from '../shared/file-citations.cjs';
+import { validateInlineImage } from './message-images.mjs';
+import { ThreadWriterConflictError } from './shared-app-server.mjs';
+import { ManagedAppServer } from './managed-app-server.mjs';
+import { RuntimeDiscovery } from './runtime-discovery.mjs';
+import { streamSharedThread, threadListNotificationMethods } from './shared-thread-stream.mjs';
 import appServerEvents from '../shared/app-server-events.cjs';
-import { runtimePaths } from './platform/windows/runtime-paths.mjs';
+import questionAttention from '../shared/question-attention.cjs';
+import messageDelivery from '../shared/message-delivery.cjs';
+import fileChanges from '../shared/file-changes.cjs';
+import { runtimePaths } from './platform/runtime-paths.mjs';
 import { openControl } from './service-control.mjs';
 import { writeRecord, readRecord } from './service-lifecycle.mjs';
 import { ExecutionHealth } from './execution-health.mjs';
-import { activeDebugPort, serveDebugResource } from './debug-ui.mjs';
-import { authorizeLanDevice } from './self-relay/lan-authorizations.mjs';
+import { authorizeLanDevice, onLanAuthorizationsChanged, recordLanConnection } from './self-relay/lan-authorizations.mjs';
+import { createRelayManager } from './self-relay/lifecycle.mjs';
 import { generateAndSetThreadTitle } from './thread-title-generation.mjs';
-import { DesktopMonitor } from './platform/windows/desktop-monitor.mjs';
-import { desktopHost } from './platform/windows/desktop-host.mjs';
+import { desktopHost } from './platform/desktop-host.mjs';
 import { SharedCatalog } from './shared-catalog.mjs';
+import { DotsAppServer } from './dots-task-catalog.mjs';
+import { DotsChatServer } from './dots-chat-server.mjs';
+import { HostedHistoryCache } from './hosted-history-cache.mjs';
+import { readDotsSummaryTasks } from './dots-summary-tasks.mjs';
+import { readDotsSchedules } from './dots-schedules.mjs';
+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';
-
-const MAX_FRAME_BYTES = 32 * 1024 * 1024;
-const MAX_ATTACHMENT_BYTES = 16 * 1024 * 1024;
+import { checkServiceUpdate, requestServiceUpdate, serviceUpdateStatus } from './service-update.mjs';
+import { TurnModelHistory } from './turn-model-history.mjs';
+import { browseCode } from './code-browser.mjs';
+import { fileRange, fileRevision, FileRangeError } from './file-transfer-range.mjs';
+import { browseProjectFolders, createProjectFolder } from './project-management.mjs';
+import { projectLocations } from './platform/project-locations.mjs';
+import { createWorkstationProject } from './project-create.mjs';
+import { removeWorkstationProject } from './project-remove.mjs';
+import { archivedThreadsPage } from './archived-threads.mjs';
+import { updateWorkstationProject } from './project-update.mjs';
+import { WorkstationDownloads } from './workstation-downloads.mjs';
+import { stageWorkstationMessageFile } from './message-upload-files.mjs';
+import { consumeUsageReset } from './usage-reset.mjs';
+import { DesktopHelper } from './platform/windows/desktop-helper.mjs';
+
+const turnModelHistory = new TurnModelHistory();
+const messageReceipts = new messageDelivery.Store();
+const desktopHelper = process.platform === 'win32' ? new DesktopHelper() : null;
+
+const MAX_ATTACHMENT_BYTES = 20 * 1024 * 1024;
+const MAX_FILE_DOWNLOAD_BYTES = 20 * 1024 * 1024;
 const MAX_CACHED_ATTACHMENTS = 32;
 const MAX_CACHED_FILES = 64;
 const MAX_CONTEXT_TAIL_BYTES = 4 * 1024 * 1024;
-const MAX_LIVE_ACTIVITY_TAIL_BYTES = 1024 * 1024;
-const SHARED_HISTORY_PAGE_BYTES = 500 * 1024;
-const SHARED_HISTORY_PAGE_TURNS = 8;
+const MAX_LIVE_ACTIVITY_TAIL_BYTES = 1024 * 1024;
+const SHARED_HISTORY_PAGE_BYTES = 500 * 1024;
+const SHARED_HISTORY_PAGE_TURNS = 8;
 const MAX_SETTINGS_SCAN_BYTES = 64 * 1024 * 1024;
-const ALLOWED_MODELS = new Set([
-  'gpt-6-astra',
-  'gpt-5.6-sol',
-  'gpt-5.6-terra',
-  'gpt-5.6-luna',
-  'gpt-5.5',
-  'gpt-5.3-codex-spark',
-]);
 const ALLOWED_THINKING = new Set(['low', 'medium', 'high', 'xhigh', 'max', 'ultra']);
-const ALLOWED_TOOLS = new Set([
-  'create_thread',
-  'get_usage_limits',
-  'list_projects',
-  'list_threads',
-  'read_thread',
-  'send_message_to_thread',
-  'wait_threads',
-]);
+
+class RequestError extends Error {
+  constructor(statusCode, message, details) {
+    super(message);
+    this.statusCode = statusCode;
+    this.details = details;
+    this.code = details?.code;
+  }
+}
+
+function readRuntimeVersion() {
+  let directory = path.dirname(fileURLToPath(import.meta.url));
+  while (true) {
+    const manifest = readRecord(path.join(directory, 'package.json'));
+    if (manifest?.name === '@walkhi/code-relax') return manifest.version || '未知';
+    const parent = path.dirname(directory);
+    if (parent === directory) return '未知';
+    directory = parent;
+  }
+}
 
 const options = parseOptions(process.argv.slice(2));
-const pipePath = process.env.CODEX_APP_TOOLS_PIPE_PATH?.trim();
-let sourceThreadId = (process.env.CODEX_THREAD_ID || process.env.CODEX_SESSION_ID)?.trim();
+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 repositoryRoot = path.resolve(webRoot, '..', '..');
 const projectRoot = os.homedir();
 const { codexDataRoot, stateRoot, sessionsRoot, uploadsRoot } = runtimePaths();
+const desktopVideoProbe = process.platform === 'win32' ? new RustDeskVideoProbe({ stateRoot }) : null;
+process.once('exit', () => desktopVideoProbe?.stop());
+const workstationDownloads = new WorkstationDownloads(stateRoot);
 const markdownItScript = fs.readFileSync(path.join(webRoot, 'vendor', 'markdown-it.umd.min.js'));
 const markdownSandbox = { atob };
 vm.runInNewContext(markdownItScript.toString(), markdownSandbox);
 const imageMarkdown = markdownSandbox.markdownit({ html: false });
-let nextRequestId = 0;
-const attachmentCache = new Map();
-const fileCache = new Map();
-const fileCapabilitySecret = crypto.randomBytes(32);
-const imageCapabilityKey = crypto.createHash('sha256')
-  .update('code-relax-image-capability\0').update(options.token || fileCapabilitySecret).digest();
-const legacyUploadsRoot = path.resolve(webRoot, '..', 'uploads');
-const allowedUploadsRoots = [uploadsRoot, legacyUploadsRoot,
-  ...JSON.parse(process.env.CODEX_REMOTE_LEGACY_UPLOADS_ROOTS || '[]')];
+fileCitations.install(imageMarkdown);
+const attachmentCache = new Map();
+const fileCache = new Map();
+const fileCapabilitySecret = crypto.randomBytes(32);
+const imageCapabilityKey = crypto.createHash('sha256')
+  .update('code-relax-image-capability\0').update(options.token || fileCapabilitySecret).digest();
 const sessionPathCache = new Map();
 const sessionSettingsCache = new Map();
 const liveActivityCache = new Map();
-const messageQueues = new Map();
-let sharedServer = null;
-const desktopMonitor = new DesktopMonitor({
-  read: (tool, args, pipe) => callTool(tool, args, 5000, pipe),
-});
-const managedAppServer = new ManagedAppServer({ stateRoot, host: desktopHost });
-let sharedCatalog = null, executionMode = 'ordinary';
-function selectSharedExecution(enabled) {
-  const next = enabled ? managedAppServer.client : null;
-  if (sharedServer === next) return;
-  sharedServer = next;
-  sharedCatalog = sharedServer ? new SharedCatalog(sharedServer) : null;
-}
-const executionHealth = new ExecutionHealth(async () => {
-  await managedAppServer.ensure();
-  const [desktop, attachedUrl] = await Promise.all([desktopHost.inspect(), desktopHost.sharedServiceUrl()]);
-  const attached = Boolean(desktop.running && attachedUrl === managedAppServerUrl);
-  const managed = managedAppServer.snapshot();
-  // The managed app-server owns execution. Desktop is another client of the
-  // same service, so closing Desktop must not disable phone writes.
-  selectSharedExecution(managed.ready);
-  executionMode = sharedServer ? 'shared' : 'ordinary';
-  const basicReady = Boolean(desktop.running && sourceThreadId && desktopMonitor.pipe);
-  const managedRestarting = managed.state === 'restarting';
-  const ready = !managedRestarting && (sharedServer ? sharedServer.ready === true : basicReady);
-  const state = managedRestarting ? 'restarting'
-    : ready ? (sharedServer ? 'full' : 'basic') : !desktop.running ? 'offline' : 'unavailable';
-  return { state, ready, canWrite: ready, mode: executionMode,
-    desktop: { state: !desktop.running ? 'stopped' : attached ? 'managed' : 'ordinary', attachedToManagedServer: attached } };
-});
-async function refreshExecution() {
-  sourceThreadId = readRecord(path.join(stateRoot, 'bridge-startup-context.json'))?.sourceThreadId || sourceThreadId;
-  await executionHealth.refresh();
-  return { mode: executionMode };
-}
-async function requireExecutionWritable(threadId) {
-  const recovery = readRecord(path.join(stateRoot, 'shared-recovery.json'));
-  if (['scheduled', 'running'].includes(recovery?.status)) {
-    throw new RequestError(409, 'Codex 正在重新启动，当前不能提交写操作。', { code: 'desktop_recovering' });
-  }
-  const execution = await executionHealth.refresh();
-  if (!execution.canWrite) {
-    const message = execution.mode === 'shared'
-      ? 'Codex 内核尚未建立可写连接，请稍后重新检测。'
-      : 'Codex Desktop 尚未建立基础控制连接，请稍后重新检测。';
-    throw new RequestError(409, message, { code: 'execution_not_writable', execution });
-  }
-  if (threadId && sharedServer) sharedServer.requireWritable(threadId);
-  return execution;
-}
-managedAppServer.client.on('subscription-error', error => console.error('完整控制任务取消订阅失败：', error.message));
-const queueWorkers = new Map();
-const appServer = new AppServerClient({ cwd: projectRoot });
-const appServerTasks = new AppServerTaskTransport({
-  client: appServer,
-  store: new AppServerTaskStore(path.join(stateRoot, 'app-server-tasks.json')),
-});
-appServer.on('protocol-error', error => console.error(`app-server 协议错误：${error.message}`));
-appServer.on('server-request', request => {
-  console.log(`app-server 等待客户端处理反向请求：${request.method} (${request.id})`);
+let sharedServer = null;
+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 });
+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) {
+  const next = enabled ? managedAppServer.client : null;
+  if (sharedServer === next) return;
+  sharedServer = next;
+  sharedCatalog = sharedServer ? new SharedCatalog(sharedServer, dotsServer, dotsChat) : null;
+}
+const executionHealth = new ExecutionHealth(async () => {
+  await managedAppServer.ensure();
+  const managed = managedAppServer.snapshot();
+  // The managed app-server owns execution. Desktop is another client of the
+  // same service, so closing Desktop must not disable phone writes.
+  selectSharedExecution(managed.ready);
+  executionMode = sharedServer ? 'shared' : 'ordinary';
+  const managedRestarting = managed.state === 'restarting';
+  const ready = !managedRestarting && sharedServer?.ready === true;
+  const state = managedRestarting ? 'restarting'
+    : ready ? 'full' : 'unavailable';
+  return { state, ready, canWrite: ready, mode: executionMode };
 });
+function workstationHealth() {
+  const executionReady = executionHealth.state.ready && sharedServer?.ready === true;
+  return {
+    status: 'ok', resident: true, version: runtimeVersion, serviceInstanceId,
+    keepAwake: powerManager.snapshot(),
+    serviceUpdate: serviceUpdateStatus(stateRoot),
+    execution: { ...executionHealth.state, ready: executionReady, canWrite: executionReady,
+      mode: executionMode },
+    managedAppServer: managedAppServer.snapshot(),
+    ...runtimeDiscovery.state,
+    sharedAppServerConnected: sharedServer?.ready === true,
+    sharedRecoveryAvailable: runtimeDiscovery.state.desktop?.installed === true,
+    mode: options.lan ? 'lan' : 'loopback',
+    tokenRequired: Boolean(options.token),
+    nativeImageTransport: sharedServer ? 'shared-app-server' : null,
+    transportMode: sharedServer?.ready === true ? 'lan-shared' : 'unavailable',
+  };
+}
+
+async function refreshExecution() {
+  await executionHealth.refresh();
+  return { mode: executionMode };
+}
+async function requireExecutionWritable(threadId, client = sharedServer) {
+  const execution = await executionHealth.refresh();
+  if (!execution.canWrite) {
+    throw new RequestError(503, 'Codex 内核未就绪。请重启工作站服务；若仍失败，运行 relax doctor。',
+      { code: 'full_control_required', execution });
+  }
+  if (threadId && client) client.requireWritable(threadId);
+  return execution;
+}
+managedAppServer.client.on('subscription-error', error => console.error('Codex 内核任务取消订阅失败：', error.message));
+dotsServer.on('subscription-error', error => console.error('Dots 任务取消订阅失败：', error.message));
+dotsChat.on('subscription-error', error => console.error('Dots 对话取消订阅失败：', error.message));
+dotsChat.on('activity-error', error => console.error('点点状态通道不可用：', error.message));
 
+dotsServer.on('profile-error', error => console.error(error.message));
 async function handleRequest(request, response) {
+  let messageSubmissionStarted = false;
   try {
     const url = new URL(request.url || '/', `http://${request.headers.host || 'localhost'}`);
 
     if (!request.socketRequest) {
-      if (serveDebugResource(request, response, stateRoot, options.port)) return;
-      sendJson(response, 404, { error: 'Bridge 调试页面未开启，或请求的资源不存在。' });
+      sendJson(response, 404, { error: '此端口不提供网页。' });
+      return;
+    }
+
+    if (process.platform !== 'win32' && url.pathname.startsWith('/api/desktop/'))
+      throw new RequestError(501, 'Mac 版不提供远程桌面控制。', { code: 'desktop_control_unsupported' });
+
+    if (url.pathname === '/api/desktop/video-probe') {
+      if (request.method === 'POST') {
+        try { sendJson(response, 200, await desktopVideoProbe.begin()); }
+        catch (error) { throw new RequestError(error.statusCode || 502, error.message, { code: error.code || 'desktop_video_failed' }); }
+      }
+      else if (request.method === 'PUT' || request.method === 'DELETE') {
+        const body = await readJsonBody(request);
+        if (typeof body.leaseId !== 'string' || !/^[a-f0-9]{32}$/.test(body.leaseId)) throw new RequestError(400, '无效的视频会话');
+        sendJson(response, 200, request.method === 'PUT' ? desktopVideoProbe.renew(body.leaseId) : desktopVideoProbe.release(body.leaseId));
+      } else throw new RequestError(405, '不支持的操作');
+      return;
+    }
+    if (request.method === 'GET' && url.pathname === '/api/desktop/frame') {
+      const started = Date.now();
+      try {
+        const preview = url.searchParams.get('preview') === '1';
+        const frame = await desktopHelper.frame({ preview });
+        if (!preview) console.info(JSON.stringify({ time: new Date().toISOString(), event: 'desktop-frame', state: frame.state,
+          kind: frame.kind, width: frame.width, height: frame.height, bytes: frame.size, ms: Date.now() - started }));
+        if (response.writableEnded) { desktopHelper.release(frame.frameId); return; }
+        sendJson(response, 200, frame);
+      } catch (error) {
+        console.error(JSON.stringify({ time: new Date().toISOString(), event: 'desktop-frame', state: 'failed',
+          error: error.message.slice(0, 160), ms: Date.now() - started }));
+        throw error;
+      }
+      return;
+    }
+    const desktopImage = /^\/api\/desktop\/frames\/([a-f0-9]{32})$/.exec(url.pathname);
+    if (request.method === 'GET' && desktopImage) {
+      if (!request.fileTransfer) throw new RequestError(400, '请通过文件通道读取桌面画面。');
+      const image = desktopHelper.image(desktopImage[1]);
+      const { offset, length } = fileRange(url.searchParams, image.length, desktopImage[1]);
+      const mimeType = desktopHelper.active.frame.mimeType;
+      response.filePart({ name: mimeType === 'image/jpeg' ? 'desktop.jpg' : 'desktop.png', size: image.length, offset, revision: desktopImage[1], mimeType },
+        image.subarray(offset, offset + length));
+      return;
+    }
+    if (request.method === 'POST' && url.pathname === '/api/desktop/move') {
+      try { sendJson(response, 200, await desktopHelper.move(await readJsonBody(request))); }
+      catch (error) {
+        console.error(JSON.stringify({ time: new Date().toISOString(), event: 'desktop-move', state: 'failed',
+          code: error.code, error: error.message.slice(0, 160) }));
+        throw error;
+      }
+      return;
+    }
+    if (request.method === 'POST' && url.pathname === '/api/desktop/click') {
+      const started = Date.now();
+      console.info(JSON.stringify({ time: new Date().toISOString(), event: 'desktop-click', state: 'received' }));
+      try {
+        const result = await desktopHelper.click(await readJsonBody(request));
+        console.info(JSON.stringify({ time: new Date().toISOString(), event: 'desktop-click', state: result.state,
+          inputCount: result.inputCount, ms: Date.now() - started }));
+        sendJson(response, 200, result);
+      } catch (error) {
+        console.error(JSON.stringify({ time: new Date().toISOString(), event: 'desktop-click', state: 'failed',
+          code: error.code, error: error.message.slice(0, 160), ms: Date.now() - started }));
+        throw error;
+      }
+      return;
+    }
+    if (request.method === 'DELETE' && url.pathname === '/api/desktop/frame') {
+      const body = await readJsonBody(request);
+      if (typeof body.sessionId !== 'string' || !/^[a-f0-9]{32}$/.test(body.sessionId)) throw new RequestError(400, '无效的桌面会话');
+      desktopHelper.release(undefined, body.sessionId);
+      sendJson(response, 200, { released: true });
       return;
     }
 
@@ -172,157 +290,408 @@ 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/desktop/start', '/api/desktop/restart'].includes(url.pathname)) {
+      const body = await readJsonBody(request);
+      if (body.confirmed !== true) throw new RequestError(400, '请确认启动桌面端。');
+      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') {
       const body = await readJsonBody(request);
-      if (body.confirmed !== true || typeof body.operationId !== 'string') throw new RequestError(400, '请确认重新打开当前 Codex 并启用完整控制后再继续。');
+      if (body.confirmed !== true || typeof body.operationId !== 'string') throw new RequestError(400, '请确认重新打开当前 Codex 并接入 Codex 内核后再继续。');
       sendJson(response, 202, await requestRecovery(stateRoot, body)); return;
     }
-    if (request.method === 'POST' && url.pathname === '/api/service/restart') {
-      const body = await readJsonBody(request);
-      if (body.confirmed !== true) throw new RequestError(400, '请确认重启工作站服务后再继续。');
-      sendJson(response, 202, await requestServiceRestart(stateRoot)); return;
-    }
-    if (request.method === 'POST' && url.pathname === '/api/managed-app-server/restart') {
-      const body = await readJsonBody(request);
-      if (body.confirmed !== true || typeof body.operationId !== 'string' || !body.operationId.trim()) {
-        throw new RequestError(400, '请先确认中断风险，再重启 Codex 内核。');
-      }
-      try {
-        sendJson(response, 202, managedAppServer.restart(body.operationId.trim()));
-      } catch (error) {
-        if (error?.code === 'managed_app_server_restarting') throw new RequestError(409, error.message);
-        throw error;
-      }
-      return;
-    }
-
-    if (request.method === 'GET' && url.pathname === '/api/health') {
-      // Status readers consume the workstation's cached sample. A phone query
-      // must not trigger PowerShell, process-identity, or app-server checks.
-      const recovery = readRecord(path.join(stateRoot, 'shared-recovery.json'));
-      const recovering = ['scheduled', 'running'].includes(recovery?.status);
-      sendJson(response, 200, {
-        status: 'ok', resident: true,
-        execution: { ...executionHealth.state, ready: executionHealth.state.ready && (!sharedServer || sharedServer.ready),
-          ...(recovering ? { state: 'recovering' } : {}), mode: executionMode },
-        managedAppServer: managedAppServer.snapshot(),
-        desktop: executionHealth.state.desktop || { state: 'stopped', attachedToManagedServer: false },
-        desktopRestartRecommended: executionHealth.state.desktop?.state === 'ordinary' && managedAppServer.snapshot().ready,
-        recovery: recovery ? { operationId: recovery.operationId, status: recovery.status, stage: recovery.stage, error: recovery.error } : null,
-        debugUiPort: await activeDebugPort(stateRoot, options.port),
-        desktopConnected: Boolean(desktopMonitor.pipe),
-        sharedAppServerConnected: sharedServer?.ready === true,
-        sharedRecoveryAvailable: true,
-        desktopOrderingReady: Boolean(desktopMonitor.snapshot),
-        toolCount: 0,
-        mode: options.lan ? 'lan' : 'loopback',
-        tokenRequired: Boolean(options.token),
-        nativeImageTransport: sharedServer ? 'shared-app-server' : null,
-        transportMode: sharedServer ? 'lan-shared' : 'lan-legacy',
-        appServer: {
-          state: appServer.state,
-          cliVersion: appServer.cliVersion,
-          taskCount: appServerTasks.store.list().length,
-        },
-      });
+    if (url.pathname === '/api/service/update' && request.method === 'GET') {
+      sendJson(response, 200, await checkServiceUpdate(stateRoot)); return;
+    }
+    if (url.pathname === '/api/service/update' && request.method === 'POST') {
+      sendJson(response, 202, await requestServiceUpdate(stateRoot, await readJsonBody(request))); return;
+    }
+    if (request.method === 'POST' && url.pathname === '/api/service/restart') {
+      const body = await readJsonBody(request);
+      if (body.confirmed !== true) throw new RequestError(400, '请确认重启工作站服务后再继续。');
+      sendJson(response, 202, { ...await requestServiceRestart(stateRoot), serviceInstanceId }); return;
+    }
+    if (request.method === 'POST' && url.pathname === '/api/managed-app-server/restart') {
+      const body = await readJsonBody(request);
+      if (body.confirmed !== true || typeof body.operationId !== 'string' || !body.operationId.trim()) {
+        throw new RequestError(400, '请先确认中断风险，再重启 Codex 内核。');
+      }
+      try {
+        sendJson(response, 202, managedAppServer.restart(body.operationId.trim()));
+      } catch (error) {
+        if (error?.code === 'managed_app_server_restarting') throw new RequestError(409, error.message);
+        throw error;
+      }
       return;
     }
 
+    if (request.method === 'GET' && url.pathname === '/api/official-remote/status') {
+      if (!managedAppServer.client.ready) throw new RequestError(503, 'Codex 内核未就绪，无法读取官方工作站状态。');
+      const result = await managedAppServer.client.request('remoteControl/status/read', {});
+      sendJson(response, 200, { status: result.status, environmentId: result.environmentId });
+      return;
+    }
+    if (request.method === 'POST' && url.pathname === '/api/official-remote/pairing') {
+      if (!managedAppServer.client.ready) throw new RequestError(503, 'Codex 内核未就绪，无法生成官方配对码。');
+      const status = await managedAppServer.client.request('remoteControl/status/read', {});
+      if (status.status !== 'connected') throw new RequestError(409, '当前 Codex 内核未连接 OpenAI Remote，无法配对。');
+      const result = await managedAppServer.client.request('remoteControl/pairing/start', { manualCode: true });
+      if (!result.manualPairingCode || !result.environmentId) throw new RequestError(502, 'Codex 内核未返回有效的官方配对码。');
+      // One-time code: return only to the authenticated station controller; never persist or log it.
+      sendJson(response, 200, { manualPairingCode: result.manualPairingCode,
+        environmentId: result.environmentId, expiresAt: result.expiresAt });
+      return;
+    }
 
-    const imageMatch = /^\/api\/images\/([a-f0-9]{64})$/.exec(url.pathname);
-    if (request.method === 'GET' && imageMatch) {
-      let image = attachmentCache.get(imageMatch[1])
-        || recoverLocalImage(imageMatch[1], url.searchParams.get('recovery') || '');
-      const contextThreadId = url.searchParams.get('threadId') || '';
-      const contextTurnId = url.searchParams.get('turnId') || '';
-      if (!image && sharedServer && contextThreadId && contextTurnId
-        && contextThreadId.length <= 128 && contextTurnId.length <= 128) {
-        try {
-          normalizeTurn(await sharedServer.turnContext(contextThreadId, contextTurnId));
-          image = attachmentCache.get(imageMatch[1]);
-        } catch {}
-      }
-      if (!image) throw new RequestError(404, '这张图片已失效，无法从工作站重新读取。');
-      const thumbnail = url.searchParams.get('variant') === 'thumbnail';
-      const asset = thumbnail ? await attachmentThumbnail(image) : { buffer: image.buffer, mimeType: image.mimeType };
-      sendJson(response, 200, { url: `data:${asset.mimeType};base64,${asset.buffer.toString('base64')}` });
+    if (request.method === 'GET' && url.pathname === '/api/health') {
+      sendJson(response, 200, workstationHealth()); return;
+    }
+    if (request.method === 'GET' && url.pathname === '/api/health/events') {
+      response.startEvents();
+      let previous = '', stopped = false, timer;
+      const publish = () => {
+        if (stopped) return;
+        try {
+          const health = workstationHealth();
+          // Sampling timestamps alone do not change a workstation's visible state.
+          const signature = JSON.stringify(health, (key, value) => key === 'checkedAt' ? undefined : value);
+          if (signature !== previous) { previous = signature; response.event('health', health); }
+        } catch (error) { previous = ''; response.event('health-error', { error: error.message }); }
+      };
+      const close = () => { stopped = true; clearInterval(timer); managedAppServer.off('state', publish); };
+      response.once('close', close);
+      managedAppServer.on('state', publish);
+      publish();
+      // Reads only existing local samples and operation records, never chat history
+      // or an extra Desktop/process probe. Idle snapshots are not sent over the network.
+      timer = setInterval(publish, 1000); timer.unref?.();
       return;
     }
 
+    const fileLinkMatch = /^\/api\/files\/([a-f0-9]{64})\/link$/.exec(url.pathname);
+    if (request.method === 'GET' && fileLinkMatch) {
+      const attachment = attachmentCache.get(fileLinkMatch[1])
+        || dotsImages.restore(fileLinkMatch[1], url.searchParams.get('recovery') || '');
+      if (!attachment?.dotsFile) throw new RequestError(404, '此附件没有网络链接，请重新读取对话。');
+      sendJson(response, 200, { url: await dotsImages.fileLink(attachment) });
+      return;
+    }
+
+    const imageMatch = /^\/api\/images\/([a-f0-9]{64})$/.exec(url.pathname);
+    if (request.method === 'GET' && imageMatch) {
+      let image = attachmentCache.get(imageMatch[1])
+        || dotsImages.restore(imageMatch[1], url.searchParams.get('recovery') || '')
+        || recoverLocalImage(imageMatch[1], url.searchParams.get('recovery') || '');
+      const contextThreadId = url.searchParams.get('threadId') || '';
+      const contextTurnId = url.searchParams.get('turnId') || '';
+      if (!image && sharedServer && contextThreadId && contextTurnId
+        && contextThreadId.length <= 128 && contextTurnId.length <= 128) {
+        try {
+          normalizeTurn(await sharedServer.turnContext(contextThreadId, contextTurnId));
+          image = attachmentCache.get(imageMatch[1]);
+        } catch {}
+      }
+      if (!image) throw new RequestError(404, '这张图片已失效，无法从工作站重新读取。');
+      if (image.dotsFile) await dotsImages.load(image);
+      if (url.searchParams.get('variant') === 'thumbnail') {
+        const asset = await attachmentThumbnail(image);
+        sendJson(response, 200, { url: `data:${asset.mimeType};base64,${asset.buffer.toString('base64')}` });
+        return;
+      }
+      const size = image.buffer.length;
+      if (size > MAX_ATTACHMENT_BYTES) throw new RequestError(413, '图片超过下载上限（20 MiB），无法下载。');
+      if (!size) throw new RequestError(400, '图片为空，无法下载。');
+      if (!request.fileTransfer) throw new RequestError(400, '请通过文件通道读取原图。');
+      const revision = imageMatch[1];
+      const { offset, length } = fileRange(url.searchParams, size, revision);
+      response.filePart({ name: image.name || '图片', size, offset, revision, mimeType: image.mimeType },
+        image.buffer.subarray(offset, offset + length));
+      return;
+    }
+
+    const localFileRequest = url.pathname === '/api/files/local';
     const fileMatch = /^\/api\/files\/([a-f0-9]{64})$/.exec(url.pathname);
-    if (request.method === 'GET' && fileMatch) {
-      const file = fileCache.get(fileMatch[1]);
-      if (!file) throw new RequestError(404, '文件授权已失效，请重新读取对话。');
-      let stat;
-      try { stat = fs.statSync(file.path); } catch { throw new RequestError(404, '电脑上的文件已不存在。'); }
-      if (!stat.isFile() || stat.size !== file.size || stat.mtimeMs !== file.mtimeMs) {
-        fileCache.delete(fileMatch[1]);
-        throw new RequestError(409, '电脑上的文件已发生变化，请重新读取对话。');
+    if (request.method === 'GET' && (fileMatch || localFileRequest)) {
+      if (!request.fileTransfer) throw new RequestError(400, '请通过文件通道下载附件。');
+      const hosted = !localFileRequest && (attachmentCache.get(fileMatch[1])
+        || dotsImages.restore(fileMatch[1], url.searchParams.get('recovery') || ''));
+      if (hosted?.dotsFile) {
+        const { bytes, ...metadata } = await dotsImages.readPart(hosted, url.searchParams);
+        response.filePart(metadata, bytes);
+        return;
+      }
+      const localPath = url.searchParams.get('path') || '';
+      if (localFileRequest && (/[\x00-\x1f]/.test(localPath)
+        || !(process.platform === 'win32' ? /^[a-z]:[\\/]/i : /^\/(?!\/)/).test(localPath))) {
+        throw new RequestError(400, '无效的工作站文件路径。');
       }
-      if (stat.size > MAX_ATTACHMENT_BYTES) throw new RequestError(413, '暂只支持下载不超过 16 MiB 的文件。');
-      sendJson(response, 200, { name: file.name, size: file.size, dataBase64: fs.readFileSync(file.path).toString('base64') });
+      const file = localFileRequest ? describeLocalFile(localPath) : fileCache.get(fileMatch[1]);
+      if (!file) throw new RequestError(404, '电脑上的文件不存在或无法读取。');
+      if (file.externalIdentity) await dotsImages.authorization(file.externalIdentity);
+      const { offset, length } = fileRange(url.searchParams, file.size, file.revision);
+      let handle;
+      try { handle = fs.openSync(file.path, 'r'); }
+      catch (error) {
+        if (error.code === 'ENOENT') throw new RequestError(404, '电脑上的文件已不存在。');
+        throw error;
+      }
+      try {
+        const validate = () => {
+          const stat = fs.fstatSync(handle);
+          if (!stat.isFile() || fileRevision(stat) !== file.revision || fileRevision(fs.statSync(file.path)) !== file.revision) {
+            if (fileMatch) fileCache.delete(fileMatch[1]);
+            throw new RequestError(409, '电脑上的文件已发生变化，请重新读取对话。');
+          }
+          if (stat.size > MAX_FILE_DOWNLOAD_BYTES) throw new RequestError(413, '文件超过下载上限（20 MiB），无法下载。');
+          if (!stat.size) throw new RequestError(400, '文件为空，无法下载。');
+        };
+        validate();
+        const data = Buffer.alloc(length);
+        let bytesRead = 0;
+        while (bytesRead < data.length) {
+          const count = fs.readSync(handle, data, bytesRead, data.length - bytesRead, offset + bytesRead);
+          if (!count) throw new RequestError(409, '电脑上的文件读取不完整，请重新读取对话。');
+          bytesRead += count;
+        }
+        validate();
+        response.filePart({ name: file.name, size: file.size, offset, revision: file.revision }, data);
+      } finally { fs.closeSync(handle); }
+      return;
+    }
+
+    if (url.pathname.startsWith('/api/app-server/') || url.pathname === '/api/wait') {
+      throw new RequestError(410, '此连接方式已停用。请检查 Codex 内核状态。', { code: 'unsupported_control' });
+    }
+    const taskPath = /^\/api\/threads\/([^/]+)/.exec(url.pathname);
+    if (taskPath && (url.pathname.endsWith('/takeover') || url.pathname === `/api/threads/${taskPath[1]}`)) {
+      throw new RequestError(410, '此连接方式已停用。', { code: 'unsupported_control' });
+    }
+    const hostId = url.searchParams.get('hostId') || 'local';
+    if (!['local', 'durable'].includes(hostId)) {
+      throw new RequestError(410, '此对话的连接方式已停用，请检查 Codex 内核状态。', { code: 'unsupported_control' });
+    }
+    if (!executionHealth.state.ready || sharedServer?.ready !== true) {
+      throw new RequestError(503, 'Codex 内核未就绪。请重启工作站服务；若仍失败，运行 relax doctor。',
+        { code: 'full_control_required' });
+    }
+    const rootChat = hostId === 'durable' && taskPath
+      && await dotsServer.source(decodeURIComponent(taskPath[1])) === 'aeon';
+    const execution = rootChat ? dotsChat : hostId === 'durable' ? dotsServer : sharedServer;
+
+    if (url.pathname === '/api/permissions' && ['GET', 'POST'].includes(request.method)) {
+      if (hostId !== 'local') throw new RequestError(405, '当前来源不提供工作站全局审批方式。');
+      const body = request.method === 'POST' ? await readJsonBody(request) : {};
+      if (request.method === 'POST' && typeof body.mode !== 'string') throw new RequestError(400, '缺少审批方式。');
+      sendJson(response, 200, await sharedServer.globalPermissions(body.mode, {
+        threadId: url.searchParams.get('threadId') || '', cwd: url.searchParams.get('cwd') || '',
+      }));
+      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, '只有点点主聊天提供此活动面板。');
+      response.startEvents();
+      const disconnected = () => response.end();
+      dotsChat.on('disconnected', disconnected);
+      const release = dotsChat.acquirePanelActivity(decodeURIComponent(dotsActivityMatch[1]), value => {
+        if (!response.destroyed) response.event('dots-activity', { threadId: value.threadId, activity: value.activity });
+      });
+      response.once('close', () => { release(); dotsChat.off('disconnected', disconnected); });
+      return;
+    }
+
+    const dotsTasksMatch = /^\/api\/threads\/([^/]+)\/dots-tasks$/.exec(url.pathname);
+    if (request.method === 'GET' && dotsTasksMatch) {
+      if (!rootChat) throw new RequestError(405, '只有点点主聊天提供此任务面板。');
+      sendJson(response, 200, await readDotsSummaryTasks(dotsServer, decodeURIComponent(dotsTasksMatch[1])));
+      return;
+    }
+
+    const dotsSchedulesMatch = /^\/api\/threads\/([^/]+)\/dots-schedules$/.exec(url.pathname);
+    if (request.method === 'GET' && dotsSchedulesMatch) {
+      if (!rootChat) throw new RequestError(405, '只有点点主聊天提供此定时任务列表。');
+      sendJson(response, 200, await readDotsSchedules(dotsServer, decodeURIComponent(dotsSchedulesMatch[1])));
+      return;
+    }
+
+    if (request.method === 'GET' && url.pathname.startsWith('/api/code/')) {
+      const operation = url.pathname.slice('/api/code/'.length);
+      if (hostId === 'durable' && operation !== 'change') throw new RequestError(405, 'Dots 委派任务尚未接入代码浏览。');
+      try {
+        if ((operation === 'image' || operation === 'binary') && !request.fileTransfer) throw new RequestError(400, '请通过文件通道读取预览文件。');
+        const result = await browseCode((method, params) => execution.request(method, params), operation, url.searchParams);
+        if (operation === 'image' || operation === 'binary') {
+          const { data, ...metadata } = result;
+          response.filePart(metadata, data);
+        } else sendJson(response, 200, result);
+      } catch (error) { throw new RequestError(error.statusCode || 502, error.message); }
       return;
     }
 
     if (request.method === 'GET' && url.pathname === '/api/models') {
-      if (!usesSharedTask({ hostId: url.searchParams.get('hostId') })) throw new RequestError(400, '当前连接不支持即时模型设置。');
-      sendJson(response, 200, await sharedServer.models());
+      sendJson(response, 200, await execution.models());
+      return;
+    }
+
+    if (request.method === 'GET' && url.pathname === '/api/archived-threads') {
+      sendJson(response, 200, await archivedThreadsPage(execution, sharedServer, hostId, url.searchParams.get('cursor')));
       return;
     }
 
     if (request.method === 'GET' && url.pathname === '/api/threads') {
       const limit = boundedInteger(url.searchParams.get('limit'), 20, 1, 200);
       const archived = url.searchParams.get('archived') === 'true';
-      const catalog = sharedCatalog;
-      const sharedSnapshot = Boolean(catalog);
-      let desktopCatalog;
-      if (catalog) desktopCatalog = await catalog.threads(limit, archived);
-      else {
-        if (archived) throw new RequestError(400, '当前连接不支持归档对话。请启用完整控制。');
-        const listing = await callTool('list_threads', { limit: Math.min(limit, 50) });
-        if (!listing.success) { sendToolResult(response, listing); return; }
-        const projects = await callTool('list_projects', {});
-        if (!projects.success) { sendToolResult(response, projects); return; }
-        const catalogProjects = projects.data.projects || [];
-        desktopCatalog = { ...supplementThreadCatalog(listing.data, catalogProjects, codexDataRoot, limit),
-          projects: catalogProjects };
+      const scope = url.searchParams.get('scope') || 'all';
+      if (!['all', 'local', 'durable'].includes(scope)) { sendJson(response, 400, { error: '无效的会话列表范围' }); return; }
+      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;
       }
-      let appServerThreads = archived ? [] : appServerTasks.store.list().map(record => ({
-        id: record.id,
-        kind: 'codex',
-        hostId: 'app-server',
-        title: record.title,
-        cwd: record.cwd,
-        projectId: record.projectId,
-        updatedAt: record.updatedAt,
-        recencyAt: record.recencyAt ?? record.updatedAt,
-        status: 'unknown',
-        transport: 'app-server',
-      }));
-      if (appServerThreads.length) {
-        try { appServerThreads = await appServerTasks.listTasks(); } catch {}
+      sendJson(response, 200, catalog);
+      return;
+    }
+
+    if (request.method === 'GET' && url.pathname === '/api/file-local-copy') {
+      const value = url.searchParams.get('source') || '';
+      const match = /^([a-f0-9]{64})(?:\?recovery=([A-Za-z0-9_-]{1,4096}))?$/.exec(value);
+      if (!match) throw new RequestError(400, '无效的文件标识。');
+      const asset = attachmentCache.get(match[1])
+        || dotsImages.restore(match[1], match[2] || url.searchParams.get('recovery') || '');
+      // A missing process cache does not make a local image an external file.
+      // The actual image endpoint owns recovery and download authorization.
+      if (!asset?.dotsFile) {
+        sendJson(response, 200, { external: false, localCopy: null }); return;
       }
-      sendJson(response, 200, mergeThreadCatalog(desktopCatalog, appServerThreads, limit, sharedSnapshot));
+      await dotsImages.authorization(asset.identity);
+      const copy = await workstationDownloads.copy(asset.id);
+      sendJson(response, 200, { external: true, localCopy: copy ? workstationCopyReference(copy, asset) : null,
+        cachedContent: asset.buffer ? { remotePath: asset.id, name: asset.name, size: asset.buffer.length, mimeType: asset.mimeType } : null });
+      return;
+    }
+
+    if (request.method === 'POST' && url.pathname === '/api/workstation-file-attachments') {
+      await requireExecutionWritable();
+      const body = await readJsonBody(request);
+      const source = body.source;
+      const file = typeof source === 'string' && /^[a-z]:[\\/]/i.test(source) ? describeLocalFile(source)
+        : typeof source === 'string' && /^[a-f0-9]{64}$/.test(source) ? fileCache.get(source) : null;
+      if (!file) throw new RequestError(404, '电脑文件不可用，请从原文件入口重新添加。');
+      if (file.externalIdentity) await dotsImages.authorization(file.externalIdentity);
+      sendJson(response, 201, { file: await stageWorkstationMessageFile(file, uploadsRoot) });
+      return;
+    }
+
+    if (request.method === 'GET' && url.pathname === '/api/file-save-locations') {
+      await requireExecutionWritable();
+      const locations = await projectLocations();
+      const projects = (await sharedCatalog.projects()).projects.filter(project => project.hostId === 'local' && project.roots?.length);
+      sendJson(response, 200, { projects, downloads: locations.downloads });
+      return;
+    }
+
+    if (request.method === 'GET' && url.pathname === '/api/file-save-folders') {
+      await requireExecutionWritable();
+      sendJson(response, 200, await workstationDownloads.browse((method, params) => sharedServer.request(method, params),
+        await projectLocations(), Object.fromEntries(url.searchParams)));
+      return;
+    }
+
+    if (request.method === 'POST' && url.pathname === '/api/file-saves') {
+      await requireExecutionWritable();
+      const body = await readJsonBody(request);
+      const asset = await externalDownloadAsset(body.source, body.recovery);
+      const controller = new AbortController(), cancel = () => controller.abort();
+      response.once('close', cancel);
+      try {
+        const result = await workstationDownloads.save((method, params) => sharedServer.request(method, params),
+          await projectLocations(), body, asset, (file, query) => dotsImages.readPart(file, query), controller.signal);
+        sendJson(response, 201, { localCopy: workstationCopyReference(result, asset), warning: result.warning || '' });
+      } finally { response.off('close', cancel); }
       return;
     }
 
     if (request.method === 'GET' && url.pathname === '/api/projects') {
-      if (sharedCatalog) {
-        sendJson(response, 200, { projects: (await sharedCatalog.projects()).projects });
+      sendJson(response, 200, { projects: (await sharedCatalog.projects()).projects });
+      return;
+    }
+
+    if (url.pathname === '/api/project-folders' && ['GET', 'POST'].includes(request.method)) {
+      await requireExecutionWritable();
+      try {
+        const rpc = (method, params) => sharedServer.request(method, params);
+        const result = request.method === 'GET'
+          ? await browseProjectFolders(rpc, !url.searchParams.get('path') || url.searchParams.get('locations') === '1' ? await projectLocations() : null, url.searchParams.get('path'))
+          : await createProjectFolder(rpc, await readJsonBody(request));
+        sendJson(response, request.method === 'GET' ? 200 : 201, result);
+      } catch (error) { throw new RequestError(error.statusCode || 502, error.message); }
+      return;
+    }
+
+    const projectActionMatch = /^\/api\/projects\/([^/]+)\/(remove|move)$/.exec(url.pathname);
+    if (projectActionMatch) {
+      await requireExecutionWritable();
+      const projectId = decodeURIComponent(projectActionMatch[1]);
+      if (request.method === 'POST' && projectActionMatch[2] === 'move') {
+        const { beforeProjectId } = await readJsonBody(request);
+        if (beforeProjectId !== null && (typeof beforeProjectId !== 'string' || !beforeProjectId.trim()) || beforeProjectId === projectId) {
+          throw new RequestError(400, '排序目标无效。');
+        }
+        await sharedServer.request('project/move', { projectId, beforeProjectId });
+        sendJson(response, 200, await sharedCatalog.projects().then(({ projects }) => ({ projects })));
         return;
       }
-      const result = await callTool('list_projects', {});
-      sendToolResult(response, result);
+      if (request.method === 'POST' && projectActionMatch[2] === 'remove') {
+        const result = await removeWorkstationProject(sharedServer, stateRoot, codexDataRoot, projectId, await readJsonBody(request));
+        sendJson(response, 200, result);
+        return;
+      }
+      throw new RequestError(405, '不支持的项目操作。');
+    }
+
+    const updateProjectMatch = /^\/api\/projects\/([^/]+)$/.exec(url.pathname);
+    if (request.method === 'POST' && (url.pathname === '/api/projects' || updateProjectMatch)) {
+      await requireExecutionWritable();
+      const body = await readJsonBody(request);
+      try {
+        const result = !updateProjectMatch ? await createWorkstationProject(sharedServer, stateRoot, codexDataRoot, body)
+          : await updateWorkstationProject(sharedServer, stateRoot, codexDataRoot, decodeURIComponent(updateProjectMatch[1]), body);
+        sendJson(response, updateProjectMatch ? 200 : 201, result);
+      } catch (error) { throw new RequestError(error.statusCode || 502, error.message, error.details); }
+      return;
+    }
+
+    if (request.method === 'GET' && url.pathname === '/api/plan-pricing') {
+      sendJson(response, 200, await readPlanPricing(sharedServer));
       return;
     }
 
     if (request.method === 'GET' && url.pathname === '/api/usage-limits') {
-      if (sharedServer) sendJson(response, 200, await sharedServer.usage());
-      else sendToolResult(response, await callTool('get_usage_limits', {}));
+      sendJson(response, 200, await sharedServer.usage());
+      return;
+    }
+
+    if (request.method === 'POST' && url.pathname === '/api/usage-reset') {
+      await requireExecutionWritable();
+      const body = await readJsonBody(request);
+      try { sendJson(response, 200, await consumeUsageReset(sharedServer, body)); }
+      catch (error) { throw new RequestError(error.statusCode || 502, error.message,
+        error.code === 'usage_reset_not_submitted' ? { code: error.code, deliveryUnknown: false } : undefined); }
       return;
     }
 
-    if (request.method === 'GET' && url.pathname === '/api/usage-events' && sharedServer) {
+    if (request.method === 'GET' && url.pathname === '/api/usage-events') {
       const execution = sharedServer;
       response.startEvents();
       const emit = value => { if (!response.destroyed) response.event('usage', value); };
@@ -334,395 +703,357 @@ async function handleRequest(request, response) {
       return;
     }
 
-    if (request.method === 'GET' && url.pathname === '/api/app-server/status') {
-      sendJson(response, 200, appServerBridgeStatus());
+    if (request.method === 'GET' && url.pathname === '/api/thread-events') {
+      await sharedServer.connect();
+      const clients = [sharedServer, dotsServer, dotsChat];
+      response.startEvents();
+      const listener = ({ method, params }) => {
+        const questionChange = questionAttention.fromNotification(method, params);
+        if ((!threadListNotificationMethods.has(method) && !questionChange) || response.destroyed) return;
+        response.event('thread-list-changed', { method, threadId: params.threadId || params.thread?.id || '',
+          ...(questionChange ? { questionChange } : {}),
+          ...(params.hostId ? { hostId: params.hostId } : {}),
+          ...(params.chatRevision !== undefined ? { chatRevision: params.chatRevision } : {}),
+          ...(params.updatedAt !== undefined ? { updatedAt: params.updatedAt } : {}),
+          ...(params.chatMessageRevision !== undefined ? { chatMessageRevision: params.chatMessageRevision } : {}),
+          ...(params.status ? { status: typeof params.status === 'string' ? params.status : params.status.type } : {}) });
+      };
+      const disconnected = () => response.end();
+      for (const client of clients) {
+        client.on('notification', listener);
+        client.on('disconnected', disconnected);
+      }
+      response.once('close', () => {
+        for (const client of clients) {
+          client.off('notification', listener);
+          client.off('disconnected', disconnected);
+        }
+      });
+      response.event('ready', {});
       return;
     }
 
-    if (request.method === 'POST' && url.pathname === '/api/app-server/start') {
-      await requireExecutionWritable();
-      await appServer.start();
-      sendJson(response, 200, appServerBridgeStatus());
+    if (request.method === 'GET' && url.pathname === '/api/turn-events') {
+      const clients = [sharedServer, dotsServer, dotsChat];
+      response.startEvents();
+      const listener = ({ method, params }) => {
+        if (!['turn/started', 'turn/completed'].includes(method)) return;
+        const threadId = params?.threadId, turnId = params?.turn?.id;
+        if (typeof threadId === 'string' && typeof turnId === 'string' && !response.destroyed) {
+          response.event('turn', { method, threadId, turnId });
+        }
+      };
+      const disconnected = () => response.end();
+      for (const client of clients) {
+        client.on('notification', listener);
+        client.on('disconnected', disconnected);
+      }
+      response.once('close', () => {
+        for (const client of clients) {
+          client.off('notification', listener);
+          client.off('disconnected', disconnected);
+        }
+      });
       return;
     }
 
-    const createThreadMatch = /^\/api\/projects\/([^/]+)\/threads$/.exec(url.pathname);
-    if (request.method === 'POST' && createThreadMatch) {
-      await requireExecutionWritable();
-      const projectId = decodeURIComponent(createThreadMatch[1]);
-      const body = createThreadBody(await readJsonBody(request));
-      let projects = [];
-      if (body.transport !== 'app-server' || projectId !== '__unassigned__') {
-        const projectsResult = sharedCatalog
-          ? { success: true, data: { projects: (await sharedCatalog.projects()).projects } }
-          : await callTool('list_projects', {});
-        if (!projectsResult.success) {
-          sendJson(response, 502, { error: '无法读取 Codex Desktop 项目。', details: projectsResult.data });
-          return;
-        }
-        projects = Array.isArray(projectsResult.data?.projects) ? projectsResult.data.projects : [];
-      }
-      if (body.transport === 'app-server') {
-        const target = appServerProjectTarget(projectId, projects);
-        const result = await appServerTasks.createTask({
-          cwd: target.cwd,
-          projectId: target.projectId,
-          input: appServerTurnArguments('', body).input,
+    const activeTurnMatch = /^\/api\/threads\/([^/]+)\/active-turn$/.exec(url.pathname);
+    if (request.method === 'GET' && activeTurnMatch) {
+      if (rootChat) { sendJson(response, 200, { turnId: null }); return; }
+      const threadId = decodeURIComponent(activeTurnMatch[1]);
+      await execution.connect();
+      const { thread } = await execution.request('thread/read', { threadId, includeTurns: false });
+      const status = typeof thread.status === 'string' ? thread.status : thread.status?.type;
+      let turnId = null;
+      if (status === 'active') {
+        const page = await execution.request('thread/turns/list', {
+          threadId, limit: 1, sortDirection: 'desc', itemsView: 'summary',
         });
-        sendJson(response, 201, {
-          threadId: result.record.id,
-          hostId: 'app-server',
-          transport: 'app-server',
-          turnId: result.turn.id,
+        const latest = page.data?.[0];
+        if (latest?.status === 'inProgress') turnId = latest.id;
+      }
+      sendJson(response, 200, { turnId });
+      return;
+    }
+
+    const createStatusMatch = /^\/api\/projects\/([^/]+)\/threads\/([a-f0-9]{32})\/status$/.exec(url.pathname);
+    if (request.method === 'GET' && createStatusMatch) {
+      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;
         });
-        return;
       }
-      const project = projects.find(item => item.projectId === projectId);
-      if (usesSharedTask({ hostId:project?.hostId || body.hostId })) {
-        if (projectId !== '__unassigned__' && !project) throw new RequestError(404, '没有找到对应项目。');
-        const execution = sharedServer;
-        await execution.connect();
-        const rpc = (method, params) => execution.request(method, params);
-        let target = appServerEvents.projectlessThreadTarget(projectRoot);
-        if (project) {
-          const nativeProjects = await appServerEvents.readProjects(rpc);
-          const nativeId = nativeProjects.find(item => item.id === project.projectId)?.id;
-          if (!nativeId) throw new RequestError(404, '完整控制中没有找到对应项目，请刷新项目列表。');
-          target = { projectId:nativeId, cwd:project.path };
+      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')) {
+            throw new RequestError(410, '此连接方式已停用，请检查 Codex 内核状态。', { code: 'unsupported_control' });
+          }
+          const projects = (await sharedCatalog.projects()).projects;
+          const project = projects.find(item => item.projectId === projectId);
+          if (projectId !== '__unassigned__' && !project) throw new RequestError(404, '没有找到对应项目。');
+          const execution = sharedServer;
+          await execution.connect();
+          const rpc = (method, params) => execution.request(method, params);
+          let target = appServerEvents.projectlessThreadTarget(projectRoot);
+          if (project) {
+            const nativeProjects = await appServerEvents.readProjects(rpc);
+            const nativeProject = nativeProjects.find(item => item.id === project.projectId);
+            if (!nativeProject) throw new RequestError(404, 'Codex 内核中没有找到对应项目，请刷新项目列表。');
+            target = appServerEvents.projectThreadTarget(nativeProject);
+          }
+          const { input } = appServerTurnArguments('', body);
+          const preference = await execution.globalPermissions(undefined, { cwd: target.cwd });
+          messageSubmissionStarted = true;
+          const createRpc = (method, params) => method === 'thread/start'
+            ? execution.startThread(params) : rpc(method, params);
+          const created = await appServerEvents.createThread(createRpc, target, input,
+            { ...body, desktopPermissionMode: preference.globalPermissionMode }, undefined, bindCreation);
+          const prompt = input.filter(part => part.type === 'text').map(part => part.text).join('\n');
+          void generateAndSetThreadTitle({
+            request: rpc,
+            subscribe: listener => {
+              execution.on('notification', listener);
+              return () => execution.off('notification', listener);
+            },
+            threadId: created.threadId,
+            prompt,
+            cwd: target.cwd || null,
+          }).catch(error => console.error(`生成对话标题失败：${error.message}`));
+          return { ...created, hostId:'local' };
+        } catch (error) {
+          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;
         }
-        const { input } = appServerTurnArguments('', body);
-        const created = await appServerEvents.createThread(rpc, target, input, body);
-        const prompt = input.filter(part => part.type === 'text').map(part => part.text).join('\n');
-        void generateAndSetThreadTitle({
-          request: rpc,
-          subscribe: listener => {
-            execution.on('notification', listener);
-            return () => execution.off('notification', listener);
-          },
-          threadId: created.threadId,
-          prompt,
-          cwd: target.cwd || null,
-        }).catch(error => console.error(`生成对话标题失败：${error.message}`));
-        sendJson(response, 201, { ...created, hostId:'local' });
-        return;
-      }
-      const argumentsValue = await createThreadArguments(projectId, body, projects);
-      sendToolResult(response, await callTool('create_thread', argumentsValue, 90_000));
+      });
+      sendJson(response, 201, result);
       return;
     }
 
     const timelineMatch = /^\/api\/threads\/([^/]+)\/timeline$/.exec(url.pathname);
-    if (request.method === 'GET' && timelineMatch) {
-      const threadId = decodeURIComponent(timelineMatch[1]);
-      if (!appServerTasks.owns(threadId) && usesSharedTask({ hostId: url.searchParams.get('hostId') })) {
-        const timeline = normalizeSharedTimeline(await sharedServer.timeline(threadId, sharedHistoryPageOptions()));
-        const knownUpdatedAt = Number(url.searchParams.get('knownUpdatedAt'));
-        const knownTurnId = url.searchParams.get('knownTurnId') || '';
-        const knownTurnStatus = url.searchParams.get('knownTurnStatus') || '';
-        const knownHistoryView = url.searchParams.get('knownHistoryView') || '';
-        const latest = timeline.turns.at(-1);
-        const knownIndex = knownTurnId ? timeline.turns.findIndex(turn => turn.id === knownTurnId) : -1;
-        const sameHistoryView = knownHistoryView === timeline.historyView;
-        const unchanged = sameHistoryView
-          && knownIndex === timeline.turns.length - 1
-          && timeline.thread.status === 'idle' && latest?.status !== 'inProgress'
-          && knownTurnStatus && knownTurnStatus !== 'inProgress'
-          && (!Number.isFinite(knownUpdatedAt) || knownUpdatedAt <= 0 || timeline.thread.updatedAt === knownUpdatedAt);
-        const partial = !unchanged && sameHistoryView && knownIndex >= 0
-          ? { ...timeline, turns: timeline.turns.slice(knownIndex), partialFromTurnId: knownTurnId }
-          : timeline;
-        sendJson(response, 200, unchanged ? { ...timeline, turns: [], notModified: true } : partial);
-        return;
-      }
-      if (appServerTasks.owns(threadId)) {
-        const thread = await appServerTasks.readTask(threadId, {
-          includeTurns: true,
-          turnLimit: boundedInteger(url.searchParams.get('turnLimit'), 10, 1, 10),
-        });
-        sendJson(response, 200, normalizeAppServerTimeline(thread));
-        return;
+    if (request.method === 'GET' && timelineMatch) {
+      const threadId = decodeURIComponent(timelineMatch[1]);
+      const knownSeq = url.searchParams.get('knownSeq');
+      const knownSync = { id: url.searchParams.get('knownSyncId'),
+        epoch: url.searchParams.get('knownEpoch'), seq: knownSeq === null ? undefined : Number(knownSeq),
+        updatedAt: Number(url.searchParams.get('knownUpdatedAt')), chatRevision: url.searchParams.get('knownChatRevision') };
+      const pageOptions = sharedHistoryPageOptions();
+      pageOptions.reconcileObserved = url.searchParams.get('refresh') === '1';
+      if (request.socketRequest) {
+        pageOptions.onWindow = async window => {
+          if (response.writableEnded) return;
+          await response.historyPage(await prepareSharedTimeline(window));
+        };
       }
-      const argumentsValue = readThreadArguments(url, threadId, 10);
-      const result = await callTool('read_thread', argumentsValue);
-      if (result.success) {
-        const timeline = normalizeTimeline(result.data);
-        enrichTimelineWithLocalActivity(timeline, threadId);
-        sendJson(response, 200, timeline);
-      } else {
-        sendJson(response, 502, { error: 'Codex Desktop 工具返回失败。', details: result.data });
+      const timeline = await prepareSharedTimeline(await execution.timeline(threadId, pageOptions, knownSync));
+      if (request.socketRequest) {
+        response.on('progress', () => execution.keepSnapshotAlive(threadId, timeline.sync));
+        response.once('close', () => execution.keepSnapshotAlive(threadId, timeline.sync));
       }
+      sendJson(response, 200, timeline);
       return;
     }
 
     const approvalMatch = /^\/api\/threads\/([^/]+)\/approvals$/.exec(url.pathname);
-    if (request.method === 'POST' && approvalMatch) {
-      const threadId = decodeURIComponent(approvalMatch[1]);
-      await requireExecutionWritable(threadId);
-      if (!usesSharedTask({ hostId: url.searchParams.get('hostId') }) || appServerTasks.owns(threadId)) {
-        sendJson(response, 409, { error: '当前执行模式不支持手机审批，请在工作站处理。' }); return;
-      }
+    if (request.method === 'GET' && approvalMatch && rootChat) {
+      const threadId = decodeURIComponent(approvalMatch[1]);
+      sendJson(response, 200, await execution.inspectApproval(threadId, {
+        id: url.searchParams.get('requestId'), roomMessageId: url.searchParams.get('roomMessageId'),
+      })); return;
+    }
+    if (request.method === 'POST' && approvalMatch) {
+      const threadId = decodeURIComponent(approvalMatch[1]);
+      await requireExecutionWritable(threadId, execution);
       const body = await readJsonBody(request);
-      sendJson(response, 200, await sharedServer.respondApproval(threadId, body)); return;
+      sendJson(response, 200, await execution.respondApproval(threadId, body)); return;
     }
 
     const eventsMatch = /^\/api\/threads\/([^/]+)\/events$/.exec(url.pathname);
     if (request.method === 'GET' && eventsMatch) {
       const threadId = decodeURIComponent(eventsMatch[1]);
-      if (!appServerTasks.owns(threadId) && usesSharedTask({ hostId: url.searchParams.get('hostId') })) {
-        const after = Number(url.searchParams.get('afterSeq'));
-        const requestedSync = url.searchParams.get('syncId') && url.searchParams.get('syncEpoch') && Number.isSafeInteger(after) && after >= 0
-          ? { id: url.searchParams.get('syncId'), epoch: url.searchParams.get('syncEpoch'), after } : undefined;
-        const knownUpdatedAt = Number(url.searchParams.get('knownUpdatedAt'));
-        const known = url.searchParams.get('knownTurnId') ? {
-          updatedAt: Number.isFinite(knownUpdatedAt) ? knownUpdatedAt : 0,
-          turnId: url.searchParams.get('knownTurnId'),
-          turnStatus: url.searchParams.get('knownTurnStatus') || '',
-        } : undefined;
-        await streamSharedThread(response, threadId, sharedServer, normalizeSharedTimeline, requestedSync, known);
-        return;
-      }
-      if (appServerTasks.owns(threadId)) {
-        await streamAppServerThreadEvents(request, response, threadId);
-        return;
-      }
-      await streamThreadEvents(
-        request,
-        response,
-        threadId,
-        url.searchParams.get('hostId')?.trim(),
-      );
+      const after = Number(url.searchParams.get('afterSeq'));
+      const requestedSync = { id: url.searchParams.get('syncId'), epoch: url.searchParams.get('syncEpoch'),
+        after: Number.isSafeInteger(after) && after >= 0 ? after : undefined,
+        updatedAt: Number(url.searchParams.get('knownUpdatedAt')), chatRevision: url.searchParams.get('knownChatRevision') };
+      await streamSharedThread(response, threadId, execution,
+        prepareSharedTimeline, requestedSync);
       return;
     }
 
+    const modelChangesMatch = /^\/api\/threads\/([^/]+)\/model-changes$/.exec(url.pathname);
+    if (request.method === 'GET' && modelChangesMatch) {
+      const threadId = decodeURIComponent(modelChangesMatch[1]);
+      if (!/^[0-9a-f]{8}-[0-9a-f-]{20,55}$/i.test(threadId)) throw new RequestError(400, '对话 ID 无效。');
+      sendJson(response, 200, hostId === 'durable' ? [] : await turnModelHistory.read(findSessionPath(threadId), (url.searchParams.get('turnIds') || '').split(',').filter(Boolean)));
+      return;
+    }
     const contextMatch = /^\/api\/threads\/([^/]+)\/context$/.exec(url.pathname);
     if (request.method === 'GET' && contextMatch) {
       const threadId = decodeURIComponent(contextMatch[1]);
-      const current = readContextUsage(threadId);
-      const native = usesSharedTask({ hostId: url.searchParams.get('hostId') }) ? await sharedServer.readContext(threadId) : {};
+      const current = hostId === 'durable' ? { available: false } : readContextUsage(threadId);
+      const native = await execution.readContext(threadId, url.searchParams.get('refreshSettings') === 'true');
       sendJson(response, 200, { ...current, ...(native.model ? { model: native.model, thinking: native.thinking, serviceTier: native.serviceTier,
-        permissionMode: native.permissionMode, permissionModes: native.permissionModes } : {}), ...(native.available ? native : {}) });
+        permissionMode: native.permissionMode, permissionModes: native.permissionModes, globalPermissionMode: native.globalPermissionMode } : {}), ...(native.available ? native : {}) });
       return;
     }
 
     const sharedAction = /^\/api\/threads\/([^/]+)\/(history|settings|permissions)$/.exec(url.pathname);
-    if (sharedAction) {
+    if (sharedAction) {
       const id = decodeURIComponent(sharedAction[1]);
-      if (!usesSharedTask({ hostId: url.searchParams.get('hostId') }) || appServerTasks.owns(id)) throw new RequestError(400, '此连接不支持该操作。');
       if (request.method === 'GET' && sharedAction[2] === 'history') {
-        sendJson(response, 200, normalizeSharedTimeline(await sharedServer.history(id, url.searchParams.get('cursor'), sharedHistoryPageOptions())));
+        const pageOptions = sharedHistoryPageOptions();
+        if (url.searchParams.has('itemLimit')) {
+          const itemLimit = Number(url.searchParams.get('itemLimit'));
+          if (!Number.isInteger(itemLimit) || itemLimit < 1 || itemLimit > 100) throw new RequestError(400, '历史条目数量无效。');
+          pageOptions.itemLimit = itemLimit;
+        }
+        const history = await execution.history(id, url.searchParams.get('cursor'), pageOptions);
+        sendJson(response, 200, await prepareSharedTimeline(history, hostId));
         return;
       }
-      if (request.method === 'POST' && sharedAction[2] === 'settings') {
-        await requireExecutionWritable(id);
+      if (request.method === 'POST' && sharedAction[2] === 'settings') {
+        if (rootChat) throw new RequestError(405, 'Dots 主对话不提供 Codex 模型设置。');
+        await requireExecutionWritable(id, execution);
         const body = await readJsonBody(request);
-        sendJson(response, 200, await sharedServer.settings(id, body.model, body.thinking, body.serviceTier));
+        sendJson(response, 200, await execution.settings(id, body.model, body.thinking, body.serviceTier));
         return;
       }
-      if (request.method === 'POST' && sharedAction[2] === 'permissions') {
-        await requireExecutionWritable(id);
+      if (request.method === 'POST' && sharedAction[2] === 'permissions') {
+        if (rootChat) throw new RequestError(405, 'Dots 主对话不提供 Codex 权限设置。');
+        await requireExecutionWritable(id, execution);
         const body = await readJsonBody(request);
-        sendJson(response, 200, await sharedServer.permissions(id, body.mode));
+        sendJson(response, 200, await execution.permissions(id, body.mode));
         return;
-      }
-    }
-
-    const sharedOperationGroup = /^\/api\/threads\/([^/]+)\/turns\/([^/]+)\/groups\/([^/]+)\/items$/.exec(url.pathname);
-    if (request.method === 'GET' && sharedOperationGroup) {
-      const threadId = decodeURIComponent(sharedOperationGroup[1]);
-      const turnId = decodeURIComponent(sharedOperationGroup[2]);
-      const groupId = decodeURIComponent(sharedOperationGroup[3]);
-      if (!usesSharedTask({ hostId: url.searchParams.get('hostId') }) || appServerTasks.owns(threadId)) {
-        throw new RequestError(400, '此连接不支持操作组分页。');
-      }
-      const page = await sharedServer.operationGroupItems(threadId, turnId, groupId, url.searchParams.get('offset'));
-      sendJson(response, 200, { turnId: page.turnId, groupId: page.groupId,
-        entries: page.items.map(normalizeItem).filter(Boolean), nextOffset: page.nextOffset, total: page.total });
-      return;
-    }
-
-    const archiveMatch = /^\/api\/threads\/([^/]+)\/(archive|unarchive)$/.exec(url.pathname);
-    if (request.method === 'POST' && archiveMatch) {
-      const threadId = decodeURIComponent(archiveMatch[1]);
-      await requireExecutionWritable(threadId);
-      if (!usesSharedTask({ hostId: url.searchParams.get('hostId') }) || appServerTasks.owns(threadId)) {
-        throw new RequestError(400, '当前连接不支持归档对话。请启用完整控制。');
       }
-      await sharedServer.request(`thread/${archiveMatch[2]}`, { threadId });
-      sendJson(response, 200, { threadId, archived: archiveMatch[2] === 'archive' });
-      return;
     }
 
-    const readMatch = /^\/api\/threads\/([^/]+)$/.exec(url.pathname);
-    if (request.method === 'DELETE' && readMatch) {
-      const threadId = decodeURIComponent(readMatch[1]);
-      await requireExecutionWritable(threadId);
-      if (!appServerTasks.owns(threadId)) {
-        throw new RequestError(400, '仅支持删除由独立 app-server 通道创建的任务。');
-      }
-      await appServerTasks.deleteTask(threadId);
-      messageQueues.delete(threadId);
-      sendJson(response, 200, { deleted: true, threadId, transport: 'app-server' });
+    const renameMatch = /^\/api\/threads\/([^/]+)\/name$/.exec(url.pathname);
+    if (request.method === 'POST' && renameMatch) {
+      if (rootChat) throw new RequestError(405, '点点主聊天名称由点点资料管理。');
+      const threadId = decodeURIComponent(renameMatch[1]);
+      await requireExecutionWritable(threadId, execution);
+      const body = await readJsonBody(request);
+      const name = typeof body.name === 'string' ? body.name.trim() : '';
+      if (!name || /[\r\n]/.test(name)) throw new RequestError(400, '请输入单行对话名称。');
+      await execution.request('thread/name/set', { threadId, name });
+      sendJson(response, 200, { threadId, name });
       return;
     }
-    if (request.method === 'GET' && readMatch) {
-      const threadId = decodeURIComponent(readMatch[1]);
-      if (appServerTasks.owns(threadId)) {
-        sendJson(response, 200, { thread: await appServerTasks.readTask(threadId, {
-          includeTurns: true,
-          turnLimit: boundedInteger(url.searchParams.get('turnLimit'), 10, 1, 10),
-        }) });
-        return;
+
+    const archiveMatch = /^\/api\/threads\/([^/]+)\/(archive|unarchive)$/.exec(url.pathname);
+    if (request.method === 'POST' && archiveMatch) {
+      if (rootChat) throw new RequestError(405, 'Dots 主对话不提供任务归档。');
+      const threadId = decodeURIComponent(archiveMatch[1]);
+      await requireExecutionWritable(threadId, execution);
+      if (archiveMatch[2] === 'archive') {
+        const { thread } = await execution.request('thread/read', { threadId, includeTurns: false });
+        const status = typeof thread.status === 'string' ? thread.status : thread.status?.type;
+        if (['active', 'inProgress'].includes(status)) throw new RequestError(409, '对话正在运行，请先停止任务。');
       }
-      const argumentsValue = readThreadArguments(url, threadId, 10, 12_000);
-      sendToolResult(response, await callTool('read_thread', argumentsValue));
+      await execution.request(`thread/${archiveMatch[2]}`, { threadId });
+      sendJson(response, 200, { threadId, archived: archiveMatch[2] === 'archive' });
       return;
     }
 
     const queueMatch = /^\/api\/threads\/([^/]+)\/queue$/.exec(url.pathname);
     if (queueMatch) {
+      if (hostId === 'durable') throw new RequestError(405, '当前托管连接不提供排队消息。');
       const threadId = decodeURIComponent(queueMatch[1]);
-      if (!appServerTasks.owns(threadId) && usesSharedTask({ hostId: url.searchParams.get('hostId') })) {
-        await sharedServer.connect();
-        const rpc = (method, params) => sharedServer.request(method, params);
-        if (request.method === 'GET') { sendJson(response, 200, await appServerEvents.readQueue(rpc, threadId)); return; }
-        if (request.method === 'POST') {
-          await requireExecutionWritable(threadId);
-          const args = appServerTurnArguments(threadId, await readJsonBody(request));
-          sendJson(response, 202, await appServerEvents.addQueue(rpc, threadId, args.input, crypto.randomUUID())); return;
-        }
-      }
-      if (request.method === 'GET') {
-        sendJson(response, 200, { items: publicQueue(threadId) });
-        return;
-      }
-      if (request.method === 'POST') {
-        await requireExecutionWritable(threadId);
+      await sharedServer.connect();
+      const rpc = (method, params) => sharedServer.request(method, params);
+      if (request.method === 'GET') { sendJson(response, 200, await appServerEvents.readQueue(rpc, threadId)); return; }
+      if (request.method === 'POST') {
         const body = await readJsonBody(request);
-        const argumentsValue = appServerTasks.owns(threadId)
-          ? appServerTurnArguments(threadId, body)
-          : await messageArguments(threadId, body);
-        const item = {
-          id: crypto.randomUUID(),
-          ...argumentsValue,
-          transport: appServerTasks.owns(threadId) ? 'app-server' : 'desktop-tools',
-          displayPrompt: messageDisplayText(body),
-          text: typeof body.prompt === 'string' ? body.prompt.trim() : '',
-          attachments: (body.images || []).map(id => ({ type:'image', available:true, url:id.startsWith('data:') ? id : `/api/attachments/${id}`, thumbnailUrl:id.startsWith('data:') ? id : `/api/attachments/${id}/thumbnail` })),
-          createdAt: new Date().toISOString(),
-          error: '',
-        };
-        const queue = messageQueues.get(threadId) || [];
-        queue.push(item);
-        messageQueues.set(threadId, queue);
-        ensureQueueWorker(threadId);
-        sendJson(response, 202, { items: publicQueue(threadId) });
-        return;
+        const result = await messageReceipts.submit([hostId, threadId], body.clientUserMessageId, async () => {
+          let args;
+          try { await requireExecutionWritable(threadId); args = appServerTurnArguments(threadId, body); }
+          catch (error) { error.deliveryUnknown = false; throw error; }
+          messageSubmissionStarted = true;
+          try { return await appServerEvents.addQueue(rpc, threadId, args.input, body.clientUserMessageId, body.containsVoiceInput); }
+          catch (error) { if (messageDelivery.rejectedBeforeSubmission(error)) error.deliveryUnknown = false; throw error; }
+        });
+        sendJson(response, 202, result); return;
       }
     }
 
     const queueItemMatch = /^\/api\/threads\/([^/]+)\/queue\/([a-f0-9-]+)(?:\/(steer))?$/.exec(url.pathname);
     if (queueItemMatch) {
+      if (hostId === 'durable') throw new RequestError(405, '当前托管连接不提供排队消息。');
       const threadId = decodeURIComponent(queueItemMatch[1]);
       const itemId = queueItemMatch[2];
-      if (!appServerTasks.owns(threadId) && usesSharedTask({ hostId: url.searchParams.get('hostId') })) {
-        await sharedServer.connect();
-        const action = request.method === 'DELETE' ? 'delete' : queueItemMatch[3] === 'steer' ? 'steer' : null;
-        if (!action) throw new RequestError(405, '不支持的队列操作');
-        await requireExecutionWritable(threadId);
-        sendJson(response, 200, await appServerEvents.changeQueue((method, params) => sharedServer.request(method, params), threadId, itemId, action)); return;
-      }
-      const queue = messageQueues.get(threadId) || [];
-      const index = queue.findIndex(item => item.id === itemId);
-      if (index < 0) {
-        sendJson(response, 404, { error: '没有找到该排队消息。' });
-        return;
-      }
-      if (request.method === 'DELETE' && !queueItemMatch[3]) {
-        await requireExecutionWritable(threadId);
-        queue.splice(index, 1);
-        sendJson(response, 200, { items: publicQueue(threadId) });
-        return;
-      }
-      if (request.method === 'POST' && queueItemMatch[3] === 'steer') {
-        await requireExecutionWritable(threadId);
-        const [item] = queue.splice(index, 1);
-        const result = await steerQueuedItem(threadId, item);
-        if (!result.success) {
-          queue.splice(index, 0, item);
-          sendJson(response, 502, { error: '插队发送失败。', details: result.data });
-          return;
-        }
-        sendJson(response, 200, { items: publicQueue(threadId) });
-        return;
-      }
-    }
-
-    const takeoverMatch = /^\/api\/threads\/([^/]+)\/takeover$/.exec(url.pathname);
-    if (request.method === 'POST' && takeoverMatch) {
-      const threadId = decodeURIComponent(takeoverMatch[1]);
-      await requireExecutionWritable(threadId);
-      if (appServerTasks.owns(threadId)) {
-        sendJson(response, 200, { thread: (await appServerTasks.listTasks()).find(t => t.id === threadId) });
-        return;
-      }
-      if (messageQueues.get(threadId)?.length || queueWorkers.has(threadId)) throw new RequestError(409, '请先处理此聊天的排队消息。');
-      const result = await callTool('read_thread', { threadId, turnLimit: 1, includeOutputs: false });
-      if (!result.success) throw new RequestError(502, '无法确认 Desktop 聊天状态。');
-      const timeline = normalizeTimeline(result.data);
-      const thread = timeline.thread;
-      if (thread.hostId && thread.hostId !== 'local') throw new RequestError(400, '只支持本机聊天。');
-      if (!['idle', 'notLoaded'].includes(thread.status) || timeline.turns.some(t => t.status === 'inProgress')) throw new RequestError(409, '只允许接管已空闲的聊天，请等当前轮次结束。');
-      if (!findSessionPath(threadId)) throw new RequestError(400, '未找到此聊天的本机历史。');
-      sendJson(response, 200, { thread: await appServerTasks.adoptTask({ ...thread, id: threadId }) });
-      return;
+      await sharedServer.connect();
+      const action = request.method === 'DELETE' ? 'delete' : queueItemMatch[3] === 'steer' ? 'steer' : null;
+      if (!action) throw new RequestError(405, '不支持的队列操作');
+      await requireExecutionWritable(threadId);
+      sendJson(response, 200, await appServerEvents.changeQueue((method, params) => sharedServer.request(method, params), threadId, itemId, action)); return;
     }
 
     const interruptMatch = /^\/api\/threads\/([^/]+)\/interrupt$/.exec(url.pathname);
-    if (request.method === 'POST' && interruptMatch) {
-      const threadId = decodeURIComponent(interruptMatch[1]);
-      await requireExecutionWritable(threadId);
-      if (!appServerTasks.owns(threadId) && usesSharedTask({ hostId: url.searchParams.get('hostId') })) {
-        const body = await readJsonBody(request);
-        if (!body.turnId) throw new RequestError(400, '缺少活动轮次 ID。');
-        await sharedServer.interrupt(threadId, body.turnId);
-        sendJson(response, 200, { requested: true });
-        return;
-      }
-      if (!appServerTasks.owns(threadId)) throw new RequestError(409, '请先接管空闲聊天。');
+    if (request.method === 'POST' && interruptMatch) {
+      if (rootChat) throw new RequestError(405, 'Dots 主对话不提供停止 Codex 任务的操作。');
+      const threadId = decodeURIComponent(interruptMatch[1]);
+      await requireExecutionWritable(threadId, execution);
       const body = await readJsonBody(request);
-      const thread = await appServerTasks.readTask(threadId, { turnLimit: 1 });
-      const active = thread.turns?.at(-1);
-      if (!body.turnId || active?.id !== body.turnId || statusText(active.status) !== 'inProgress') throw new RequestError(409, '此轮次已经结束或发生变化。');
-      // Stop also clears pending messages so the queue cannot restart work.
-      messageQueues.delete(threadId);
-      await appServerTasks.interruptTurn(threadId, body.turnId);
+      if (!body.turnId) throw new RequestError(400, '缺少活动轮次 ID。');
+      await execution.interrupt(threadId, body.turnId);
       sendJson(response, 200, { requested: true });
       return;
     }
 
-    const messageMatch = /^\/api\/threads\/([^/]+)\/messages$/.exec(url.pathname);
-    if (request.method === 'POST' && messageMatch) {
-      const threadId = decodeURIComponent(messageMatch[1]);
-      await requireExecutionWritable(threadId);
-      const body = await readJsonBody(request);
-      if (!appServerTasks.owns(threadId) && usesSharedTask(body)) {
-        sendJson(response, 200, { success: true, data: await sharedServer.send(appServerTurnArguments(threadId, body)) });
-      } else if (appServerTasks.owns(threadId)) {
-        const args = appServerTurnArguments(threadId, body);
-        const current = await appServerTasks.readTask(threadId, { turnLimit: 1 });
-        const active = current.turns?.at(-1);
-        sendJson(response, 200, statusText(active?.status) === 'inProgress'
-          ? await appServerTasks.steerTurn(threadId, active.id, args.input)
-          : await appServerTasks.startTurn(threadId, args));
-      } else {
-        sendToolResult(response, await callTool('send_message_to_thread', await messageArguments(threadId, body)));
-      }
+    const roomReadMatch = /^\/api\/threads\/([^/]+)\/read$/.exec(url.pathname);
+    if (request.method === 'POST' && roomReadMatch) {
+      if (!rootChat) throw new RequestError(405, '此对话不提供消息房间已读操作。');
+      await dotsChat.markRead(decodeURIComponent(roomReadMatch[1]), await readJsonBody(request));
+      sendJson(response, 200, { success: true });
       return;
     }
 
-    if (request.method === 'POST' && url.pathname === '/api/wait') {
+    const messageStatusMatch = /^\/api\/threads\/([^/]+)\/messages\/([a-f0-9]{32})\/status$/.exec(url.pathname);
+    if (request.method === 'GET' && messageStatusMatch) {
+      const threadId = decodeURIComponent(messageStatusMatch[1]), clientId = messageStatusMatch[2];
+      const result = await messageReceipts.reconcile([hostId, threadId], clientId, async () => {
+        if (hostId !== 'durable') {
+          await sharedServer.connect();
+          const queue = await appServerEvents.readQueue((method, params) => sharedServer.request(method, params), threadId);
+          if (queue.items.some(item => messageDelivery.normalizeId(item.clientUserMessageId) === clientId)) return queue;
+        }
+        return execution.findSentMessage(threadId, clientId, url.searchParams.get('anchorItemId') || '');
+      });
+      sendJson(response, 200, result);
+      return;
+    }
+    const messageMatch = /^\/api\/threads\/([^/]+)\/messages$/.exec(url.pathname);
+    if (request.method === 'POST' && messageMatch) {
+      const threadId = decodeURIComponent(messageMatch[1]);
       const body = await readJsonBody(request);
-      sendToolResult(response, await callTool('wait_threads', body, 130_000));
+      if (body.hostId && body.hostId !== hostId) throw new RequestError(400, '请求中的对话主机不一致。');
+      const result = await messageReceipts.submit([hostId, threadId], body.clientUserMessageId, async () => {
+        let args;
+        try { await requireExecutionWritable(threadId, execution); args = execution === dotsChat ? { ...body, threadId } : appServerTurnArguments(threadId, { ...body, hostId }); }
+        catch (error) { error.deliveryUnknown = false; throw error; }
+        messageSubmissionStarted = true;
+        const responseFor = submitted => ({ success: true, data: submitted.result, usage: submitted.usage });
+        try { return responseFor(await execution.send(args)); }
+        catch (error) {
+          if (error.deliveryResult) error.deliveryResult = error.deliveryResult.then(responseFor);
+          throw error;
+        }
+      });
+      sendJson(response, 200, result);
       return;
     }
 
@@ -732,209 +1063,100 @@ async function handleRequest(request, response) {
       if (!response.writableEnded) response.end();
       return;
     }
-    const status = error instanceof RequestError || error instanceof ThreadWriterConflictError ? (error.statusCode || 409) : 502;
-    sendJson(response, status, {
-      error: error instanceof Error ? error.message : String(error),
-      code: error?.code,
-      threadId: error?.threadId,
-      readOnly: error?.readOnly,
-      details: error?.details,
+    if (!messageSubmissionStarted && error.deliveryUnknown === undefined && request.method === 'POST'
+      && /^\/api\/threads\/[^/]+\/(?:messages|queue)(?:\?|$)/.test(request.url || '')) error.deliveryUnknown = false;
+    const status = error instanceof RequestError || error instanceof ThreadWriterConflictError || error instanceof FileRangeError ? (error.statusCode || 409) : 502;
+    sendJson(response, status, {
+      error: error instanceof Error ? error.message : String(error),
+      code: error?.code,
+      threadId: error?.threadId,
+      readOnly: error?.readOnly,
+      details: error?.deliveryUnknown === undefined ? error?.details : { ...error?.details, deliveryUnknown: error.deliveryUnknown },
     });
   }
 }
 
 const server = http.createServer(handleRequest);
 const lanSocket = attachLanSocket(server, { token: options.token, dispatch: handleRequest,
+  uploadsRoot,
   authorizeDevice: (clientId, credential) => authorizeLanDevice(stateRoot, clientId, credential),
+  onDeviceAuthorizationsChanged: listener => onLanAuthorizationsChanged(stateRoot, listener),
+  onPhoneConnected: (...args) => connectionReporting(stateRoot).connected(...args),
+  onPhoneDisconnected: id => connectionReporting(stateRoot).disconnected(id),
+  onDeviceConnected: (clientId, info) => {
+    try { recordLanConnection(stateRoot, clientId, info); }
+    catch (error) { console.error('记录局域网设备连接失败：', error.message); }
+  },
 });
 
-if (options.appServer) {
-  try {
-    await appServer.start();
-  } catch (error) {
-    console.error(`app-server 启动失败：${error instanceof Error ? error.message : String(error)}`);
-    process.exit(2);
-  }
-}
-
-let control;
-desktopMonitor.start();
-void managedAppServer.start();
-executionHealth.start();
+let control;
+const powerManager = createPowerManager(stateRoot);
+runtimeDiagnostic('service.starting', { platform: process.platform, nodeVersion: process.version });
+void managedAppServer.start();
+executionHealth.start();
+runtimeDiscovery.start();
 server.on('error', error => {
-  console.error('Bridge 监听失败：', error.message);
+  console.error('桌面服务监听失败：', error.message);
   process.exit(1);
 });
 server.listen(options.port, options.lan ? '0.0.0.0' : '127.0.0.1', async () => {
   try {
+    await powerManager.start();
     if (process.env.CODEX_REMOTE_INSTANCE && process.env.CODEX_REMOTE_CONTROL_SECRET && process.env.CODEX_REMOTE_READY_PATH) {
-      control = await openControl({ instanceId: process.env.CODEX_REMOTE_INSTANCE,
-        secret: process.env.CODEX_REMOTE_CONTROL_SECRET, shutdown: shutDown, actions: {
-          'refresh-execution': refreshExecution,
-          'restart-managed-app-server': () => {
-            const state = managedAppServer.snapshot();
-            return state.launcherRestartRequired ? managedAppServer.restart(crypto.randomUUID()) : state;
-          },
-        } });
+      control = await openControl({ instanceId: process.env.CODEX_REMOTE_INSTANCE,
+        secret: process.env.CODEX_REMOTE_CONTROL_SECRET, shutdown: shutDown, actions: {
+          'refresh-execution': refreshExecution,
+          'keep-awake-status': () => powerManager.snapshot(),
+          'keep-awake-enable': () => powerManager.setEnabled(true),
+          'keep-awake-disable': () => powerManager.setEnabled(false),
+          'relay-start': () => relayManager.run('relay-start'),
+          'relay-status': () => relayManager.run('relay-status'),
+          'relay-stop': () => relayManager.run('relay-stop'),
+          'relay-pair': () => relayManager.run('relay-pair'),
+          'relay-revoke': () => relayManager.run('relay-revoke'),
+          'invite-create': details => relayManager.run('invite-create', details),
+          'invite-list': () => relayManager.run('invite-list'),
+          'invite-revoke': details => relayManager.run('invite-revoke', details),
+          'devices-list': () => relayManager.run('devices-list'),
+          'device-revoke': details => relayManager.run('device-revoke', details),
+          'restart-managed-app-server': () => {
+            const state = managedAppServer.snapshot();
+            return state.launcherRestartRequired ? managedAppServer.restart(crypto.randomUUID()) : state;
+          },
+          'restart-managed-app-server-confirmed': () => managedAppServer.restart(crypto.randomUUID()),
+        } });
       writeRecord(process.env.CODEX_REMOTE_READY_PATH, { instanceId: process.env.CODEX_REMOTE_INSTANCE,
         pid: process.pid, controlPort: control.port });
     }
   } catch (error) {
-    console.error('Bridge 管理通道启动失败：', error.message);
+    console.error('桌面服务管理通道启动失败：', error.message);
     process.exit(1);
   }
-  console.log(`Code Relax Bridge 已启动：http://127.0.0.1:${options.port}/`);
+  console.log(`Code Relax 桌面服务已启动：http://127.0.0.1:${options.port}/`);
   if (options.lan) {
     console.log('LAN 模式使用鉴权 WebSocket，仅适合受信任局域网测试，不要暴露到公网。');
-  }
-});
-
-let shuttingDown = false;
-async function shutDown() {
-  if (shuttingDown) return;
-  shuttingDown = true;
-  lanSocket.close();
-  server.close();
-  desktopMonitor?.stop();
-  executionHealth?.stop();
-  managedAppServer.close();
-  await appServer.close();
-  await control?.close();
-  process.exit(0);
-}
-process.on('SIGTERM', shutDown);
-process.on('SIGINT', shutDown);
-
-async function callTool(tool, argumentsValue, timeoutMs = 60_000, targetPipe) {
-  if (!sourceThreadId) throw new RequestError(503, '基础控制尚未绑定调用上下文；请在 Codex 对话启动一次 Code Relax。电脑管理连接仍可使用。');
-  if (!ALLOWED_TOOLS.has(tool)) {
-    throw new RequestError(403, `工具 ${tool} 不在 Bridge 允许列表中。`);
-  }
-
-  const invocationId = crypto.randomUUID();
-  const rpc = await callDesktop('tools/call', {
-    arguments: argumentsValue,
-    callId: `codex-remote-${invocationId}`,
-    namespace: 'codex_app',
-    threadId: sourceThreadId,
-    tool,
-    turnId: `codex-remote-turn-${invocationId}`,
-  }, timeoutMs, targetPipe);
-
-  const result = rpc.result;
-  if (!result || typeof result.success !== 'boolean') {
-    throw new BridgeError('Codex Desktop 没有返回有效的工具结果。', rpc);
-  }
-
-  const items = Array.isArray(result.contentItems) ? result.contentItems : [];
-  let data = items;
-  if (items.length === 1 && items[0]?.type === 'inputText' && typeof items[0].text === 'string') {
-    try {
-      data = JSON.parse(items[0].text);
-    } catch {
-      data = items[0].text;
-    }
-  }
-
-  return { success: result.success, data };
-}
-
-function callDesktop(method, params, timeoutMs, targetPipe = desktopMonitor?.pipe || pipePath) {
-  if (!targetPipe) return Promise.reject(new RequestError(503, 'Desktop 工具通道尚未就绪。'));
-  return new Promise((resolve, reject) => {
-    const socket = net.createConnection(targetPipe);
-    const requestId = ++nextRequestId;
-    const payload = Buffer.from(JSON.stringify({ jsonrpc: '2.0', id: requestId, method, params }), 'utf8');
-    const header = Buffer.allocUnsafe(4);
-    header.writeUInt32LE(payload.length, 0);
-    let pending = Buffer.alloc(0);
-    let expectedLength = null;
-    let settled = false;
-
-    const finish = (callback, value) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timer);
-      socket.destroy();
-      callback(value);
-    };
-
-    const timer = setTimeout(() => {
-      finish(reject, new BridgeError('等待 Codex Desktop 响应超时。'));
-    }, timeoutMs);
-
-    socket.once('connect', () => socket.write(Buffer.concat([header, payload])));
-    socket.on('data', chunk => {
-      pending = Buffer.concat([pending, chunk]);
-      if (expectedLength === null && pending.length >= 4) {
-        expectedLength = pending.readUInt32LE(0);
-        pending = pending.subarray(4);
-        if (expectedLength <= 0 || expectedLength > MAX_FRAME_BYTES) {
-          finish(reject, new BridgeError(`Codex Desktop 返回了无效帧长度：${expectedLength}。`));
-          return;
-        }
-      }
-
-      if (expectedLength !== null && pending.length >= expectedLength) {
-        try {
-          const responseValue = JSON.parse(pending.subarray(0, expectedLength).toString('utf8'));
-          if (responseValue.error) {
-            finish(reject, new BridgeError('Codex Desktop 工具调用失败。', responseValue.error));
-          } else if (responseValue.id !== requestId) {
-            finish(reject, new BridgeError('Codex Desktop 返回了不匹配的请求 ID。'));
-          } else {
-            finish(resolve, responseValue);
-          }
-        } catch (error) {
-          finish(reject, new BridgeError('无法解析 Codex Desktop 响应。', undefined, error));
-        }
-      }
-    });
-    socket.once('error', error => finish(reject, new BridgeError(
-      '无法连接 Codex Desktop Pipe。桌面版可能已重启，请重新启动 Bridge。',
-      undefined,
-      error,
-    )));
-    socket.once('close', () => {
-      if (!settled) finish(reject, new BridgeError('Codex Desktop Pipe 在返回结果前关闭。'));
-    });
-  });
-}
-
-function sendToolResult(response, result) {
-  if (result.success) {
-    sendJson(response, 200, result.data);
-  } else {
-    sendJson(response, 502, { error: 'Codex Desktop 工具返回失败。', details: result.data });
-  }
-}
-
-function appServerBridgeStatus() {
-  return {
-    ...appServer.snapshot(),
-    platformFamily: appServer.initializeResult?.platformFamily || null,
-    platformOs: appServer.initializeResult?.platformOs || null,
-    taskCount: appServerTasks.store.list().length,
-    ownershipError: appServerTasks.store.loadError?.message || null,
-  };
-}
+  }
+});
 
-function readThreadArguments(url, threadId, defaultTurnLimit, defaultOutputLimit = 4_000) {
-  const argumentsValue = {
-    threadId,
-    turnLimit: boundedInteger(url.searchParams.get('turnLimit'), defaultTurnLimit, 1, 10),
-    includeOutputs: booleanValue(url.searchParams.get('includeOutputs'), true),
-    maxOutputCharsPerItem: boundedInteger(
-      url.searchParams.get('maxOutputCharsPerItem'),
-      defaultOutputLimit,
-      500,
-      100_000,
-    ),
-  };
-  const hostId = url.searchParams.get('hostId')?.trim();
-  if (hostId) argumentsValue.hostId = hostId;
-  return argumentsValue;
+let shuttingDown = false;
+async function shutDown() {
+  if (shuttingDown) return;
+  shuttingDown = true;
+  await powerManager.close();
+  desktopHelper?.release();
+  lanSocket.close();
+  server.close();
+  executionHealth?.stop();
+  runtimeDiscovery.stop();
+  await relayManager.close();
+  dotsServer.close();
+  dotsChat.close();
+  managedAppServer.close();
+  await control?.close();
+  process.exit(0);
 }
+process.on('SIGTERM', shutDown);
+process.on('SIGINT', shutDown);
 
 function readContextUsage(threadId) {
   if (!/^[0-9a-f]{8}-[0-9a-f-]{20,55}$/i.test(threadId)) {
@@ -1058,108 +1280,6 @@ function findSessionPath(threadId) {
   return null;
 }
 
-function enrichTimelineWithLocalActivity(timeline, threadId) {
-  const turn = timeline.turns.at(-1);
-  if (!turn || turn.status !== 'inProgress') return;
-  if (turn.entries.some(entry => entry?.type === 'activity' && entry.status === 'inProgress')) return;
-  const pending = readPendingLocalActivity(threadId);
-  if (!pending || (pending.turnId && pending.turnId !== turn.id)) return;
-  turn.entries.push(pending.entry);
-}
-
-function readPendingLocalActivity(threadId) {
-  const sessionPath = findSessionPath(threadId);
-  if (!sessionPath) return null;
-  let handle;
-  try {
-    const stat = fs.statSync(sessionPath);
-    const cacheKey = `${stat.size}:${stat.mtimeMs}`;
-    const cached = liveActivityCache.get(sessionPath);
-    if (cached?.key === cacheKey) return cached.value;
-    const readLength = Math.min(stat.size, MAX_LIVE_ACTIVITY_TAIL_BYTES);
-    const buffer = Buffer.allocUnsafe(readLength);
-    handle = fs.openSync(sessionPath, 'r');
-    fs.readSync(handle, buffer, 0, readLength, stat.size - readLength);
-    const lines = buffer.toString('utf8').split(/\r?\n/);
-    if (readLength < stat.size) lines.shift();
-    const pending = new Map();
-    for (const line of lines) {
-      if (!line.includes('"custom_tool_call')) continue;
-      let event;
-      try { event = JSON.parse(line); } catch { continue; }
-      if (event?.type !== 'response_item') continue;
-      const payload = event.payload;
-      const callId = payload?.call_id;
-      if (!callId) continue;
-      if (payload.type === 'custom_tool_call') pending.set(callId, payload);
-      if (payload.type === 'custom_tool_call_output') pending.delete(callId);
-    }
-    const payload = [...pending.values()].at(-1);
-    const value = payload ? pendingActivity(payload) : null;
-    liveActivityCache.set(sessionPath, { key: cacheKey, value });
-    return value;
-  } catch {
-    liveActivityCache.delete(sessionPath);
-    return null;
-  } finally {
-    if (handle !== undefined) fs.closeSync(handle);
-  }
-}
-
-function pendingActivity(payload) {
-  const input = typeof payload.input === 'string' ? payload.input : '';
-  const nestedTool = input.match(/tools\.([A-Za-z0-9_]+)\s*\(/)?.[1] || payload.name || 'tool';
-  const id = `live:${payload.call_id}`;
-  const common = { type: 'activity', id, status: 'inProgress', transient: true };
-  const turnId = payload.internal_chat_message_metadata_passthrough?.turn_id || '';
-  if (nestedTool === 'exec_command') {
-    return {
-      turnId,
-      entry: {
-        ...common,
-        kind: 'command',
-        title: '命令',
-        command: jsonStringField(input, 'cmd'),
-        cwd: jsonStringField(input, 'workdir'),
-      },
-    };
-  }
-  if (nestedTool === 'apply_patch') {
-    return { turnId, entry: { ...common, kind: 'fileChange', title: '文件修改', changes: [] } };
-  }
-  if (nestedTool === 'web__run') {
-    return {
-      turnId,
-      entry: { ...common, kind: 'webSearch', title: '网页搜索', query: jsonStringField(input, 'q') },
-    };
-  }
-  if (nestedTool === 'view_image') {
-    return {
-      turnId,
-      entry: { ...common, kind: 'imageView', title: '查看图片', path: jsonStringField(input, 'path') },
-    };
-  }
-  const parts = nestedTool.replace(/^mcp__/, '').split('__');
-  return {
-    turnId,
-    entry: {
-      ...common,
-      kind: 'tool',
-      title: '工具',
-      server: parts.length > 1 ? parts.shift() : 'functions',
-      tool: parts.join('/') || nestedTool,
-      arguments: {},
-    },
-  };
-}
-
-function jsonStringField(source, field) {
-  const pattern = new RegExp(`(?:["']${field}["']|${field})\\s*:\\s*("(?:\\\\.|[^"\\\\])*")`);
-  const match = pattern.exec(source);
-  if (!match) return '';
-  try { return JSON.parse(match[1]); } catch { return ''; }
-}
-
 function messagePayload(body) {
   const prompt = typeof body.prompt === 'string' ? body.prompt.trim() : '';
   if (body.images !== undefined && (!Array.isArray(body.images) || body.images.length > 4)) {
@@ -1173,6 +1293,14 @@ function messagePayload(body) {
     if (!fs.existsSync(file)) throw new RequestError(400, '图片不存在，请重新添加。');
     return file;
   });
+  for (const input of fileMentions.originalInputs(body)) {
+    const incoming = fs.realpathSync(path.join(uploadsRoot, 'incoming'));
+    const imagePath = fs.realpathSync(input.path);
+    if (path.dirname(imagePath).toLowerCase() !== incoming.toLowerCase()) throw new RequestError(400, '原图必须来自上传目录。');
+    const stat = fs.statSync(imagePath);
+    if (!stat.isFile() || stat.size <= 0 || stat.size > MAX_ATTACHMENT_BYTES) throw new RequestError(400, '原图为空或超过 20 MiB。');
+    images.push(imagePath);
+  }
   if (images.filter(image => image.startsWith('data:')).reduce((size, image) => size + Buffer.byteLength(image.slice(image.indexOf(',') + 1), 'base64'), 0) > 8 * 1024 * 1024) throw new RequestError(413, '本条消息图片合计不能超过 8 MiB。');
   if (!prompt && !images.length) throw new RequestError(400, 'prompt 不能为空。');
   if (prompt.length > 32_000) throw new RequestError(400, 'prompt 不能超过 32000 个字符。');
@@ -1180,9 +1308,7 @@ function messagePayload(body) {
   const payload = { prompt, images };
   if (typeof body.hostId === 'string' && body.hostId.trim()) payload.hostId = body.hostId.trim();
   if (typeof body.model === 'string' && body.model.trim()) {
-    const model = body.model.trim();
-    if (!ALLOWED_MODELS.has(model)) throw new RequestError(400, '不支持的模型。');
-    payload.model = model;
+    payload.model = body.model.trim();
   }
   if (typeof body.thinking === 'string' && body.thinking.trim()) {
     const thinking = body.thinking.trim();
@@ -1196,302 +1322,32 @@ function messagePayload(body) {
   return payload;
 }
 
-async function messageArguments(threadId, body) {
-  const payload = messagePayload(body);
-  payload.images = await Promise.all(payload.images.map(image => image.startsWith('data:') ? persistLegacyImage(image, uploadsRoot) : image));
-  let prompt = payload.prompt;
-  if (payload.images.length) {
-    prompt += (prompt ? '\n\n' : '') + payload.images
-      .map((file, index) => `![手机图片 ${index + 1}](${file.replaceAll('\\', '/')})`)
-      .join('\n\n');
-  }
-  const argumentsValue = { threadId, prompt };
-  if (payload.hostId) argumentsValue.hostId = payload.hostId;
-  if (payload.model) argumentsValue.model = payload.model;
-  if (payload.thinking) argumentsValue.thinking = payload.thinking;
-  return argumentsValue;
-}
-
-function usesSharedTask(body) {
-  return Boolean(sharedServer && (!body.hostId || body.hostId === 'local'));
-}
-
 function appServerTurnArguments(threadId, body) {
   const payload = messagePayload(body);
+  const mentioned = payload.hostId === 'durable' ? fileMentions.parse(payload.prompt) : null;
+  if (mentioned?.files.length) payload.prompt = mentioned.text;
   const input = [];
   if (payload.prompt) input.push({ type: 'text', text: payload.prompt });
-  for (const image of payload.images) input.push(image.startsWith('data:') ? { type: 'image', url: image } : { type: 'localImage', path: image });
-  const value = { threadId, input };
+  for (const image of payload.images) {
+    if (image.startsWith('data:')) input.push({ type: 'image', url: image });
+    else if (payload.hostId === 'durable') {
+      const mimeType = imageMimeType(image);
+      if (!mimeType) throw new RequestError(400, '云端图片格式无效。');
+      input.push({ type: 'image', url: `data:${mimeType};base64,${fs.readFileSync(image).toString('base64')}` });
+    } else input.push({ type: 'localImage', path: image });
+  }
+  const value = { threadId, input, ...appServerEvents.mobileTurnSource(body.clientUserMessageId, body.containsVoiceInput) };
+  if (mentioned?.files.length) value.uploadFiles = mentioned.files;
   if (typeof body.clientUserMessageId === 'string' && /^[a-f0-9]{32}$/.test(body.clientUserMessageId)) value.clientUserMessageId = body.clientUserMessageId;
   if (payload.model) value.model = payload.model;
   if (payload.thinking) value.effort = payload.thinking;
   return value;
 }
 
-function messageDisplayText(body) {
-  const prompt = typeof body.prompt === 'string' ? body.prompt.trim() : '';
-  const imageCount = Array.isArray(body.images) ? body.images.length : 0;
-  return prompt || (imageCount ? `[${imageCount} 张图片]` : '');
-}
-
-function createThreadBody(body) {
-  const payload = messagePayload(body);
-  return { ...body, prompt: payload.prompt, transport: body.transport === 'app-server' ? 'app-server' : 'desktop-tools' };
-}
-
-function appServerProjectTarget(projectId, projects) {
-  if (projectId === '__unassigned__') return appServerEvents.projectlessThreadTarget(projectRoot);
-  const project = projects.find(item => item?.projectId === projectId);
-  if (!project) throw new RequestError(404, '没有找到对应项目。');
-  if (project.hostId && project.hostId !== 'local') {
-    throw new RequestError(400, '独立 app-server 当前只支持本机项目。');
-  }
-  if (typeof project.path !== 'string' || !path.isAbsolute(project.path)) {
-    throw new RequestError(400, '项目没有可用的本机路径。');
-  }
-  return { projectId, cwd: project.path };
-}
-
-function mergeThreadCatalog(catalog, appThreads, limit, sharedSnapshot = Boolean(sharedServer)) {
-  const owned = new Map(appThreads.map(thread => [thread.id, thread]));
-  const pinnedThreads = (catalog.pinnedThreads || []).map(thread => owned.get(thread.id) || thread);
-  const pinnedIds = new Set(pinnedThreads.map(thread => thread.id));
-  if (sharedSnapshot) {
-    const listed = new Set([...pinnedIds, ...(catalog.threads || []).map(thread => thread.id)]);
-    const threads = (catalog.threads || []).map(thread => owned.get(thread.id) || thread);
-    threads.push(...appThreads.filter(thread => !listed.has(thread.id)));
-    threads.sort((left, right) => threadRecency(right) - threadRecency(left));
-    return { ...catalog, pinnedThreads: [], threads: threads.slice(0, limit) };
-  }
-  const desktopThreads = (catalog.threads || []).filter(thread => !owned.has(thread.id));
-  const merged = [...desktopThreads, ...appThreads.filter(thread => !pinnedIds.has(thread.id))]
-    .sort((left, right) => threadRecency(right) - threadRecency(left))
-    .slice(0, limit);
-  return { ...catalog, pinnedThreads, threads: merged };
-}
-
-async function createThreadArguments(projectId, body, projects) {
-  const { threadId, hostId, ...message } = await messageArguments('', body);
-  if (projectId === '__unassigned__') return { ...message, target: { type:'projectless' } };
-  const project = projects.find(item => item?.projectId === projectId);
-  if (!project) throw new RequestError(404, '没有找到对应项目。');
-  return { ...message, target:{ type:'project', projectId, environment:{ type:'local' } } };
-}
-
-function publicQueue(threadId) {
-  return (messageQueues.get(threadId) || []).map(item => ({
-    id: item.id,
-    prompt: item.displayPrompt || item.prompt,
-    text: item.text, attachments:item.attachments || [],
-    model: item.model || '',
-    thinking: item.thinking || item.effort || '',
-    createdAt: item.createdAt,
-    error: item.error || '',
-  }));
-}
-
-function queueArguments(item) {
-  const value = { threadId: item.threadId, prompt: item.prompt };
-  if (item.hostId) value.hostId = item.hostId;
-  if (item.model) value.model = item.model;
-  if (item.thinking) value.thinking = item.thinking;
-  return value;
-}
-
-async function sendQueuedItem(threadId, item) {
-  await requireExecutionWritable(threadId);
-  if (item.transport === 'app-server') {
-    try {
-      return { success: true, data: await appServerTasks.startTurn(threadId, item) };
-    } catch (error) {
-      return { success: false, data: error instanceof Error ? error.message : String(error) };
-    }
-  }
-  return callTool('send_message_to_thread', queueArguments(item));
-}
-
-async function steerQueuedItem(threadId, item) {
-  if (item.transport !== 'app-server') return callTool('send_message_to_thread', queueArguments(item));
-  try {
-    const thread = await appServerTasks.readTask(threadId, { includeTurns: true, turnLimit: 1 });
-    const activeTurn = thread.turns?.at(-1);
-    if (!activeTurn || statusText(activeTurn.status) !== 'inProgress') {
-      throw new Error('当前没有可引导的 app-server 活动轮次。');
-    }
-    return {
-      success: true,
-      data: await appServerTasks.steerTurn(threadId, activeTurn.id, item.input),
-    };
-  } catch (error) {
-    return { success: false, data: error instanceof Error ? error.message : String(error) };
-  }
-}
-
-function ensureQueueWorker(threadId) {
-  if (queueWorkers.has(threadId)) return;
-  const worker = runQueueWorker(threadId)
-    .catch(error => {
-      const item = messageQueues.get(threadId)?.[0];
-      if (item) item.error = error instanceof Error ? error.message : String(error);
-    })
-    .finally(() => queueWorkers.delete(threadId));
-  queueWorkers.set(threadId, worker);
-}
-
-async function runQueueWorker(threadId) {
-  while (true) {
-    const queue = messageQueues.get(threadId) || [];
-    const item = queue[0];
-    if (!item || item.error) return;
-    let timeline;
-    if (item.transport === 'app-server') {
-      const thread = await appServerTasks.readTask(threadId, { includeTurns: true, turnLimit: 1 });
-      timeline = normalizeAppServerTimeline(thread);
-    } else {
-      const readArguments = {
-        threadId,
-        turnLimit: 1,
-        includeOutputs: false,
-        maxOutputCharsPerItem: 500,
-      };
-      if (item.hostId) readArguments.hostId = item.hostId;
-      const threadResult = await callTool('read_thread', readArguments, 15_000);
-      if (!threadResult.success) throw new BridgeError('读取排队任务状态失败。', threadResult.data);
-      timeline = normalizeTimeline(threadResult.data);
-    }
-    const active = timeline.thread.status === 'active' || timeline.turns.at(-1)?.status === 'inProgress';
-    if (active) {
-      await delay(2_000);
-      continue;
-    }
-    if (messageQueues.get(threadId) !== queue || queue[0]?.id !== item.id) continue;
-    const sendResult = await sendQueuedItem(threadId, item);
-    if (!sendResult.success) throw new BridgeError('发送排队消息失败。', sendResult.data);
-    if (queue[0]?.id === item.id) queue.shift();
-  }
-}
-
-async function streamAppServerThreadEvents(request, response, threadId) {
-  response.startEvents();
-
-  let closed = false;
-  let pushPending = false;
-  let pushing = false;
-  let previousHash = '';
-  let updateTimer = null;
-  let resolveClosed;
-  const closedPromise = new Promise(resolve => { resolveClosed = resolve; });
-  response.once('close', () => { closed = true; resolveClosed(); });
-
-  const pushUpdate = async () => {
-    if (closed) return;
-    if (pushing) { pushPending = true; return; }
-    pushing = true;
-    try {
-      const thread = await appServerTasks.readTask(threadId, { includeTurns: true, turnLimit: 2 });
-      const timeline = normalizeAppServerTimeline(thread);
-      const update = {
-        thread: timeline.thread,
-        turns: timeline.turns.slice(-2),
-        turn: timeline.turns.at(-1) || null,
-        queue: publicQueue(threadId),
-      };
-      const serialized = JSON.stringify(update);
-      const hash = crypto.createHash('sha256').update(serialized).digest('base64url');
-      if (hash !== previousHash) {
-        sendEvent(response, 'update', update);
-        previousHash = hash;
-      }
-    } catch (error) {
-      sendEvent(response, 'bridge-error', { error: error instanceof Error ? error.message : String(error) });
-    } finally {
-      pushing = false;
-      if (pushPending && !closed) {
-        pushPending = false;
-        void pushUpdate();
-      }
-    }
-  };
-  const scheduleUpdate = event => {
-    if (closed || event.threadId !== threadId || updateTimer) return;
-    updateTimer = setTimeout(() => {
-      updateTimer = null;
-      void pushUpdate();
-    }, 60);
-  };
-  appServerTasks.on('thread-event', scheduleUpdate);
-  await pushUpdate();
-
-  await closedPromise;
-  closed = true;
-  if (updateTimer) clearTimeout(updateTimer);
-  appServerTasks.off('thread-event', scheduleUpdate);
-  if (!response.writableEnded) response.end();
-}
-
-async function streamThreadEvents(request, response, threadId, hostId) {
-  response.startEvents();
-
-  let closed = false;
-  let previousHash = '';
-  response.once('close', () => { closed = true; });
-
-  while (!closed) {
-    let intervalMs = 2_500;
-    try {
-      const argumentsValue = {
-        threadId,
-        turnLimit: 2,
-        includeOutputs: true,
-        maxOutputCharsPerItem: 4_000,
-      };
-      if (hostId) argumentsValue.hostId = hostId;
-      const result = await callTool('read_thread', argumentsValue);
-      if (!result.success) {
-        throw new BridgeError('Codex Desktop 工具返回失败。', result.data);
-      }
-
-      const timeline = normalizeTimeline(result.data);
-      enrichTimelineWithLocalActivity(timeline, threadId);
-      const update = {
-        thread: timeline.thread,
-        turns: timeline.turns.slice(-2),
-        turn: timeline.turns.at(-1) || null,
-        queue: publicQueue(threadId),
-      };
-      const serialized = JSON.stringify(update);
-      const hash = crypto.createHash('sha256').update(serialized).digest('base64url');
-      if (hash !== previousHash) {
-        sendEvent(response, 'update', update);
-        previousHash = hash;
-      }
-      if (timeline.thread.status === 'active' || update.turn?.status === 'inProgress') {
-        intervalMs = 1_000;
-      }
-    } catch (error) {
-      sendEvent(response, 'bridge-error', {
-        error: error instanceof Error ? error.message : String(error),
-      });
-      intervalMs = 3_000;
-    }
-
-    await delay(intervalMs);
-  }
-
-  if (!response.writableEnded) response.end();
-}
-
-function sendEvent(response, eventName, value) {
-  if (response.destroyed || response.writableEnded) return;
-  response.event(eventName, value);
-}
-
-function normalizeTimeline(data, reverseTurns = true) {
+function normalizeTimeline(data) {
   const source = data && typeof data === 'object' ? data : {};
   const sourceTurns = Array.isArray(source.turns) ? source.turns : source.thread?.turns;
   const turns = Array.isArray(sourceTurns) ? sourceTurns.map(normalizeTurn) : [];
-  if (reverseTurns) turns.reverse();
-  if (reverseTurns) restoreEmptyTurnMessages(source.thread?.id, turns);
   return {
     schemaVersion: 1,
     thread: normalizeThread(source.thread),
@@ -1499,113 +1355,88 @@ function normalizeTimeline(data, reverseTurns = true) {
   };
 }
 
-function normalizeAppServerTimeline(thread) {
-  const record = appServerTasks.store.get(thread?.id);
-  return normalizeTimeline({
-    thread: {
-      ...thread,
-      title: thread?.name || thread?.title || record?.title || '',
-      projectId: record?.projectId || '',
-      hostId: 'app-server',
-      transport: 'app-server',
-    },
-  }, false);
+function normalizeSharedTimeline({ thread, nextCursor, sync, notModified, incremental }, hostId = thread?.hostId || 'local') {
+  const timeline = normalizeTimeline({ thread: { ...thread, title: thread.name || thread.title || '', hostId,
+    transport: 'shared-app-server' } });
+  return { ...timeline,
+    historyItemCount: (thread.turns || []).reduce((count, turn) => count + (turn.roomMessage ? 1 : turn.items?.length || 0), 0),
+    historyView: thread?.threadSource === 'aeon' ? 'chat-items-v1' : 'item-pages-v1',
+    ...(notModified ? { notModified: true } : {}),
+    ...(incremental ? { incremental: true } : {}),
+    ...(nextCursor !== undefined ? { nextCursor } : {}), ...(sync ? { sync } : {}) };
 }
 
-function normalizeSharedTimeline({ thread, nextCursor, sync }) {
-  return { ...normalizeTimeline({ thread: { ...thread, title: thread.name || thread.title || '', hostId: 'local', transport: 'shared-app-server' } }, false),
-    historyView: 'grouped-lazy-skeleton-v11',
-    ...(nextCursor !== undefined ? { nextCursor } : {}), ...(sync ? { sync } : {}) };
-}
-
-function restoreEmptyTurnMessages(threadId, turns) {
-  const missing = new Map(turns.filter(turn => turn.entries.length === 0).map(turn => [turn.id, turn]));
-  if (!missing.size || !threadId) return;
-  const sessionPath = findSessionPath(threadId);
-  if (!sessionPath) return;
-  const handle = fs.openSync(sessionPath, 'r');
-  try {
-    const size = fs.fstatSync(handle).size;
-    const length = Math.min(size, MAX_SETTINGS_SCAN_BYTES);
-    const buffer = Buffer.allocUnsafe(length);
-    fs.readSync(handle, buffer, 0, length, size - length);
-    const lines = buffer.toString('utf8').split(/\r?\n/);
-    if (length < size) lines.shift();
-    let turnId;
-    for (const line of lines) {
-      if (!line.trim()) continue;
-      let event;
-      try { event = JSON.parse(line); } catch { continue; }
-      const item = event.payload;
-      if (event.type === 'event_msg' && item?.type === 'task_started') turnId = item.turn_id;
-      if (event.type === 'turn_context') turnId = item?.turn_id;
-      const turn = missing.get(turnId);
-      if (!turn || event.type !== 'response_item') continue;
-      let entry;
-      if (item.type === 'function_call_output' && item.namespace === 'codex_app' && ['create_thread', 'send_message_to_thread'].includes(item.name)) {
-        const text = extractDelegatedInput(item.output);
-        if (text) entry = { type: 'message', id: item.id, role: 'user', source: 'remote', ...splitUploadedImages(text) };
-      } else if (item.type === 'message' && ['user', 'assistant'].includes(item.role) && item.channel !== 'analysis') {
-        const text = (item.content || []).filter(part => ['input_text', 'output_text'].includes(part.type)).map(part => part.text || '').join('\n');
-        if (text) entry = item.role === 'user'
-          ? normalizeItem({ type: 'userMessage', id: item.id, content: item.content.map(part => ({ ...part, type: part.type === 'input_text' ? 'text' : part.type })) })
-          : normalizeItem({ type: 'agentMessage', id: item.id, phase: item.phase || item.channel, text });
-      }
-      if (entry) turn.entries.push(entry);
+async function prepareSharedTimeline(value, hostId) {
+  if (value.thread?.threadSource !== 'aeon') return normalizeSharedTimeline(value, hostId);
+  const epoch = dotsChat.epoch, threadId = value.thread.id;
+  const current = () => {
+    if (epoch !== dotsChat.epoch) throw new Error('点点连接已变化，请重新同步。');
+  };
+  if (value.notModified) {
+    const record = dotsChat.threads.get(threadId);
+    if (await dotsImages.prepareTimeline(record?.thread)) {
+      current();
+      value = dotsChat.snapshot(threadId, record);
     }
-  } finally { fs.closeSync(handle); }
+  }
+  const snapshot = structuredClone(value);
+  await dotsImages.prepareTimeline(snapshot.thread);
+  current();
+  return normalizeSharedTimeline(snapshot, hostId);
 }
 
-function normalizeThread(thread) {
+function normalizeThread(thread) {
   const source = thread && typeof thread === 'object' ? thread : {};
   return {
-    id: source.id || '',
-    title: source.name || source.title || source.preview || '',
-    status: statusText(source.status),
-    updatedAt: Number(source.updatedAt) || 0,
-    recencyAt: Number(source.recencyAt ?? source.updatedAt) || 0,
-    projectId: source.projectId || '',
+    id: source.id || '',
+    title: source.name || source.title || source.preview || '',
+    status: statusText(source.status),
+    updatedAt: Number(source.updatedAt) || 0,
+    recencyAt: Number(source.recencyAt ?? source.updatedAt) || 0,
+    projectId: source.projectId || '',
     cwd: source.cwd || '',
     hostId: source.hostId || '',
-    transport: source.transport || (source.hostId === 'app-server' ? 'app-server' : 'desktop-tools'),
-    readOnly: source.readOnly === true,
-    readOnlyReason: source.readOnlyReason || '',
+    threadSource: source.threadSource || '',
+    ...(['aeon', 'aeon_child'].includes(source.threadSource) ? { chatRevision: source.chatRevision || '' } : {}),
+    ...(source.threadSource === 'aeon' ? { avatar: source.avatar || '', color: source.color || '',
+      chatMessageRevision: source.chatMessageRevision, messagingRoomId: source.messagingRoomId, lastMessageAt: source.lastMessageAt } : {}),
+    transport: source.transport || 'shared-app-server',
+    readOnly: source.readOnly === true,
+    readOnlyReason: source.readOnlyReason || '',
   };
 }
 
-function normalizeTurn(turn) {
-  const source = turn && typeof turn === 'object' ? turn : {};
-  const turnId = source.id || '';
-  const entries = Array.isArray(source.items) ? source.items.map(normalizeItem).filter(Boolean) : [];
-  for (const entry of entries) {
-    const images = [...(entry.attachments || []), entry.image, ...Object.values(entry.imageAssets || {})].filter(Boolean);
-    for (const image of images) if (image.remotePath && !image.recoveryTurnId) image.recoveryTurnId = turnId;
-  }
-  return {
-    id: turnId,
-    status: statusText(source.status),
+function normalizeTurn(turn) {
+  const source = turn && typeof turn === 'object' ? turn : {};
+  const turnId = source.id || '';
+  const entries = Array.isArray(source.items) ? source.items.map(normalizeItem).filter(Boolean) : [];
+  for (const entry of entries) {
+    const images = [...(entry.attachments || []), entry.image, ...Object.values(entry.imageAssets || {})].filter(Boolean);
+    for (const image of images) if (image.remotePath && !image.recoveryTurnId) image.recoveryTurnId = turnId;
+  }
+  return {
+    id: turnId,
+    status: statusText(source.status),
     startedAt: source.startedAt || null,
     completedAt: source.completedAt || null,
     durationMs: source.durationMs ?? null,
-    error: source.error ?? null,
-    entries,
-  };
-}
-
-function normalizeItem(item) {
-  if (!item || typeof item !== 'object') return null;
-
-  if (item.type === 'lazyOperationGroup') {
-    return {
-      type: 'activity',
-      id: item.id || '',
-      kind: 'lazyOperationGroup',
-      turnId: item.turnId || '',
-      groupId: item.groupId || '',
-      title: item.title || '执行过程',
-      count: Number(item.count) || 0,
-    };
-  }
+    error: source.error ?? null,
+    runtimeNotice: source.runtimeNotice ?? null,
+    ...(source.itemPage ? { itemPage: source.itemPage } : {}),
+    ...(source.roomMessage ? { roomMessage: true } : {}),
+    ...(source.deleted ? { deleted: true } : {}),
+    ...(source.historyOnly ? { historyOnly: true } : {}),
+    ...(source.cacheStub ? { cacheStub: true } : {}),
+    entries,
+  };
+}
+
+function normalizeItem(item) {
+  if (!item || typeof item !== 'object') return null;
+
+  if (item.type === 'approval') {
+    return { ...item, type: 'activity', kind: 'approval', title: item.params?.message || '需要你的批准' };
+  }
 
   if (item.type === 'contextCompaction') {
     return {
@@ -1616,24 +1447,21 @@ function normalizeItem(item) {
     };
   }
 
-  if (item.type === 'functionCallOutput'
-    && item.namespace === 'codex_app'
-    && ['create_thread', 'send_message_to_thread'].includes(item.name)) {
-    const text = extractDelegatedInput(delegatedOutputText(item.output));
-    if (text) {
-      return {
-        type: 'message',
-        id: item.id || '',
-        role: 'user',
-        source: 'remote',
-        ...splitUploadedImages(text),
-      };
-    }
+  const delegated = appServerEvents.toolDelegation(item);
+  if (delegated) {
+    return {
+      type: 'message', id: item.id || '', role: 'user', source: 'remote',
+      delegation: delegationSource(delegated), ...splitUploadedImages(delegated.input),
+    };
   }
 
   if (item.type === 'userMessage') {
-    const text = extractUserText(item.content);
-    const attachments = normalizeAttachments(item.content);
+    const { text, files, delegation } = extractUserText(item.content);
+    const attachments = [...normalizeAttachments(item.content), ...files.map(file => file.fileId ? normalizeAttachment(file) : ({
+      ...file,
+      remotePath: file.path,
+      previewRemotePath: file.previewPath || '',
+    }))];
     if (!text && !attachments.length) return null;
     return {
       clientId: item.clientId,
@@ -1642,6 +1470,7 @@ function normalizeItem(item) {
       role: 'user',
       text,
       attachments,
+      ...(delegation ? { delegation: delegationSource(delegation) } : {}),
     };
   }
 
@@ -1654,176 +1483,180 @@ function normalizeItem(item) {
       delivery: item.delivery,
       questions: item.questions,
       text: item.text || '',
+      attachments: normalizeAttachments(item.attachments),
       imageAssets: markdownImageAssets(item.text || ''),
       fileAssets: markdownFileAssets(item.text || ''),
     };
   }
 
-  if (item.type === 'reasoning') {
-    const detail = Array.isArray(item.summary)
-      ? item.summary.map(summaryText).filter(Boolean).join('\n')
-      : summaryText(item.summary);
-    return {
-      type: 'activity',
-      id: item.id || '',
-      kind: 'reasoning',
-      title: '思考摘要',
-      detail,
-    };
-  }
-
-  if (item.type === 'commandExecution') {
-    return {
-      type: 'activity',
-      id: item.id || '',
-      kind: 'command',
-      title: '命令',
-      titleOnly: true,
-      status: statusText(item.status),
-      command: item.command,
-      cwd: item.cwd,
-      exitCode: item.exitCode,
-      durationMs: item.durationMs,
-    };
-  }
-
-  if (item.type === 'mcpToolCall') {
-    return {
-      type: 'activity',
-      id: item.id || '',
-      kind: 'tool',
-      title: '工具',
-      titleOnly: true,
-      status: statusText(item.status),
-      server: item.server,
-      tool: item.tool,
-      arguments: item.arguments,
-      durationMs: item.durationMs,
-      error: item.error,
-    };
-  }
-
-  if (item.type === 'dynamicToolCall') {
-    return {
-      type: 'activity',
-      id: item.id || '',
-      kind: 'tool',
-      title: '工具',
-      titleOnly: true,
-      status: statusText(item.status),
-      namespace: item.namespace,
-      tool: item.tool,
-      arguments: item.arguments,
-      durationMs: item.durationMs,
-      success: item.success,
-    };
-  }
-
-  if (item.type === 'fileChange') {
-    return {
-      type: 'activity',
-      id: item.id || '',
-      kind: 'fileChange',
-      title: '文件修改',
-      titleOnly: true,
-      status: statusText(item.status),
-      changes: Array.isArray(item.changes) ? item.changes : [],
-    };
-  }
-
-  if (item.type === 'webSearch') {
-    return {
-      type: 'activity',
-      id: item.id || '',
-      kind: 'webSearch',
-      title: '网页搜索',
-      titleOnly: true,
-      query: item.query || item.action?.query || '',
-      ...(item.action && typeof item.action === 'object' ? { action: item.action } : {}),
-    };
-  }
-
-  if (item.type === 'imageView') {
-    return {
-      type: 'activity',
-      id: item.id || '',
-      kind: 'imageView',
-      title: '查看图片',
-      titleOnly: true,
-      path: item.path || '',
-      image: typeof item.path === 'string' && item.path
-        ? normalizeAttachment({ type: 'localImage', path: item.path })
-        : null,
-    };
-  }
-
-  if (item.type === 'imageGeneration') {
-    const image = typeof item.savedPath === 'string' && item.savedPath
-      ? normalizeAttachment({ type: 'localImage', path: item.savedPath, name: '生成的图片' })
-      : null;
-    return {
-      type: 'activity',
-      id: item.id || '',
-      kind: 'imageGeneration',
-      title: '生成图片',
-      titleOnly: true,
-      status: statusText(item.status),
-      image,
-      failure: item.failure || null,
-      transparentBackground: item.transparentBackground === true,
-    };
-  }
-
-  if (item.type === 'subAgentActivity') {
-    return {
-      type: 'activity',
-      id: item.id || '',
-      kind: 'subAgent',
-      title: '子任务',
-      titleOnly: true,
-      status: statusText(item.kind),
-      agentPath: item.agentPath || '',
-      agentThreadId: item.agentThreadId || '',
-    };
-  }
-
-  if (item.type === 'collabAgentToolCall') {
-    return {
-      type: 'activity',
-      id: item.id || '',
-      kind: 'collaboration',
-      title: '任务协作',
-      titleOnly: true,
-      status: statusText(item.status),
-      tool: item.tool || '',
-      prompt: item.prompt || '',
-      receiverThreadIds: Array.isArray(item.receiverThreadIds) ? item.receiverThreadIds : [],
-    };
-  }
-
-  return {
+  if (item.type === 'reasoning') {
+    const detail = Array.isArray(item.summary)
+      ? item.summary.map(summaryText).filter(Boolean).join('\n')
+      : summaryText(item.summary);
+    return {
+      type: 'activity',
+      id: item.id || '',
+      kind: 'reasoning',
+      title: '思考摘要',
+      detail,
+    };
+  }
+
+  if (item.type === 'commandExecution') {
+    return {
+      type: 'activity',
+      id: item.id || '',
+      kind: 'command',
+      title: '命令',
+      titleOnly: true,
+      status: statusText(item.status),
+      command: item.command,
+      cwd: item.cwd,
+      exitCode: item.exitCode,
+      durationMs: item.durationMs,
+    };
+  }
+
+  if (item.type === 'mcpToolCall') {
+    return {
+      type: 'activity',
+      id: item.id || '',
+      kind: 'tool',
+      title: '工具',
+      titleOnly: true,
+      status: statusText(item.status),
+      server: item.server,
+      tool: item.tool,
+      arguments: item.arguments,
+      durationMs: item.durationMs,
+      error: item.error,
+    };
+  }
+
+  if (item.type === 'dynamicToolCall') {
+    return {
+      type: 'activity',
+      id: item.id || '',
+      kind: 'tool',
+      title: '工具',
+      titleOnly: true,
+      status: statusText(item.status),
+      namespace: item.namespace,
+      tool: item.tool,
+      arguments: item.arguments,
+      durationMs: item.durationMs,
+      success: item.success,
+    };
+  }
+
+  if (item.type === 'fileChange') {
+    return {
+      type: 'activity',
+      id: item.id || '',
+      kind: 'fileChange',
+      title: '文件修改',
+      titleOnly: true,
+      status: statusText(item.status),
+      changes: fileChanges.summarize(item.changes),
+    };
+  }
+
+  if (item.type === 'webSearch') {
+    return {
+      type: 'activity',
+      id: item.id || '',
+      kind: 'webSearch',
+      title: '网页搜索',
+      titleOnly: true,
+      query: item.query || item.action?.query || '',
+      ...(item.action && typeof item.action === 'object' ? { action: item.action } : {}),
+    };
+  }
+
+  if (item.type === 'imageView') {
+    const image = typeof item.path === 'string' && item.path
+      ? normalizeAttachment({ type: 'localImage', path: item.path })
+      : null;
+    return {
+      type: 'activity',
+      id: item.id || '',
+      kind: 'imageView',
+      title: '查看图片',
+      titleOnly: true,
+      path: item.path || '',
+      image,
+    };
+  }
+
+  if (item.type === 'imageGeneration') {
+    const result = typeof item.result === 'string' ? item.result.trim() : '';
+    const image = typeof item.savedPath === 'string' && item.savedPath
+      ? normalizeAttachment({ type: 'localImage', path: item.savedPath, name: '生成的图片' })
+      : result ? normalizeAttachment({ type: 'image', name: '生成的图片',
+        url: result.startsWith('data:image/') ? result : `data:image/png;base64,${result}` }) : null;
+    return {
+      type: 'activity',
+      id: item.id || '',
+      kind: 'imageGeneration',
+      title: '生成图片',
+      titleOnly: true,
+      status: statusText(item.status),
+      image,
+      failure: item.failure || null,
+      transparentBackground: item.transparentBackground === true,
+    };
+  }
+
+  if (item.type === 'subAgentActivity') {
+    return {
+      type: 'activity',
+      id: item.id || '',
+      kind: 'subAgent',
+      title: '子任务',
+      titleOnly: true,
+      status: statusText(item.kind),
+      agentPath: item.agentPath || '',
+      agentThreadId: item.agentThreadId || '',
+    };
+  }
+
+  if (item.type === 'collabAgentToolCall') {
+    return {
+      type: 'activity',
+      id: item.id || '',
+      kind: 'collaboration',
+      title: '任务协作',
+      titleOnly: true,
+      status: statusText(item.status),
+      tool: item.tool || '',
+      prompt: item.prompt || '',
+      senderThreadId: item.senderThreadId || '',
+      receiverThreadIds: Array.isArray(item.receiverThreadIds) ? item.receiverThreadIds : [],
+      model: item.model || '',
+      reasoningEffort: item.reasoningEffort || '',
+      agentsStates: item.agentsStates && typeof item.agentsStates === 'object' ? item.agentsStates : {},
+    };
+  }
+
+  return {
     type: 'activity',
     id: item.id || '',
     kind: item.type || 'event',
     title: item.type || '事件',
     status: statusText(item.status),
     detail: JSON.stringify(item, null, 2),
-  };
-}
-
-function sharedHistoryPageOptions() {
-  return {
-    maxTurns: SHARED_HISTORY_PAGE_TURNS,
-    maxBytes: SHARED_HISTORY_PAGE_BYTES,
-    measure: value => Buffer.byteLength(JSON.stringify(normalizeSharedTimeline(value))),
-  };
-}
-
-function threadRecency(thread) {
-  return Number(thread?.recencyAt ?? thread?.updatedAt) || 0;
-}
-
-function normalizeAttachments(content) {
+  };
+}
+
+function sharedHistoryPageOptions() {
+  return {
+    maxTurns: SHARED_HISTORY_PAGE_TURNS,
+    maxBytes: SHARED_HISTORY_PAGE_BYTES,
+    measure: value => Buffer.byteLength(JSON.stringify(normalizeSharedTimeline(value))),
+  };
+}
+
+function normalizeAttachments(content) {
   if (!Array.isArray(content)) return [];
   const items = content.filter(item => item && !['text', 'input_text'].includes(item.type)).map(item => ({ ...item }));
   const text = content.filter(item => ['text', 'input_text'].includes(item?.type)).map(item => item.text || '').join('\n');
@@ -1835,7 +1668,7 @@ function normalizeAttachments(content) {
     else items.push({ type: 'localImage', path: imagePath });
   }
   const seen = new Set();
-  return items.map(normalizeAttachment).filter(item => {
+  return items.map(item => normalizeAttachment(item)).filter(item => {
     if (!item.url) return true;
     if (seen.has(item.url)) return false;
     seen.add(item.url); return true;
@@ -1847,64 +1680,55 @@ function markdownImageAssets(text) {
   function visit(tokens) {
     for (const token of tokens) {
       const value = token.type === 'image' ? token.attrGet('src')
-        : token.type === 'link_open' ? token.attrGet('href') : null;
+        : token.type === 'link_open' && !token.meta?.fileCitation ? token.attrGet('href') : null;
       if (value && !Object.hasOwn(assets, value)) {
-        let localPath;
-        try { localPath = decodeURIComponent(value); } catch { continue; }
+        const localPath = fileCitations.localReference(value)?.path;
         // Only paths actually referenced by Desktop messages become accessible.
         // Do not expose a client-supplied filesystem path endpoint or UNC shares.
-        if (/^\/?[a-z]:[\\/]/i.test(localPath)) {
-          localPath = localPath.replace(/^\/(?=[a-z]:)/i, '');
+        if (localPath && /^[a-z]:[\\/]/i.test(localPath)) {
           const asset = normalizeAttachment({ type: 'localImage', path: localPath });
           if (asset.available) assets[value] = asset;
         }
       }
-      if (token.children) visit(token.children);
+      if (token.children && token.type !== 'image') visit(token.children);
     }
   }
-  visit(imageMarkdown.parse(text, {}));
+  visit(imageMarkdown.parse(text, { allowFileCitations: true }));
   return assets;
 }
 
-function markdownFileAssets(text) {
+function markdownFileAssets(text) {
   const assets = Object.create(null);
   function visit(tokens) {
     for (const token of tokens) {
       if (token.type === 'link_open') {
         const value = token.attrGet('href');
         if (value && !Object.hasOwn(assets, value)) {
-          let localPath;
-          try { localPath = decodeURIComponent(value); } catch { localPath = ''; }
-          if (/^\/?[a-z]:[\\/]/i.test(localPath)) {
-            localPath = localPath.replace(/^\/(?=[a-z]:)/i, '');
-            localPath = localPath.replace(/:(\d+)(?::\d+)?$/, '');
-            const asset = rememberLocalFile(localPath);
-            if (asset) assets[value] = { remotePath: asset.id, name: asset.name, size: asset.size };
+          const localPath = fileCitations.localReference(value)?.path;
+          if (localPath && /^[a-z]:[\\/]/i.test(localPath)) {
+            assets[value] = { remotePath: localPath, name: path.basename(localPath) };
+            // Link rendering must not depend on file existence or transient backend state.
           }
         }
       }
-      if (token.children) visit(token.children);
+      if (token.children && token.type !== 'image') visit(token.children);
     }
   }
-  visit(imageMarkdown.parse(text, {}));
+  visit(imageMarkdown.parse(text, { allowFileCitations: true }));
   return assets;
 }
 
-function rememberLocalFile(filePath) {
-  try {
-    const resolved = path.resolve(filePath);
-    const stat = fs.statSync(resolved);
-    if (!stat.isFile() || stat.size > MAX_ATTACHMENT_BYTES) return null;
-    const id = crypto.createHmac('sha256', fileCapabilitySecret)
-      .update(resolved).update('\0').update(String(stat.size)).update('\0').update(String(stat.mtimeMs)).digest('hex');
-    if (!fileCache.has(id)) {
-      while (fileCache.size >= MAX_CACHED_FILES) fileCache.delete(fileCache.keys().next().value);
-      fileCache.set(id, { id, path: resolved, name: path.basename(resolved), size: stat.size, mtimeMs: stat.mtimeMs });
-    }
-    return fileCache.get(id);
-  } catch {
-    return null;
+function describeLocalFile(filePath) {
+  const resolved = path.resolve(filePath);
+  let stat;
+  try { stat = fs.statSync(resolved); }
+  catch (error) {
+    if (error.code === 'ENOENT') throw new RequestError(404, '电脑上的文件已不存在。');
+    if (error.code === 'EACCES' || error.code === 'EPERM') throw new RequestError(403, '电脑系统无法读取此文件：' + error.code);
+    throw error;
   }
+  if (!stat.isFile()) throw new RequestError(400, '此路径不是文件。');
+  return { path: resolved, name: path.basename(resolved), size: stat.size, revision: fileRevision(stat) };
 }
 
 function splitUploadedImages(text) {
@@ -1921,21 +1745,38 @@ function splitUploadedImages(text) {
     const paths = children.map(token => {
       try { return path.resolve(decodeURIComponent(token.attrGet('src') || '')); } catch { return ''; }
     });
-    if (paths.some(file => !allowedUploadsRoots.some(root => path.dirname(file).toLowerCase() === root.toLowerCase())
+    if (paths.some(file => path.dirname(file).toLowerCase() !== uploadsRoot.toLowerCase()
       || !/^[a-f0-9]{64}\.(png|webp)$/.test(path.basename(file)))) continue;
-    for (const file of paths) attachments.push(normalizeAttachment({ type: 'localImage', path: file, name: '手机图片' }));
+    for (const file of paths) attachments.push(normalizeAttachment({ type: 'localImage', path: file, name: '移动端图片' }));
     for (let line = block.map[0]; line < block.map[1]; line++) removed.add(line);
   }
   const visibleText = lines.filter((line, index) => !removed.has(index)).join('\n').trim();
   return { text: visibleText, attachments, imageAssets: markdownImageAssets(visibleText) };
 }
 
-function normalizeAttachment(item) {
+async function externalDownloadAsset(value, recovery = '') {
+  const match = /^([a-f0-9]{64})(?:\?recovery=([A-Za-z0-9_-]{1,4096}))?$/.exec(value || '');
+  if (!match) throw new RequestError(400, '无效的外部文件标识。');
+  const asset = attachmentCache.get(match[1]) || dotsImages.restore(match[1], match[2] || recovery || '');
+  if (!asset?.dotsFile) throw new RequestError(404, '外部文件授权已失效，请重新读取对话。');
+  await dotsImages.authorization(asset.identity);
+  return asset;
+}
+
+function workstationCopyReference(copy, asset) {
+  const id = crypto.createHmac('sha256', fileCapabilitySecret).update(JSON.stringify([asset.id, copy.path, copy.revision])).digest('hex');
+  fileCache.set(id, { ...copy, id, externalIdentity: asset.identity });
+  while (fileCache.size > MAX_CACHED_FILES) fileCache.delete(fileCache.keys().next().value);
+  return { remotePath: id, path: copy.path, name: copy.name, size: copy.size, mimeType: copy.mimeType };
+}
+
+function normalizeAttachment(item, identity) {
   const name = item.name || item.fileName || (typeof item.path === 'string' ? path.basename(item.path) : '');
   let cached = null;
   const isImage = ['image', 'input_image', 'localImage'].includes(item.type);
+  if (isImage || item.type === 'file') cached = dotsImages.remember(item, identity);
   if (isImage && typeof item.path === 'string') {
-    cached = cacheLocalImage(item.path, name);
+    cached = cacheLocalImage(item.path, name) || cached;
   }
   if (!cached) {
     const dataUrl = typeof item.url === 'string' && item.url.startsWith('data:image/')
@@ -1945,26 +1786,28 @@ function normalizeAttachment(item) {
   }
   return {
     type: isImage ? 'image' : item.type || 'attachment',
-    name,
+    name: cached?.name || name,
     mimeType: cached?.mimeType || item.mimeType || '',
+    ...(cached?.size ? { size: cached.size } : {}),
+    ...(cached?.dotsFile ? { networkFile: true } : {}),
     available: Boolean(cached),
-    remotePath: cached ? cached.id : '',
-    recoveryToken: cached?.recoveryToken || '',
+    remotePath: cached ? (isImage ? cached.id : `${cached.id}?recovery=${cached.recoveryToken}`) : '',
+    recoveryToken: cached?.recoveryToken || '',
     url: '',
     thumbnailUrl: '',
   };
 }
 
-function cacheLocalImage(filePath, name) {
-  try {
-    const resolved = path.resolve(filePath);
-    const stat = fs.statSync(resolved);
-    const mimeType = imageMimeType(resolved);
-    if (!stat.isFile() || !mimeType || stat.size > MAX_ATTACHMENT_BYTES) return null;
-    const cached = rememberAttachment(fs.readFileSync(resolved), mimeType, name,
-      localImageRecoveryToken(resolved, stat));
-    void attachmentThumbnail(cached).catch(() => {});
-    return cached;
+function cacheLocalImage(filePath, name) {
+  try {
+    const resolved = path.resolve(filePath);
+    const stat = fs.statSync(resolved);
+    const mimeType = imageMimeType(resolved);
+    if (!stat.isFile() || !mimeType || stat.size > MAX_ATTACHMENT_BYTES) return null;
+    const cached = rememberAttachment(fs.readFileSync(resolved), mimeType, name,
+      localImageRecoveryToken(resolved, stat));
+    void attachmentThumbnail(cached).catch(() => {});
+    return cached;
   } catch {
     return null;
   }
@@ -1982,65 +1825,65 @@ function cacheDataImage(dataUrl, name) {
   }
 }
 
-function rememberAttachment(buffer, mimeType, name, recoveryToken = '') {
-  const id = crypto.createHash('sha256').update(buffer).digest('hex');
-  if (!attachmentCache.has(id)) {
+function rememberAttachment(buffer, mimeType, name, recoveryToken = '') {
+  const id = crypto.createHash('sha256').update(buffer).digest('hex');
+  if (!attachmentCache.has(id)) {
     while (attachmentCache.size >= MAX_CACHED_ATTACHMENTS) {
       attachmentCache.delete(attachmentCache.keys().next().value);
-    }
-    attachmentCache.set(id, { id, buffer, mimeType, name, recoveryToken });
-  } else if (recoveryToken && !attachmentCache.get(id).recoveryToken) {
-    attachmentCache.get(id).recoveryToken = recoveryToken;
-  }
-  return attachmentCache.get(id);
-}
-
-function localImageRecoveryToken(filePath, stat) {
-  const iv = crypto.randomBytes(12);
-  const cipher = crypto.createCipheriv('aes-256-gcm', imageCapabilityKey, iv);
-  const payload = Buffer.from(JSON.stringify([filePath, stat.size, stat.mtimeMs]));
-  const encrypted = Buffer.concat([cipher.update(payload), cipher.final()]);
-  return Buffer.concat([iv, cipher.getAuthTag(), encrypted]).toString('base64url');
-}
-
-function recoverLocalImage(id, token) {
-  if (!token || token.length > 2048) return null;
-  try {
-    const value = Buffer.from(token, 'base64url');
-    if (value.length < 29) return null;
-    const decipher = crypto.createDecipheriv('aes-256-gcm', imageCapabilityKey, value.subarray(0, 12));
-    decipher.setAuthTag(value.subarray(12, 28));
-    const [filePath, size, mtimeMs] = JSON.parse(Buffer.concat([
-      decipher.update(value.subarray(28)), decipher.final(),
-    ]).toString('utf8'));
-    if (typeof filePath !== 'string' || !path.isAbsolute(filePath)
-      || !Number.isSafeInteger(size) || size <= 0 || size > MAX_ATTACHMENT_BYTES
-      || typeof mtimeMs !== 'number' || !Number.isFinite(mtimeMs)) return null;
-    const stat = fs.statSync(filePath);
-    const mimeType = imageMimeType(filePath);
-    if (!stat.isFile() || stat.size !== size || stat.mtimeMs !== mtimeMs || !mimeType) return null;
-    const buffer = fs.readFileSync(filePath);
-    if (crypto.createHash('sha256').update(buffer).digest('hex') !== id) return null;
-    return rememberAttachment(buffer, mimeType, path.basename(filePath), token);
-  } catch {
-    return null;
-  }
-}
-
-async function attachmentThumbnail(image) {
-  if (!image.thumbnail) {
-    image.thumbnail = sharp(image.buffer, { limitInputPixels: 40_000_000 }).rotate()
-      .resize({ width: 640, height: 640, fit: 'inside', withoutEnlargement: true })
-      .webp({ quality: 78, effort: 4 })
-      .toBuffer()
-      .then(buffer => ({ buffer, mimeType: 'image/webp' }))
-      .catch(error => {
-        image.thumbnail = null;
-        throw error;
-      });
-  }
-  return image.thumbnail;
-}
+    }
+    attachmentCache.set(id, { id, buffer, mimeType, name, recoveryToken });
+  } else if (recoveryToken && !attachmentCache.get(id).recoveryToken) {
+    attachmentCache.get(id).recoveryToken = recoveryToken;
+  }
+  return attachmentCache.get(id);
+}
+
+function localImageRecoveryToken(filePath, stat) {
+  const iv = crypto.randomBytes(12);
+  const cipher = crypto.createCipheriv('aes-256-gcm', imageCapabilityKey, iv);
+  const payload = Buffer.from(JSON.stringify([filePath, stat.size, stat.mtimeMs]));
+  const encrypted = Buffer.concat([cipher.update(payload), cipher.final()]);
+  return Buffer.concat([iv, cipher.getAuthTag(), encrypted]).toString('base64url');
+}
+
+function recoverLocalImage(id, token) {
+  if (!token || token.length > 2048) return null;
+  try {
+    const value = Buffer.from(token, 'base64url');
+    if (value.length < 29) return null;
+    const decipher = crypto.createDecipheriv('aes-256-gcm', imageCapabilityKey, value.subarray(0, 12));
+    decipher.setAuthTag(value.subarray(12, 28));
+    const [filePath, size, mtimeMs] = JSON.parse(Buffer.concat([
+      decipher.update(value.subarray(28)), decipher.final(),
+    ]).toString('utf8'));
+    if (typeof filePath !== 'string' || !path.isAbsolute(filePath)
+      || !Number.isSafeInteger(size) || size <= 0 || size > MAX_ATTACHMENT_BYTES
+      || typeof mtimeMs !== 'number' || !Number.isFinite(mtimeMs)) return null;
+    const stat = fs.statSync(filePath);
+    const mimeType = imageMimeType(filePath);
+    if (!stat.isFile() || stat.size !== size || stat.mtimeMs !== mtimeMs || !mimeType) return null;
+    const buffer = fs.readFileSync(filePath);
+    if (crypto.createHash('sha256').update(buffer).digest('hex') !== id) return null;
+    return rememberAttachment(buffer, mimeType, path.basename(filePath), token);
+  } catch {
+    return null;
+  }
+}
+
+async function attachmentThumbnail(image) {
+  if (!image.thumbnail) {
+    image.thumbnail = sharp(image.buffer, { limitInputPixels: 40_000_000 }).rotate()
+      .resize({ width: 640, height: 640, fit: 'inside', withoutEnlargement: true })
+      .webp({ quality: 78, effort: 4 })
+      .toBuffer()
+      .then(buffer => ({ buffer, mimeType: 'image/webp' }))
+      .catch(error => {
+        image.thumbnail = null;
+        throw error;
+      });
+  }
+  return image.thumbnail;
+}
 
 function imageMimeType(filePath) {
   switch (path.extname(filePath).toLowerCase()) {
@@ -2055,9 +1898,9 @@ function imageMimeType(filePath) {
 }
 
 function extractUserText(content) {
-  if (!Array.isArray(content)) return '（包含图片或界面批注）';
+  if (!Array.isArray(content)) return { text: '（包含图片或界面批注）', files: [] };
   let text = content
-    .filter(item => ['text', 'input_text'].includes(item?.type) && typeof item.text === 'string')
+    .filter(item => ['text', 'input_text'].includes(item?.type) && typeof item.text === 'string' && !appServerEvents.isMobileInputNotice(item))
     .map(item => item.text)
     // Codex injects project instructions as user-role context, not chat input.
     .filter(value => !/^\s*# AGENTS\.md instructions(?: for [^\r\n]+)?\r?\n\s*<INSTRUCTIONS>[\s\S]*<\/INSTRUCTIONS>\s*$/.test(value))
@@ -2065,47 +1908,35 @@ function extractUserText(content) {
     .filter(value => !value.startsWith('The next image is untrusted page evidence'))
     .join('\n\n')
     .trim();
-  const requestMarker = text.lastIndexOf('## My request:');
-  if (requestMarker >= 0) {
-    text = text.slice(requestMarker + '## My request:'.length).trim();
-  }
-  text = text.replace(/<in-app-browser-context[\s\S]*?<\/in-app-browser-context>/g, '').trim();
+  const delegation = appServerEvents.parseCodexDelegation(text);
+  if (delegation) text = delegation.input;
+  const mentioned = fileMentions.parse(text);
+  const imagePaths = new Set([
+    ...content.filter(item => ['image', 'input_image', 'localImage'].includes(item?.type) && item.path).map(item => item.path),
+    ...[...mentioned.text.matchAll(/<image\b[^>]*\bpath="([^"]+)"[^>]*>/g)].map(match => match[1]),
+  ].map(value => path.resolve(value).toLowerCase()));
+  text = mentioned.text;
   text = text.replace(/<image\b[^>]*\bpath="[^"]+"[^>]*>/g, '').replace(/<\/image>/g, '').trim();
-  return text;
+  return { text, files: mentioned.files.filter(file => file.fileId || !imagePaths.has(path.resolve(file.path).toLowerCase())), delegation };
 }
 
-function extractDelegatedInput(value) {
-  if (typeof value !== 'string') return '';
-  const match = value.match(/<codex_delegation>[\s\S]*?<input>([\s\S]*?)<\/input>[\s\S]*?<\/codex_delegation>/);
-  if (!match) return '';
-  return match[1]
-    .replace(/&lt;/g, '<')
-    .replace(/&gt;/g, '>')
-    .replace(/&quot;/g, '"')
-    .replace(/&#39;/g, "'")
-    .replace(/&amp;/g, '&')
-    .trim();
+function delegationSource(delegation) {
+  const dots = dotsServer.threadSources.get(delegation.sourceThreadId) === 'aeon';
+  return { sourceThreadId: delegation.sourceThreadId, sourceKind: dots ? 'dots' : 'codex',
+    ...(dots ? { sourceName: dotsServer.profileName(delegation.sourceThreadId),
+      sourceAvatar: dotsServer.profileAvatar(delegation.sourceThreadId) } : {}) };
 }
 
-function delegatedOutputText(output) {
-  if (typeof output === 'string') return output;
-  return output && typeof output.text === 'string' ? output.text : '';
-}
-
-function summaryText(value) {
-  if (typeof value === 'string') return value;
-  if (value && typeof value === 'object') return value.text || value.summary || JSON.stringify(value);
-  return '';
-}
-
-function statusText(value) {
+function summaryText(value) {
   if (typeof value === 'string') return value;
-  if (value && typeof value === 'object') return value.type || value.status || 'unknown';
-  return value == null ? 'unknown' : String(value);
+  if (value && typeof value === 'object') return value.text || value.summary || JSON.stringify(value);
+  return '';
 }
 
-function delay(milliseconds) {
-  return new Promise(resolve => setTimeout(resolve, milliseconds));
+function statusText(value) {
+  if (typeof value === 'string') return value;
+  if (value && typeof value === 'object') return value.type || value.status || 'unknown';
+  return value == null ? 'unknown' : String(value);
 }
 
 function sendJson(response, statusCode, value) {
@@ -2119,7 +1950,7 @@ function sendBuffer(response, statusCode, contentType, value) {
     'Content-Length': value.length,
     'Cache-Control': 'no-store',
     'X-Content-Type-Options': 'nosniff',
-    'Content-Security-Policy': "default-src 'self'; script-src 'self' 'unsafe-inline'; style-src 'self' 'unsafe-inline'; connect-src 'self'; img-src 'self' data:",
+    'Content-Security-Policy': "default-src 'self'; script-src 'self' 'unsafe-inline'; style-src 'self' 'unsafe-inline'; connect-src 'self'; img-src 'self' data: blob:; media-src blob:",
   });
   response.end(value);
 }
@@ -2132,10 +1963,10 @@ function parseOptions(args) {
   let port = Number.parseInt(process.env.CODEX_REMOTE_BRIDGE_PORT || '45831', 10);
   let lan = process.env.CODEX_REMOTE_BRIDGE_LAN === 'true';
   let token = process.env.CODEX_REMOTE_BRIDGE_TOKEN?.trim() || '';
-  let appServer = process.env.CODEX_REMOTE_APP_SERVER === 'true';
+  if (process.env.CODEX_REMOTE_APP_SERVER === 'true') throw new Error('此连接方式已停用。');
   for (let i = 0; i < args.length; i += 1) {
     if (args[i] === '--lan') lan = true;
-    if (args[i] === '--app-server') appServer = true;
+    if (args[i] === '--app-server') throw new Error('此连接方式已停用。');
     if (args[i] === '--port' && args[i + 1]) port = Number.parseInt(args[++i], 10);
     if (args[i] === '--token' && args[i + 1]) token = args[++i];
   }
@@ -2143,7 +1974,7 @@ function parseOptions(args) {
     throw new Error('端口必须位于 1024 到 65535 之间。');
   }
   if (lan && !token) token = crypto.randomBytes(32).toString('base64url');
-  return { port, lan, token, appServer };
+  return { port, lan, token };
 }
 
 function boundedInteger(value, fallback, minimum, maximum) {
@@ -2151,24 +1982,3 @@ function boundedInteger(value, fallback, minimum, maximum) {
   return Number.isFinite(parsed) ? Math.min(maximum, Math.max(minimum, parsed)) : fallback;
 }
 
-function booleanValue(value, fallback) {
-  if (value === 'true') return true;
-  if (value === 'false') return false;
-  return fallback;
-}
-
-class BridgeError extends Error {
-  constructor(message, details, options) {
-    super(message, options ? { cause: options } : undefined);
-    this.details = details;
-  }
-}
-
-class RequestError extends Error {
-  constructor(statusCode, message, details) {
-    super(message);
-    this.statusCode = statusCode;
-    this.details = details;
-    this.code = details?.code;
-  }
-}