@walkhi/code-relax 0.1.0-beta.1 → 0.1.0-beta.10

package/dist/src/service-doctor.mjs

@@ -2,11 +2,10 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { readRecord } from './service-lifecycle.mjs';
 import { inspectSkill } from './skill-install.mjs';
-import { readManagedEnvironment } from './platform/windows/user-environment.mjs';
-import { managedAppServerUrl } from './managed-app-server.mjs';
 
 export async function doctor({ paths, host, service, skillTarget }) {
   const checks = [];
+  let installedVersion;
   const add = (id, status, message) => checks.push({ id, status, message });
   const check = async (id, task) => {
     try { await task(); } catch (error) { add(id, 'error', error.message); }
@@ -15,16 +14,12 @@ export async function doctor({ paths, host, service, skillTarget }) {
     const record = readRecord(path.join(paths.serviceRoot, 'installation.json'));
     if (!record || !fs.existsSync(path.join(paths.serviceRoot, 'dist/bin/codex-remote.mjs'))) throw Error('尚未完整部署服务，请重新安装 Code Relax。');
     if (!record.nodeExecutable || !fs.existsSync(record.nodeExecutable)) throw Error('记录的 Node 已失效，请用可用的 Node 重新安装 Code Relax。');
-    add('installation', 'ok', `服务 ${record.version}；Node：${record.nodeExecutable}`);
+    installedVersion = record.version;
+    add('installation', 'ok', `已安装版本：${record.version}；Node：${record.nodeExecutable}`);
   });
-  let sharedUrl;
-  await check('shared-service', async () => {
-    sharedUrl = await host.sharedServiceUrl();
-    add('shared-service', 'ok', sharedUrl ? '完整控制连接可用。' : '当前使用基础控制。');
-  });
-  await check('desktop', async () => {
-    await host.desktopEnvironment(readRecord(path.join(paths.stateRoot, 'bridge-startup-context.json')), sharedUrl);
-    add('desktop', 'ok', 'Desktop 来源上下文和工具管道已定位；实际任务操作尚未验证。');
+  await check('bridge-runtime', async () => {
+    await host.bridgeEnvironment();
+    add('bridge-runtime', 'ok', 'Bridge 启动环境已就绪；实际任务操作尚未验证。');
   });
   await check('network', async () => {
     const address = await host.lanAddress();
@@ -34,24 +29,17 @@ export async function doctor({ paths, host, service, skillTarget }) {
   await check('service', async () => {
     const state = await service.status();
     add('service', state.running ? 'ok' : 'warning', state.running
-      ? `本机服务正常：${state.mode}，端口 ${state.port}` : '服务未就绪；安装后执行 relax start。');
+      ? `本机服务正常：${state.mode}，端口 ${state.port}，运行版本：${state.version || '未知'}` : '服务未就绪；安装后执行 relax start。');
+    if (state.running && installedVersion && state.version !== installedVersion) add('service-version', 'warning', state.version
+      ? `已安装版本 ${installedVersion}，但当前运行版本为 ${state.version}；请重新执行安装或重启工作站服务。`
+      : `已安装版本 ${installedVersion}，但当前运行 Bridge 未报告版本，可能仍是旧进程；请重新执行安装或重启工作站服务。`);
     if (state.running) add('managed-app-server', state.managedAppServer?.state === 'ready' ? 'ok' : 'error',
       state.managedAppServer?.state === 'ready' ? '受管 app-server 已就绪。'
         : state.managedAppServer?.error || '受管 app-server 尚未就绪。');
     if (state.managedAppServer?.updatePending) add('managed-app-server-update', 'warning',
-      'Codex Desktop 已提供新版 CLI；当前 app-server 会继续完成任务，并在下次进程自然重启或重新登录 Windows 后采用新版。');
-  });
-  await check('desktop-environment', async () => {
-    const environment = await readManagedEnvironment();
-    if (environment.forceCliUser === '1' || environment.forceCliMachine === '1') {
-      add('desktop-environment', 'error', 'CODEX_APP_SERVER_FORCE_CLI=1 会阻止 Desktop 使用受管 app-server。');
-    } else if (environment.userValue === managedAppServerUrl) {
-      add('desktop-environment', 'ok', `Desktop 后续启动地址：${managedAppServerUrl}`);
-    } else {
-      add('desktop-environment', 'warning', environment.userValue
-        ? `用户配置了其他 app-server 地址：${environment.userValue}`
-        : '尚未配置 Desktop 后续启动地址；请重新执行 setup。');
-    }
+      '已选择另一版本 CLI；当前 app-server 继续完成任务，下次内核启动时采用选定版本。');
+    if (state.managedAppServer?.launcherRestartRequired) add('managed-app-server-launcher', 'warning',
+      '安装文件已经更新，但当前 app-server 仍由旧启动链创建；隐藏控制台等运行时修复尚未生效，请执行 relax setup 或重启 Windows。');
   });
   await check('skill', async () => {
     const state = inspectSkill(skillTarget);

package/dist/src/service-lifecycle.mjs

@@ -23,7 +23,6 @@ export function lifecycle({ stateRoot, host }) {
   fs.mkdirSync(stateRoot, { recursive: true });
   const sessionPath = path.join(stateRoot, 'bridge-session.json');
   const configPath = path.join(stateRoot, 'bridge-config.json');
-  const contextPath = path.join(stateRoot, 'bridge-startup-context.json');
   const scriptPath = fileURLToPath(new URL('./server.mjs', import.meta.url));
 
   async function alive(session) {
@@ -56,12 +55,12 @@ export function lifecycle({ stateRoot, host }) {
     const running = await alive(session);
     const result = running ? await health(session) : null;
     return { running: running && result?.status === 'ok', processRunning: running, pid: session?.pid,
-      port: session?.port, mode: result?.transportMode, execution: result?.execution,
+      port: session?.port, mode: result?.transportMode, version: result?.version, execution: result?.execution,
       managedAppServer: result?.managedAppServer, desktop: result?.desktop,
       desktopRestartRecommended: result?.desktopRestartRecommended === true,
       resident: result?.resident === true };
   }
-  async function pair() {
+  async function pair() {
     const session = readRecord(sessionPath);
     const connection = await alive(session) ? await health(session) : null;
     if (connection?.status !== 'ok' || !session.lan) {
@@ -76,15 +75,17 @@ export function lifecycle({ stateRoot, host }) {
       execution: connection.execution, managedAppServer: connection.managedAppServer, desktop: connection.desktop,
       desktopRestartRecommended: connection.desktopRestartRecommended === true, accessUrl: session.accessUrl,
       qrPath: path.join(stateRoot, 'connection-qr.png') };
-  }
+  }
+  async function restartManagedAppServer() {
+    const session = readRecord(sessionPath);
+    if (!await alive(session)) throw new Error('Bridge 尚未运行，无法迁移受管 app-server。');
+    return controlRequest(session, 'POST', 'restart-managed-app-server');
+  }
   async function start() {
     let session = readRecord(sessionPath);
     if (await alive(session)) {
       const result = await health(session);
       if (session.scriptPath === scriptPath && session.lan && result?.status === 'ok' && result.resident) {
-        const context = readRecord(contextPath) || {};
-        const sourceThreadId = process.env.CODEX_THREAD_ID || process.env.CODEX_SESSION_ID || context.sourceThreadId;
-        writeRecord(contextPath, { sourceThreadId });
         await controlRequest(session, 'POST', 'refresh-execution');
         return pair();
       }
@@ -97,9 +98,8 @@ export function lifecycle({ stateRoot, host }) {
       throw new Error('bridge-config.json 中端口或 Token 无效；不会自动重置凭据。');
     }
     const address = await host.lanAddress() || '127.0.0.1';
-    const { executable, environment } = await host.desktopEnvironment(readRecord(contextPath), '');
-    writeRecord(configPath, config);
-    writeRecord(contextPath, { sourceThreadId: environment.CODEX_THREAD_ID || environment.CODEX_SESSION_ID });
+    const { executable, environment } = await host.bridgeEnvironment();
+    writeRecord(configPath, config);
     const instanceId = randomUUID();
     const controlSecret = randomBytes(32).toString('base64url');
     const readyPath = path.join(stateRoot, `bridge-ready-${instanceId}.json`);
@@ -126,5 +126,5 @@ export function lifecycle({ stateRoot, host }) {
       throw error;
     } finally { fs.rmSync(readyPath, { force: true }); }
   }
-  return { start, pair, status, stop };
-}
+  return { start, pair, status, stop, restartManagedAppServer };
+}

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

@@ -6,6 +6,9 @@ import serverRequests from '../shared/server-requests.cjs';
 
 const syncTokenTtlMs = 30_000;
 const syncBufferMaxBytes = 8 * 1024 * 1024;
+const historyPageMaxTurns = 8;
+const historyPageMaxBytes = 500 * 1024;
+const turnItemPageSize = 50;
 const writerConflictMessages = ['already has an active writer', 'already has a live local writer'];
 
 export class ThreadWriterConflictError extends Error {
@@ -29,7 +32,7 @@ export class SharedAppServer extends EventEmitter {
   constructor(url) {
     super();
     const address = new URL(url);
-    if (address.protocol !== 'ws:' || address.hostname !== '127.0.0.1') throw new Error('完整控制必须使用本机回环 WebSocket。');
+    if (address.protocol !== 'ws:' || address.hostname !== '127.0.0.1') throw new Error('Codex 内核必须使用本机回环 WebSocket。');
     this.url = url;
     this.epoch = randomUUID();
     this.sequence = 0;
@@ -38,9 +41,10 @@ export class SharedAppServer extends EventEmitter {
     this.threads = new Map();
     this.contexts = new Map();
     this.settingsNotifications = new Map();
-    this.permissionOptions = new events.PermissionOptionsCache();
-    this.subscriptions = new Map();
-    this.usageCache = new events.UsageCache(value => this.emit('usage', value));
+    this.permissionOptions = new events.PermissionOptionsCache();
+    this.subscriptions = new Map();
+    this.operationGroups = new Map();
+    this.usageCache = new events.UsageCache(value => this.emit('usage', value));
   }
 
   async connect() {
@@ -76,11 +80,12 @@ export class SharedAppServer extends EventEmitter {
       this.ready = false;
       for (const pending of this.pending.values()) {
         clearTimeout(pending.timer);
-        pending.reject(new Error('完整控制连接断开；发送结果可能未确认，请检查对话后再操作。'));
+        pending.reject(new Error('Codex 内核连接断开；发送结果可能未确认，请检查对话后再操作。'));
       }
-      this.pending.clear();
-      this.serverRequests.reset(randomUUID());
-      this.threads.clear();
+      this.pending.clear();
+      this.serverRequests.reset(randomUUID());
+      this.threads.clear();
+      this.operationGroups.clear();
       for (const slot of this.subscriptions.values()) clearTimeout(slot.expiry);
       this.subscriptions.clear();
       this.contexts.clear();
@@ -123,19 +128,21 @@ export class SharedAppServer extends EventEmitter {
     await this.connect();
     this.requireWritable(args.threadId);
     // Reading the live thread checks this service owns it without resume changing settings.
-    const { thread } = await this.request('thread/read', { threadId: args.threadId, includeTurns: false });
-    const status = typeof thread.status === 'string' ? thread.status : thread.status?.type;
-    if (status === 'active') {
-      const live = await this.request('thread/read', { threadId: args.threadId, includeTurns: true });
-      const active = live.thread.turns?.findLast(turn => turn.status === 'inProgress');
-      if (!active) throw new Error('活动轮次已变化，请刷新后再发送。');
+    const { thread } = await this.request('thread/read', { threadId: args.threadId, includeTurns: false });
+    const status = typeof thread.status === 'string' ? thread.status : thread.status?.type;
+    if (status === 'active') {
+      const page = await this.request('thread/turns/list', {
+        threadId: args.threadId, limit: 1, sortDirection: 'desc', itemsView: 'summary',
+      });
+      const active = page.data?.[0];
+      if (active?.status !== 'inProgress') throw new Error('活动轮次已变化，请刷新后再发送。');
       return this.request('turn/steer', { threadId: args.threadId, expectedTurnId: active.id, input: args.input, ...(args.clientUserMessageId ? { clientUserMessageId: args.clientUserMessageId } : {}) });
     }
     return this.request('turn/start', args);
   }
 
   respondApproval(threadId, body) {
-    if (!this.ready || this.socket?.readyState !== WebSocket.OPEN) throw new Error('完整控制未连接');
+    if (!this.ready || this.socket?.readyState !== WebSocket.OPEN) throw new Error('Codex 内核未就绪');
     this.requireWritable(threadId);
     return this.serverRequests.respond(threadId, body, message => new Promise((resolve, reject) => {
       this.socket.send(JSON.stringify(message), error => error ? reject(error) : resolve());
@@ -159,14 +166,20 @@ export class SharedAppServer extends EventEmitter {
     if (method === 'thread/tokenUsage/updated') {
       this.contexts.set(id, { ...this.contexts.get(id), tokenUsage: params.tokenUsage });
       return;
-    }
-    const record = this.threads.get(id);
-    if (!record) return;
-    const turn = events.applyNotification(record.thread, method, params);
+    }
+    const record = this.threads.get(id);
+    if (!record) return;
+    const current = params.turn?.id ? record.thread.turns?.find(turn => turn.id === params.turn.id) : null;
+    const groupedHistory = current?.items?.some(item => item?.type === 'lazyOperationGroup');
+    const appliedParams = groupedHistory && method === 'turn/completed' && Array.isArray(params.turn?.items)
+      ? { ...params, turn: { ...params.turn,
+        items: params.turn.items.filter(item => ['userMessage', 'agentMessage'].includes(item?.type)) } }
+      : params;
+    const turn = events.applyNotification(record.thread, method, appliedParams);
     if (turn) {
       const sequence = ++record.sequence;
       record.changes.set(turn.id, { sequence, turn });
-      record.changeBytes += Buffer.byteLength(JSON.stringify({ method, params }));
+      record.changeBytes += Buffer.byteLength(JSON.stringify({ method, params: appliedParams }));
       if (record.changeBytes > syncBufferMaxBytes) {
         record.recoverAfter = sequence;
         record.changes.clear(); record.changeBytes = 0;
@@ -177,7 +190,7 @@ export class SharedAppServer extends EventEmitter {
     if (method === 'turn/completed') record.thread.turns = record.thread.turns.slice(-10);
   }
 
-  async timeline(threadId) {
+  async timeline(threadId, pageOptions = {}) {
     await this.connect();
     const slot = this.slot(threadId);
     const task = slot.tail.then(async () => {
@@ -191,26 +204,34 @@ export class SharedAppServer extends EventEmitter {
         let result;
         try {
           result = await this.request('thread/resume', { threadId, excludeTurns: true,
-            initialTurnsPage: { limit: 10, sortDirection: 'desc', itemsView: 'full' } });
+            initialTurnsPage: { limit: 1, sortDirection: 'desc', itemsView: 'summary' } });
         } catch (error) {
           if (!isThreadWriterConflict(error)) throw error;
-          const read = await this.request('thread/read', { threadId, includeTurns: true });
-          const turns = Array.isArray(read.thread?.turns) ? read.thread.turns.slice(-10) : [];
+          const [read, page] = await Promise.all([
+            this.request('thread/read', { threadId, includeTurns: false }),
+            this.request('thread/turns/list', {
+              threadId, limit: historyPageMaxTurns, sortDirection: 'desc', itemsView: 'summary',
+            }),
+          ]);
+          const compact = await Promise.all([...(page.data || [])].reverse().map(turn => this.compactTurn(threadId, turn)));
+          const turns = this.fitTurns({ thread: read.thread }, compact, pageOptions);
           const thread = { ...read.thread, turns, readOnly: true,
             readOnlyReason: '该对话正在另一个 Codex 实例中使用。' };
-          record = { thread, nextCursor: null, sequence: 0, recoverAfter: 0,
+          record = { thread, nextCursor: page.nextCursor ?? null, sequence: 0, recoverAfter: 0,
             changes: new Map(), changeBytes: 0, tokens: new Map(), readOnly: true };
           this.threads.set(threadId, record);
           result = null;
         }
         if (result) {
-          if (!Array.isArray(result.initialTurnsPage?.data)) throw new Error('完整控制未返回分页历史。');
-          const thread = { ...result.thread, turns: [...result.initialTurnsPage.data].reverse() };
+          if (!Array.isArray(result.initialTurnsPage?.data)) throw new Error('Codex 内核未返回分页历史。');
+          const compact = await Promise.all([...result.initialTurnsPage.data].reverse().map(turn => this.compactTurn(threadId, turn)));
+          const thread = { ...result.thread, turns: compact };
           record = { thread, nextCursor: result.initialTurnsPage.nextCursor ?? null, sequence: 0,
             recoverAfter: 0, changes: new Map(), changeBytes: 0, tokens: new Map() };
           this.threads.set(threadId, record);
           this.contexts.set(threadId, { ...this.contexts.get(threadId), model: result.model, thinking: result.reasoningEffort, serviceTier: result.serviceTier ?? null,
             cwd: result.cwd, ...events.permissionState(result) });
+          await this.extendHistoryRecord(threadId, record, pageOptions);
         }
       }
       const id = randomUUID(), expires = Date.now() + syncTokenTtlMs;
@@ -250,7 +271,8 @@ export class SharedAppServer extends EventEmitter {
     if (record?.tokens.size) { this.scheduleCleanup(threadId, slot); return; }
     slot.tail = slot.tail.then(async () => {
       if (slot.users || this.threads.get(threadId)?.tokens.size) return;
-      this.threads.delete(threadId); this.contexts.delete(threadId); this.permissionOptions.delete(threadId);
+      this.threads.delete(threadId); this.contexts.delete(threadId); this.permissionOptions.delete(threadId);
+      this.operationGroups.delete(threadId);
       this.subscriptions.delete(threadId); clearTimeout(slot.expiry);
       if (this.ready && !record?.readOnly) await this.request('thread/unsubscribe', { threadId });
       this.serverRequests.forget(threadId);
@@ -291,12 +313,135 @@ export class SharedAppServer extends EventEmitter {
       snapshot, catchup, release };
   }
 
-  async history(threadId, cursor) {
-    await this.connect();
-    if (!cursor) throw new Error('缺少历史分页游标。');
-    const result = await this.request('thread/turns/list', { threadId, cursor, limit: 10, sortDirection: 'desc', itemsView: 'full' });
-    return { thread: { id: threadId, turns: [...result.data].reverse() }, nextCursor: result.nextCursor ?? null };
-  }
+  pageSettings(options = {}) {
+    return {
+      maxTurns: Math.max(1, Math.min(historyPageMaxTurns, Number(options.maxTurns) || historyPageMaxTurns)),
+      maxBytes: Math.max(1, Number(options.maxBytes) || historyPageMaxBytes),
+      measure: typeof options.measure === 'function' ? options.measure : value => Buffer.byteLength(JSON.stringify(value)),
+    };
+  }
+
+  async compactTurn(threadId, turn) {
+    const compact = events.compactTurn(turn);
+    if (!turn?.id) return compact;
+    const batches = [];
+    let cursor;
+    do {
+      const page = await this.request('thread/items/list', {
+        threadId, turnId: turn.id, ...(cursor ? { cursor } : {}),
+        limit: 100, sortDirection: 'desc',
+      });
+      if (!Array.isArray(page.data)) throw new Error('Codex 内核未返回单轮条目索引。');
+      batches.push(page.data.map(entry => events.compactItem(entry.item)));
+      cursor = page.nextCursor ?? null;
+    } while (cursor);
+    const items = batches.reverse().flatMap(batch => batch.reverse());
+    const groups = new Map(), skeleton = [];
+    let operationItems = [];
+    const flushOperations = () => {
+      if (!operationItems.length) return;
+      const visibleItems = operationItems.filter(item => item?.type !== 'reasoning');
+      operationItems = [];
+      if (!visibleItems.length) return;
+      const groupId = `g${groups.size + 1}`;
+      const outline = operationOutline(visibleItems, false);
+      groups.set(groupId, visibleItems);
+      skeleton.push({ type: 'lazyOperationGroup', id: `${turn.id}:${groupId}`,
+        turnId: turn.id, groupId, title: outline.title, count: visibleItems.length });
+    };
+    for (const item of items) {
+      if (['userMessage', 'agentMessage', 'imageGeneration'].includes(item?.type)) {
+        flushOperations();
+        skeleton.push(item);
+      } else operationItems.push(item);
+    }
+    flushOperations();
+    let threadGroups = this.operationGroups.get(threadId);
+    if (!threadGroups) { threadGroups = new Map(); this.operationGroups.set(threadId, threadGroups); }
+    threadGroups.set(turn.id, groups);
+    return { ...compact, items: skeleton };
+  }
+
+  async operationGroupItems(threadId, turnId, groupId, offset) {
+    await this.connect();
+    const items = this.operationGroups.get(threadId)?.get(turnId)?.get(groupId);
+    if (!items) throw new Error('操作组已失效，请重新打开对话。');
+    const start = Math.max(0, Number(offset) || 0);
+    const pageItems = items.slice(start, start + turnItemPageSize);
+    const nextOffset = start + pageItems.length < items.length ? start + pageItems.length : null;
+    return { turnId, groupId, items: pageItems, nextOffset, total: items.length };
+  }
+
+  async turnContext(threadId, turnId) {
+    await this.connect();
+    if (!threadId || !turnId) throw new Error('缺少图片所属的对话或轮次。');
+    return this.compactTurn(threadId, { id: turnId });
+  }
+
+  fitTurns(base, turns, options = {}) {
+    const settings = this.pageSettings(options), accepted = [];
+    let firstOversized = false;
+    for (let index = turns.length - 1; index >= 0 && accepted.length < settings.maxTurns; index--) {
+      const candidate = [turns[index], ...accepted];
+      const candidateBytes = settings.measure({ ...base, thread: { ...base.thread, turns: candidate } });
+      if (accepted.length >= 2 && candidateBytes > settings.maxBytes) break;
+      accepted.unshift(turns[index]);
+      if (accepted.length === 1) firstOversized = candidateBytes > settings.maxBytes;
+      if (firstOversized || (accepted.length >= 2 && candidateBytes > settings.maxBytes)) break;
+    }
+    return accepted;
+  }
+
+  async extendHistoryRecord(threadId, record, options = {}) {
+    const settings = this.pageSettings(options);
+    if (!record.nextCursor || !record.thread.turns.length) return;
+    const firstOversized = settings.measure({ thread: record.thread, nextCursor: record.nextCursor }) > settings.maxBytes;
+    if (firstOversized) return;
+    while (record.nextCursor && record.thread.turns.length < settings.maxTurns) {
+      const cursor = record.nextCursor;
+      const page = await this.request('thread/turns/list', {
+        threadId, cursor, limit: 1, sortDirection: 'desc', itemsView: 'summary',
+      });
+      if (!Array.isArray(page.data) || !page.data.length) {
+        record.nextCursor = page.nextCursor ?? null;
+        break;
+      }
+      const candidate = [await this.compactTurn(threadId, page.data[0]), ...record.thread.turns];
+      const value = { thread: { ...record.thread, turns: candidate }, nextCursor: page.nextCursor ?? null };
+      if (record.thread.turns.length >= 2 && settings.measure(value) > settings.maxBytes) break;
+      record.thread.turns = candidate;
+      record.nextCursor = page.nextCursor ?? null;
+      if (record.thread.turns.length >= 2 && settings.measure(value) > settings.maxBytes) break;
+    }
+  }
+
+  async history(threadId, cursor, options = {}) {
+    await this.connect();
+    if (!cursor) throw new Error('缺少历史分页游标。');
+    const settings = this.pageSettings(options), turns = [];
+    let firstOversized = false;
+    let nextCursor = cursor;
+    while (nextCursor && turns.length < settings.maxTurns) {
+      const pageCursor = nextCursor;
+      const page = await this.request('thread/turns/list', {
+        threadId, cursor: pageCursor, limit: 1, sortDirection: 'desc', itemsView: 'summary',
+      });
+      if (!Array.isArray(page.data) || !page.data.length) {
+        nextCursor = page.nextCursor ?? null;
+        break;
+      }
+      const compact = await this.compactTurn(threadId, page.data[0]);
+      const candidate = [compact, ...turns];
+      const value = { thread: { id: threadId, turns: candidate }, nextCursor: page.nextCursor ?? null };
+      const candidateBytes = settings.measure(value);
+      if (turns.length >= 2 && candidateBytes > settings.maxBytes) break;
+      turns.unshift(compact);
+      nextCursor = page.nextCursor ?? null;
+      if (turns.length === 1) firstOversized = candidateBytes > settings.maxBytes;
+      if (firstOversized || (turns.length >= 2 && candidateBytes > settings.maxBytes)) break;
+    }
+    return { thread: { id: threadId, turns }, nextCursor };
+  }
 
   async interrupt(threadId, turnId) {
     await this.connect();
@@ -354,3 +499,16 @@ export class SharedAppServer extends EventEmitter {
 
   close() { this.socket?.close(); }
 }
+
+function operationOutline(items, hasMore) {
+  const types = new Set(items.map(item => item?.type));
+  const parts = [];
+  if (types.has('fileChange')) parts.push('编辑了文件');
+  if (types.has('commandExecution')) parts.push('运行了命令');
+  if (types.has('mcpToolCall') || types.has('dynamicToolCall')) parts.push('调用了工具');
+  if (types.has('webSearch')) parts.push('搜索了网页');
+  if (types.has('imageView')) parts.push('查看了图像');
+  if (types.has('collabAgentToolCall') || types.has('subAgentActivity')) parts.push('处理了子任务');
+  const available = hasMore || items.some(item => item && !['userMessage', 'agentMessage'].includes(item.type));
+  return { available, title: parts.length ? `${parts.join(' · ')}${hasMore ? '等' : ''}` : '执行过程' };
+}

package/dist/src/shared-catalog.mjs

@@ -14,18 +14,14 @@ export function sharedThreadProjectId(thread, projects) {
   return events.threadProjectId({ cwd: thread.cwd }, projects);
 }
 
-// Native IDs remain stable when optional Desktop presentation data arrives.
+// Mobile catalog order comes entirely from app-server authority, independent of Desktop UI state.
 export class SharedCatalog {
-  constructor(server, desktop) { this.server = server; this.desktop = desktop; }
+  constructor(server) { this.server = server; }
 
   async projects() {
     const native = await this.server.projects();
     const projects = native.map(project => ({ projectId: project.id, name: project.name,
       label: project.name, path: project.roots[0]?.path || '', cwd: project.roots[0]?.path || '', hostId: 'local' }));
-    const ordered = this.desktop.snapshot?.projects || [];
-    const key = value => value.replace(/^\\\\\?\\/, '').replaceAll('\\', '/').replace(/\/+$/, '').toLowerCase();
-    const ranks = new Map(ordered.filter(p => p.hostId === 'local').map((p, i) => [key(p.path || ''), i]));
-    projects.sort((a, b) => (ranks.get(key(a.path)) ?? Infinity) - (ranks.get(key(b.path)) ?? Infinity));
     return { projects, native };
   }
 
@@ -40,16 +36,10 @@ export class SharedCatalog {
     const summaries = threads.map(thread => ({ id: thread.id, kind: 'codex', hostId: 'local',
       title: thread.name || thread.preview || '', cwd: thread.cwd,
       projectId: sharedThreadProjectId(thread, native), updatedAt: thread.updatedAt,
+      recencyAt: thread.recencyAt ?? thread.updatedAt,
       status: typeof thread.status === 'string' ? thread.status : thread.status?.type || 'unknown',
       activeFlags: threadActiveFlags(thread.status) }));
-    const listing = this.desktop.snapshot?.listing;
-    const byId = new Map(summaries.map(thread => [thread.id, thread]));
-    const pinnedThreads = (listing?.pinnedThreads || []).filter(t => t.hostId === 'local' && byId.has(t.id)).map(t => byId.get(t.id));
-    const pinned = new Set(pinnedThreads.map(t => t.id));
-    const ranks = new Map((listing?.threads || []).filter(t => t.hostId === 'local').map((t, i) => [t.id, i]));
-    const rest = summaries.filter(t => !pinned.has(t.id));
-    rest.sort((a, b) => (ranks.get(a.id) ?? Infinity) - (ranks.get(b.id) ?? Infinity));
-    return { projects, pinnedThreads, threads: rest };
+    return { projects, pinnedThreads: [], threads: summaries };
   }
 }
 

package/dist/src/shared-recovery.mjs

@@ -8,6 +8,7 @@ import { startBackground } from './background-process.mjs';
 import { desktopHost } from './platform/windows/desktop-host.mjs';
 import * as serviceHost from './platform/windows/service-host.mjs';
 import { launchDesktop, portAvailable } from './desktop-launcher.mjs';
+import { configureManagedEnvironment } from './platform/windows/user-environment.mjs';
 
 const script = fileURLToPath(import.meta.url);
 const recordPath = root => path.join(root, 'shared-recovery.json');
@@ -19,7 +20,7 @@ const recoverySteps = () => [
   ['starting-app-server', '确认 Codex 内核'], ['starting-desktop', '重新打开 Codex'],
   ['checking-execution', '确认手机控制就绪'],
 ].map(([id, label]) => ({ id, label, status: 'pending' }));
-export const recoveryWarning = 'Codex Desktop 需要重新打开，才能接入同一个 Codex 内核。手机完整控制和 Codex 内核会保持运行；旧 Desktop 实例中的任务可能中断，未发送内容请先保存。切换不会清空项目、对话历史、设置或设备授权。';
+export const recoveryWarning = 'Codex Desktop 需要重新打开，才能接入同一个 Codex 内核。手机连接和 Codex 内核会保持运行；旧 Desktop 实例中的任务可能中断，未发送内容请先保存。切换不会清空项目、对话历史、设置或设备授权。';
 
 export async function recoveryStatus(stateRoot, host = desktopHost) {
   const record = readRecord(recordPath(stateRoot));
@@ -40,11 +41,11 @@ export async function recoveryStatus(stateRoot, host = desktopHost) {
 export async function planRecovery(stateRoot, host, available = portAvailable) {
   const info = await host.inspect();
   const action = await host.sharedServiceUrl() ? 'restart' : 'switch';
-  if (!info.desktop || !info.cli) throw new Error('未找到 Codex Desktop 或执行程序，请先在电脑完成安装和登录。');
+  if (!info.desktop) throw new Error('未找到 Codex Desktop；CLI 用户无需执行 Desktop 接入。');
   const record = readRecord(path.join(stateRoot, 'managed-app-server.json')) || readRecord(path.join(stateRoot, 'shared-desktop.json'));
   const actual = record ? await host.process(record.pid) : null;
   if (actual && (!sameProcess(record, actual) || !actual.command?.includes('app-server') || !actual.command.includes('ws://127.0.0.1:45839'))) {
-    throw new Error('完整控制进程身份与记录不符，未结束任何进程。');
+    throw new Error('Codex 内核进程身份与记录不符，未结束任何进程。');
   }
   if (!actual && !await available()) throw new Error('45839 被未识别进程占用，未关闭 Desktop 或结束任何进程。');
   return { desktop: info.desktop, action };
@@ -63,7 +64,7 @@ export async function requestRecovery(stateRoot, { confirmed, operationId = rand
   catch (error) { if (error.code === 'EEXIST') throw new Error('已有恢复操作，请先查看恢复状态。'); throw error; }
   fs.writeFileSync(lock, JSON.stringify({ operationId })); fs.closeSync(lock);
   const record = { operationId, status: 'scheduled', stage: 'prepared', startedAt: new Date().toISOString(),
-    message: '完整控制请求已接受，电脑管理连接保持运行。', steps: recoverySteps(), ...planned };
+    message: 'Codex 连接请求已接受，电脑管理连接保持运行。', steps: recoverySteps(), ...planned };
   try {
     writeRecord(recordPath(stateRoot), record);
     const log = path.join(stateRoot, 'shared-recovery.log');
@@ -99,6 +100,7 @@ export async function runRecovery(stateRoot, operationId, dependencies = {}) {
   try {
     stage('checking');
     const planned = await planRecovery(stateRoot, host, available);
+    await configureManagedEnvironment(stateRoot);
     record = { ...record, ...planned };
     if (fs.existsSync(path.join(stateRoot, 'desktop-launch.lock'))) throw new Error('Desktop 正在启动，未与启动操作并行恢复。');
     stage('stopping-desktop'); await host.closeDesktop(record.desktop);
@@ -109,9 +111,9 @@ export async function runRecovery(stateRoot, operationId, dependencies = {}) {
     await waitFor(async () => {
       const health = await service.status();
       return health.running && health.mode === 'lan-shared' && health.execution?.ready === true;
-    }, '完整控制未就绪；Bridge 和中继管理连接仍保留。');
+    }, 'Codex 内核未就绪；Bridge 和中继管理连接仍保留。');
     record = { ...record, status: 'completed', stage: 'ready', steps: record.steps.map(step => ({ ...step, status: 'completed' })),
-      message: 'Codex Desktop 已接入 Codex 内核；手机完整控制保持就绪，原任务未自动重发。' };
+      message: 'Codex Desktop 已接入 Codex 内核；手机控制保持就绪，原任务未自动重发。' };
   } catch (error) { record = { ...record, status: 'failed', error: error.message,
     steps: record.steps.map(step => ({ ...step, status: step.status === 'running' ? 'failed' : step.status })),
     message: 'Codex Desktop 未完成接入，已停止后续步骤。' }; }

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

@@ -43,7 +43,7 @@ export async function streamSharedThread(response, threadId, client, normalize,
     if (!threadListNotificationMethods.has(method)) return;
     emit('thread-list-changed', { method, threadId: params.threadId || params.thread?.id || '' });
   };
-  const onDisconnected = () => { emit('bridge-error', { error: '完整控制已断开，请重新连接。' }); response.end(); finish(); };
+  const onDisconnected = () => { emit('bridge-error', { error: 'Codex 内核连接已断开，请重新连接。' }); response.end(); finish(); };
   response.once('close', () => { closed = true; finish(); });
   client.on('turn', onTurn); client.on('settings', onSettings); client.on('disconnected', onDisconnected);
   client.on('queue-changed', onQueue);