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

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,30 +29,23 @@ 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);
     add('skill', state.managed ? 'ok' : 'warning', state.managed ? '本包管理的 Skill 已安装。'
       : state.installed ? '存在同名自定义 Skill，本包不会覆盖。' : '可执行 relax skill-install 安装 Skill。');
   });
-  add('firewall', 'warning', '手机连通性未验证。首次启动请允许记录的 Node 在受信任的专用网络通信；若曾拒绝，可在 Windows 安全中心的防火墙“允许应用通过防火墙”中检查该 Node。不要关闭整个防火墙。');
+  add('firewall', 'warning', '移动端连通性未验证。首次启动请允许记录的 Node 在受信任的专用网络通信；若曾拒绝，可在 Windows 安全中心的防火墙“允许应用通过防火墙”中检查该 Node。不要关闭整个防火墙。');
   return { ready: !checks.some(item => item.status === 'error'), lanAccess: 'unverified', checks };
 }

package/dist/src/service-install.mjs

@@ -22,8 +22,6 @@ export async function installService(source, target, executable, stateRoot, hook
   if (!fs.existsSync(path.join(source, 'dist/bin/codex-remote.mjs'))) throw new Error('缺少发布构建；源码目录请先执行 npm run build。');
   if (!fs.existsSync(path.join(source, 'node_modules'))) throw new Error('缺少包依赖，请重新安装完整 npm 包。');
   const parent = path.dirname(target);
-  const legacyUploadsRoots = readRecord(path.join(target, 'installation.json'))?.legacyUploadsRoots || [];
-  if (fs.existsSync(path.join(source, 'src/server.mjs'))) legacyUploadsRoots.push(path.join(source, 'uploads'));
   fs.mkdirSync(parent, { recursive: true });
   const stage = path.join(parent, `service-stage-${randomUUID()}`);
   const backup = path.join(parent, `service-backup-${randomUUID()}`);
@@ -34,8 +32,7 @@ export async function installService(source, target, executable, stateRoot, hook
     }
     await exec(executable, [path.join(stage, 'dist/bin/codex-remote.mjs'), '--help'], { windowsHide: true });
     await exec(executable, ['-e', 'const r=require("node:module").createRequire(process.argv[1]); r("sharp"); r("qrcode"); r("ws"); r("node-datachannel");', path.join(stage, 'package.json')], { windowsHide: true });
-    writeRecord(path.join(stage, 'installation.json'), { installedAt: new Date().toISOString(), source, nodeExecutable: executable, stateRoot,
-      legacyUploadsRoots: [...new Set(legacyUploadsRoots)],
+    writeRecord(path.join(stage, 'installation.json'), { installedAt: new Date().toISOString(), source, nodeExecutable: executable, stateRoot,
       version: readRecord(path.join(source, 'package.json')).version });
     const previous = fs.existsSync(target);
     let previousMoved = false, activated = false;

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,8 +32,9 @@ 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。');
-    this.url = url;
+    if (address.protocol !== 'ws:' || address.hostname !== '127.0.0.1') throw new Error('Codex 内核必须使用本机回环 WebSocket。');
+    this.url = url;
+    this.serverVersion = '';
     this.epoch = randomUUID();
     this.sequence = 0;
     this.pending = new Map();
@@ -38,9 +42,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() {
@@ -52,8 +57,9 @@ export class SharedAppServer extends EventEmitter {
 
   async open() {
     const socket = new WebSocket(this.url, { handshakeTimeout: 5000 });
-    this.socket = socket;
-    this.ready = false;
+    this.socket = socket;
+    this.ready = false;
+    this.serverVersion = '';
     this.serverRequests.reset(randomUUID());
     socket.on('message', bytes => {
       let message;
@@ -72,15 +78,17 @@ export class SharedAppServer extends EventEmitter {
       }
       else pending.resolve(message.result);
     });
-    socket.on('close', () => {
-      this.ready = false;
+    socket.on('close', () => {
+      this.ready = false;
+      this.serverVersion = '';
       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();
@@ -92,7 +100,10 @@ export class SharedAppServer extends EventEmitter {
     socket.on('error', () => {}); // open/request reports the connection error to the caller.
     await new Promise((resolve, reject) => { socket.once('open', resolve); socket.once('error', reject); });
     try {
-      await this.request('initialize', { clientInfo: { name: 'codex_remote_shared', version: '1.0.0' }, capabilities: { experimentalApi: true } });
+      const initialized = await this.request('initialize', { clientInfo: { name: 'codex_remote_shared', version: '1.0.0' }, capabilities: { experimentalApi: true } });
+      // The first user-agent product reports the running server build, not the
+      // selected executable that may only take effect after a future restart.
+      this.serverVersion = String(initialized?.userAgent || '').match(/^[^\s/]+\/([^\s]+)/)?.[1] || '';
       socket.send(JSON.stringify({ method: 'initialized' }));
       this.ready = true;
       this.usageCache.read(() => this.request('account/rateLimits/read')).catch(error => this.emit('usage-error', error));
@@ -123,19 +134,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 +172,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);
-    if (turn) {
-      const sequence = ++record.sequence;
+    }
+    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 +196,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,29 +210,37 @@ 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;
+      }
+      const id = randomUUID(), expires = Date.now() + syncTokenTtlMs;
       record.tokens.set(id, { sequence: record.sequence, expires });
       this.scheduleCleanup(threadId, slot);
       return { thread: record.thread, nextCursor: record.nextCursor,
@@ -250,14 +277,15 @@ 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);
     }).catch(error => this.emit('subscription-error', error));
   }
 
-  async acquire(threadId, requested) {
+  async acquire(threadId, requested) {
     const slot = this.slot(threadId);
     let record = this.threads.get(threadId), token;
     if (record && requested?.epoch === this.epoch && requested.id && Number.isSafeInteger(requested.after)) {
@@ -266,7 +294,7 @@ export class SharedAppServer extends EventEmitter {
     }
     let snapshot = false, catchup;
     if (!record || !token) {
-      const fresh = await this.timeline(threadId);
+      const fresh = await this.timeline(threadId);
       record = this.threads.get(threadId); token = record.tokens.get(fresh.sync.id);
       requested = { id: fresh.sync.id, epoch: fresh.sync.epoch, after: fresh.sync.seq };
       snapshot = true;
@@ -291,12 +319,140 @@ 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 subAgentItems = visibleItems.filter(isSubAgentItem);
+      const detailItems = visibleItems.filter(item => !isSubAgentItem(item));
+      if (detailItems.length) {
+        const groupId = `g${groups.size + 1}`;
+        groups.set(groupId, detailItems);
+        skeleton.push({ type: 'lazyOperationGroup', id: `${turn.id}:${groupId}`,
+          turnId: turn.id, groupId,
+          operationTypes: [...new Set(detailItems.map(item => item.type).filter(Boolean))] });
+      }
+      skeleton.push(...subAgentItems);
+    };
+    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 +510,7 @@ export class SharedAppServer extends EventEmitter {
 
   close() { this.socket?.close(); }
 }
+
+function isSubAgentItem(item) {
+  return item?.type === 'collabAgentToolCall' || item?.type === 'subAgentActivity';
+}

package/dist/src/shared-catalog.mjs

@@ -1,31 +1,17 @@
 import events from '../shared/app-server-events.cjs';
 
 export function sharedThreadProjectId(thread, projects) {
-  if (thread.projectId) return thread.projectId;
-  const local = thread.environments?.find(environment => environment.environmentId === 'local');
-  if (local && Array.isArray(local.runtimeWorkspaceRoots)) {
-    for (const root of local.runtimeWorkspaceRoots) {
-      const projectId = events.threadProjectId({ cwd: root }, projects);
-      if (projectId) return projectId;
-    }
-    return null;
-  }
-  // Unloaded Desktop history omits environments and often has no persisted project ID.
-  return events.threadProjectId({ cwd: thread.cwd }, projects);
+  return events.catalogThreadProjectId(thread, 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 +26,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 };
   }
 }