@walkhi/code-relax 0.1.0-beta.27 → 0.1.0-beta.29

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

@@ -2,6 +2,7 @@ import WebSocket from 'ws';
 import { EventEmitter } from 'node:events';
 import { randomUUID } from 'node:crypto';
 import events from '../shared/app-server-events.cjs';
+import messageDelivery from '../shared/message-delivery.cjs';
 import serverRequests from '../shared/server-requests.cjs';
 
 const syncTokenTtlMs = 30_000;
@@ -56,8 +57,12 @@ export class SharedAppServer extends EventEmitter {
     return this.connecting;
   }
 
+  openSocket() {
+    return new WebSocket(this.url, { handshakeTimeout: 5000 });
+  }
+
   async open() {
-    const socket = new WebSocket(this.url, { handshakeTimeout: 5000 });
+    const socket = await this.openSocket();
     this.socket = socket;
     this.ready = false;
     this.serverVersion = '';
@@ -119,7 +124,8 @@ export class SharedAppServer extends EventEmitter {
     return new Promise((resolve, reject) => {
       const timer = setTimeout(() => {
         this.pending.delete(id);
-        reject(new Error(`${method} 超时；不会自动重发，请先检查对话。`));
+        reject(Object.assign(new Error(`${method} 超时；不会自动重发，请先检查对话。`),
+          { code: 'app_server_request_timeout' }));
       }, 30000);
       this.pending.set(id, { resolve, reject, timer, transform, threadId: params?.threadId });
       this.socket.send(JSON.stringify({ id, method, params }), error => {
@@ -135,23 +141,31 @@ export class SharedAppServer extends EventEmitter {
   }
 
   async send(args) {
-    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 page = await this.request('thread/turns/list', {
-        threadId: args.threadId, limit: 1, sortDirection: 'desc', itemsView: 'notLoaded',
-      });
-      const active = page.data?.[0];
-      if (active?.status !== 'inProgress') throw new Error('活动轮次已变化，请刷新后再发送。');
-      const { turnTrigger, ...source } = events.mobileTurnSource(args.clientUserMessageId, args.responsesapiClientMetadata?.code_relax_input === 'speech_to_text');
-      const result = await this.request('turn/steer', { threadId: args.threadId, expectedTurnId: active.id, input: args.input, ...source, ...(args.clientUserMessageId ? { clientUserMessageId: args.clientUserMessageId } : {}) });
-      return { result, usage: { kind: 'steer', turnId: active.id } };
+    let submitted = false;
+    try {
+      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 page = await this.request('thread/turns/list', {
+          threadId: args.threadId, limit: 1, sortDirection: 'desc', itemsView: 'notLoaded',
+        });
+        const active = page.data?.[0];
+        if (active?.status !== 'inProgress') throw new Error('活动轮次已变化，请刷新后再发送。');
+        const { turnTrigger, ...source } = events.mobileTurnSource(args.clientUserMessageId, args.responsesapiClientMetadata?.code_relax_input === 'speech_to_text');
+        submitted = true;
+        const result = await this.request('turn/steer', { threadId: args.threadId, expectedTurnId: active.id, input: args.input, ...source, ...(args.clientUserMessageId ? { clientUserMessageId: args.clientUserMessageId } : {}) });
+        return { result, usage: { kind: 'steer', turnId: active.id } };
+      }
+      submitted = true;
+      const result = await this.request('turn/start', args);
+      return { result, usage: { kind: 'start', turnId: result?.turn?.id || null } };
+    } catch (error) {
+      if (!submitted || messageDelivery.rejectedBeforeSubmission(error)) error.deliveryUnknown = false;
+      throw error;
     }
-    const result = await this.request('turn/start', args);
-    return { result, usage: { kind: 'start', turnId: result?.turn?.id || null } };
   }
 
   respondApproval(threadId, body) {
@@ -182,8 +196,13 @@ export class SharedAppServer extends EventEmitter {
     }
     const record = this.threads.get(id);
     if (!record) return;
-    const slot = this.subscriptions.get(id);
-    if (!slot?.users && !slot?.readers && !record.tokens.size) {
+    const stub = record.thread.turns?.find(turn => turn.cacheStub && turn.id === (params.turn?.id || params.turnId));
+    if (stub && !['thread/status/changed', 'thread/name/updated'].includes(method)) {
+      record.needsReload = true;
+      this.emit('history-invalidated', id);
+      return;
+    }
+    if (!this.isThreadObserved(id, record)) {
       // Keep task/approval lifecycle metadata, not an invisible growing transcript.
       record.needsReload = true;
       if (params.turn) events.applyNotification(record.thread, method, { ...params, turn: { ...params.turn, items: [] } });
@@ -194,11 +213,14 @@ export class SharedAppServer extends EventEmitter {
       return;
     }
     const current = record.thread.turns?.find(turn => turn.id === (params.turn?.id || params.turnId));
-    if (method === 'item/completed' && current?.itemPage?.olderCursor && !current.items.some(item => item.id === params.item?.id)) return;
-    const appliedParams = (record.hydrating || current?.itemPage?.olderCursor) && method === 'turn/completed' && Array.isArray(params.turn?.items)
+    if (method === 'item/completed' && !record.hydrating && current?.itemPage?.olderCursor && !current.items.some(item => item.id === params.item?.id)) return;
+    const visibleParams = (record.hydrating || current?.itemPage?.olderCursor) && method === 'turn/completed' && Array.isArray(params.turn?.items)
       ? { ...params, turn: { ...params.turn,
         items: params.turn.items.filter(item => current?.items?.some(loaded => loaded.id === item.id)) } }
       : params;
+    const appliedParams = { ...visibleParams,
+      ...(visibleParams.item ? { item: events.compactItem(visibleParams.item) } : {}),
+      ...(visibleParams.turn ? { turn: events.compactTurn(visibleParams.turn) } : {}) };
     const turn = events.applyNotification(record.thread, method, appliedParams);
     if (turn) {
       const sequence = ++record.sequence;
@@ -211,74 +233,105 @@ export class SharedAppServer extends EventEmitter {
       this.emit('turn', { thread: record.thread, turn, sequence,
         immediate: ['turn/completed', 'item/completed'].includes(method) });
     }
-    if (method === 'turn/completed' && record.thread.turns.length > 10) {
-      record.thread.turns = record.thread.turns.slice(-10);
-      // Native cursors are opaque; obtain a matching boundary before the next snapshot.
-      record.historyTrimmed = true;
-    }
+    if (method === 'turn/completed' && record.thread.turns.length > 10) {
+      record.thread.turns = record.thread.turns.slice(-10);
+      // Native cursors are opaque; obtain a matching boundary before the next snapshot.
+      record.historyTrimmed = true;
+    }
     if (['turn/completed', 'thread/status/changed'].includes(method)) this.releaseInactiveThread(id);
   }
 
-  async timeline(threadId, pageOptions = {}) {
+  matchesUpdatedAt(thread, updatedAt) {
+    const status = typeof thread.status === 'string' ? thread.status : thread.status?.type;
+    const latest = thread.turns?.at(-1);
+    return Number(updatedAt) > 0 && status !== 'active' && latest?.status !== 'inProgress'
+      && Math.floor(Number(thread.updatedAt)) === Math.floor(Number(updatedAt));
+  }
+
+  resumeTimeline(threadId, apply) {
+    return this.request('thread/resume', { threadId, excludeTurns: true,
+      initialTurnsPage: { limit: 1, sortDirection: 'desc', itemsView: 'notLoaded' } }, value => {
+      if (!Array.isArray(value.initialTurnsPage?.data)) throw new Error('Codex 内核未返回分页历史。');
+      return apply(value);
+    });
+  }
+
+  initialTurnsPage(_threadId, resumed) { return resumed.initialTurnsPage; }
+
+  async timeline(threadId, pageOptions = {}, knownSync) {
     await this.connect();
     const slot = this.slot(threadId);
     slot.readers++;
     const task = slot.tail.then(async () => {
-      let record = this.threads.get(threadId);
-      // Snapshot refreshes must not reset the sequence or tokens of live subscribers.
-      const previous = record?.readOnly ? null : record;
-      if (record?.readOnly || record?.needsReload) this.contexts.delete(threadId);
-      if (!record || record.readOnly || record.needsReload || record.historyTrimmed) {
-        let result;
+      let record = this.threads.get(threadId), metadataReused = false;
+      // Seconds are the product's cache-update granularity. Active work still
+      // uses the received sequence so an in-progress reply can keep advancing.
+      const knownToken = record?.tokens.get(knownSync?.id);
+      const unchanged = Boolean(!pageOptions.reconcileObserved && record && !record.readOnly && !record.needsReload && !record.hydrating
+        && (this.matchesUpdatedAt(record.thread, knownSync?.updatedAt)
+          || (knownSync?.epoch === this.epoch && Number.isSafeInteger(knownSync.seq)
+            && knownToken && knownToken.expires > Date.now()
+            && knownToken.sequence === knownSync.seq && record.sequence === knownSync.seq)));
+      if (unchanged) {
+        const id = randomUUID();
+        record.tokens.set(id, { sequence: record.sequence, expires: Date.now() + syncTokenTtlMs });
+        this.scheduleCleanup(threadId, slot);
+        return { thread: { ...record.thread, turns: [] }, notModified: true,
+          sync: { id, epoch: this.epoch, seq: record.sequence } };
+      }
+      // Snapshot refreshes must not reset the sequence or tokens of live subscribers.
+      const previous = record?.readOnly ? null : record;
+      if (record?.readOnly || record?.needsReload) this.contexts.delete(threadId);
+      if (pageOptions.reconcileObserved || !record || record.readOnly || record.needsReload || record.historyTrimmed || record.metadataOnly) {
+        let result, snapshot;
         try {
-          result = await this.request('thread/resume', { threadId, excludeTurns: true,
-            initialTurnsPage: { limit: 1, sortDirection: 'desc', itemsView: 'notLoaded' } }, value => {
-            if (!Array.isArray(value.initialTurnsPage?.data)) throw new Error('Codex 内核未返回分页历史。');
-            const retained = new Map((previous?.thread.turns || []).map(turn => [turn.id, turn]));
-            record = { thread: { ...value.thread, turns: [...value.initialTurnsPage.data].reverse().map(turn => ({
-              ...turn, items: retained.get(turn.id)?.items || [],
-              ...(retained.get(turn.id)?.itemPage ? { itemPage: retained.get(turn.id).itemPage } : {}),
-            })) },
-              nextCursor: value.initialTurnsPage.nextCursor ?? null,
-              sequence: previous?.sequence ?? 0, recoverAfter: previous?.recoverAfter ?? 0,
-              changes: previous?.changes ?? new Map(), changeBytes: previous?.changeBytes ?? 0,
-              tokens: previous?.tokens ?? new Map(), hydrating: true };
+          result = await this.resumeTimeline(threadId, value => {
+            const retained = new Map((previous?.thread.turns || []).map(turn => [turn.id, turn]));
+            record = { thread: { ...value.thread, turns: [...value.initialTurnsPage.data].reverse().map(turn => ({
+              ...turn, items: retained.get(turn.id)?.items || [],
+              ...(retained.get(turn.id)?.itemPage ? { itemPage: retained.get(turn.id).itemPage } : {}),
+            })) },
+              nextCursor: value.initialTurnsPage.nextCursor ?? null,
+              sequence: previous?.sequence ?? 0, recoverAfter: previous?.recoverAfter ?? 0,
+              changes: previous?.changes ?? new Map(), changeBytes: previous?.changeBytes ?? 0,
+              tokens: previous?.tokens ?? new Map(), hydrating: true };
             this.threads.set(threadId, record);
+            snapshot = events.beginSnapshot(record.thread);
             return value;
-          });
+          }, pageOptions);
         } catch (error) {
+          snapshot?.close();
           if (!isThreadWriterConflict(error)) throw error;
-          const [read, page] = await Promise.all([
-            this.request('thread/read', { threadId, includeTurns: false }),
-            this.request('thread/turns/list', {
-              threadId, limit: 1, sortDirection: 'desc', itemsView: 'notLoaded',
-            }),
-          ]);
-          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: page.nextCursor ?? null, sequence: 0, recoverAfter: 0,
-            changes: new Map(), changeBytes: 0, tokens: new Map(), readOnly: true };
-          this.threads.set(threadId, record);
+          record = await this.readOnlyRecord(threadId, pageOptions, '该对话正在另一个 Codex 实例中使用。');
           result = null;
         }
-        if (result) {
-          if (!Array.isArray(result.initialTurnsPage?.data)) throw new Error('Codex 内核未返回分页历史。');
-          await Promise.all(result.initialTurnsPage.data.map(turn => this.compactTurn(threadId, turn, null, page => {
-            const index = record.thread.turns.findIndex(current => current.id === turn.id);
-            if (index >= 0) record.thread.turns[index] = { ...page, ...record.thread.turns[index], items: page.items, itemPage: page.itemPage };
-          })));
+        if (result) try {
+          const page = await this.initialTurnsPage(threadId, result);
+          if (!Array.isArray(page?.data)) throw new Error('Codex 内核未返回分页历史。');
+          const live = new Map(record.thread.turns.map(turn => [turn.id, turn]));
+          record.thread.turns = [...page.data].reverse().map(turn => {
+            const current = live.get(turn.id);
+            live.delete(turn.id);
+            return current ? Object.assign(current, { ...turn, ...current }) : { ...turn, items: [] };
+          }).concat([...live.values()]);
+          record.nextCursor = page.nextCursor ?? null;
+          metadataReused = Boolean(!pageOptions.reconcileObserved && !snapshot.changed()
+            && this.matchesUpdatedAt(record.thread, knownSync?.updatedAt));
+          if (metadataReused) {
+            record.metadataOnly = true;
+            record.thread.turns = record.thread.turns.map(turn => ({ ...turn, items: [], cacheStub: true }));
+          } else await Promise.all(page.data.map(turn => this.compactTurn(threadId, turn, null, page => snapshot.merge(page), 20)));
           record.hydrating = false;
           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);
-        }
+        } finally { snapshot?.close(); }
       }
       const id = randomUUID(), expires = Date.now() + syncTokenTtlMs;
       record.tokens.set(id, { sequence: record.sequence, expires });
       this.scheduleCleanup(threadId, slot);
-      return { thread: record.thread, nextCursor: this.historyCursor(threadId, record.thread.turns[0], record.nextCursor),
+      return { thread: metadataReused ? { ...record.thread, turns: [] } : record.thread,
+        ...(metadataReused ? { notModified: true } : {}),
+        nextCursor: this.historyCursor(threadId, record.thread.turns[0], record.nextCursor),
         sync: { id, epoch: this.epoch, seq: record.sequence } };
     }).finally(() => { slot.readers--; });
     slot.tail = task.catch(() => {});
@@ -326,7 +379,7 @@ export class SharedAppServer extends EventEmitter {
       if (slot.users || slot.readers || this.threads.get(threadId)?.tokens.size || this.keepThreadLoaded(threadId, this.threads.get(threadId))) return;
       this.threads.delete(threadId); this.contexts.delete(threadId); this.permissionOptions.delete(threadId);
       this.subscriptions.delete(threadId); clearTimeout(slot.expiry);
-      if (this.ready && !record?.readOnly) await this.request('thread/unsubscribe', { threadId });
+      if (this.ready && !record?.readOnly) await this.unsubscribeThread(threadId);
       this.serverRequests.forget(threadId);
     }).catch(error => this.emit('subscription-error', error));
   }
@@ -353,18 +406,20 @@ export class SharedAppServer extends EventEmitter {
       token = record.tokens.get(requested.id);
       if (!token || token.expires <= Date.now() || token.sequence !== requested.after) token = undefined;
     }
-    let snapshot = false, catchup;
-    if (!record || !token || (record.historyTrimmed && requested.after < record.recoverAfter)) {
-      const fresh = await this.timeline(threadId);
+    let snapshot = false, catchup, confirmed = false;
+    if (!record || !token || record.needsReload
+      || ((record.historyTrimmed || record.metadataOnly) && requested.after < record.recoverAfter)) {
+      const fresh = await this.timeline(threadId, {}, { updatedAt: requested?.updatedAt });
       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;
+      snapshot = fresh.notModified !== true;
+      confirmed = !snapshot;
     }
     slot.users++; record.tokens.delete(requested.id); clearTimeout(slot.expiry);
     const current = record.sequence;
     if (!snapshot && requested.after < record.recoverAfter) snapshot = true;
     if (!snapshot && current > requested.after) {
-      const turns = [...record.changes.values()].filter(change => change.sequence > requested.after)
+      const turns = [...record.changes.values()].filter(change => change.sequence > requested.after && !change.turn.cacheStub)
         .sort((left, right) => record.thread.turns.findIndex(turn => turn.id === left.turn.id)
           - record.thread.turns.findIndex(turn => turn.id === right.turn.id)).map(change => change.turn);
       catchup = { thread: { ...record.thread, turns },
@@ -372,12 +427,17 @@ export class SharedAppServer extends EventEmitter {
     }
     const release = () => {
       slot.users--;
+      // Retain the observed snapshot briefly when switching away. A later check
+      // must match the client's consumed sequence, never just this release time.
+      if (this.threads.get(threadId) === record && !record.readOnly) {
+        record.tokens.set(requested.id, { sequence: record.sequence, expires: Date.now() + syncTokenTtlMs });
+      }
       this.cleanup(threadId, slot);
       return slot.tail;
     };
     return { record: { thread: record.thread, nextCursor: this.historyCursor(threadId, record.thread.turns[0], record.nextCursor),
       sync: { id: requested.id, epoch: this.epoch, seq: current, ...(snapshot ? { reset: true } : {}) } },
-      snapshot, catchup, release };
+      snapshot, catchup, confirmed, release };
   }
 
   pageSettings(options = {}) {
@@ -391,20 +451,43 @@ export class SharedAppServer extends EventEmitter {
   historyCursor(threadId, turn, turnCursor) {
     const itemCursor = turn?.itemPage?.olderCursor;
     if (!itemCursor && !turnCursor) return null;
-    return JSON.stringify({ threadId, epoch: this.epoch, turnId: itemCursor ? turn.id : null,
+    // Upstream history cursors identify stored positions, not this observer.
+    return JSON.stringify({ threadId, turnId: itemCursor ? turn.id : null,
       itemCursor: itemCursor || null, turnCursor: turnCursor || null });
   }
 
-  async compactTurn(threadId, turn, cursor = null, apply) {
+  async compactTurn(threadId, turn, cursor = null, apply, limit = 100) {
     if (!turn?.id) return events.compactTurn(turn);
     return this.request('thread/items/list', {
-      threadId, turnId: turn.id, ...(cursor ? { cursor } : {}), limit: 100, sortDirection: 'desc',
+      threadId, turnId: turn.id, ...(cursor ? { cursor } : {}), limit, sortDirection: 'desc',
     }, page => {
       const result = this.projectItemPage(threadId, turn, cursor, page);
       apply?.(result); return result;
     });
   }
 
+  isThreadObserved(threadId, record) {
+    const slot = this.subscriptions.get(threadId);
+    return Boolean(slot?.users || slot?.readers || record.tokens.size);
+  }
+
+  unsubscribeThread(threadId) { return this.request('thread/unsubscribe', { threadId }); }
+
+  async readOnlyRecord(threadId, pageOptions, reason) {
+    const [read, page] = await Promise.all([
+      this.request('thread/read', { threadId, includeTurns: false }),
+      this.request('thread/turns/list', { threadId, limit: 1, sortDirection: 'desc', itemsView: 'notLoaded' }),
+    ]);
+    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: reason };
+    const 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);
+    this.contexts.set(threadId, { model: thread.model, thinking: thread.reasoningEffort, cwd: thread.cwd });
+    return record;
+  }
+
   projectItemPage(threadId, turn, cursor, page) {
     const compact = events.compactTurn(turn);
     if (!Array.isArray(page.data)) throw new Error('Codex 内核未返回单轮条目索引。');
@@ -441,38 +524,14 @@ export class SharedAppServer extends EventEmitter {
     return accepted;
   }
 
-  async extendHistoryRecord(threadId, record, options = {}) {
-    const settings = this.pageSettings(options);
-    if (!record.nextCursor || !record.thread.turns.length || record.thread.turns[0].itemPage?.olderCursor) 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: 'notLoaded',
-      });
-      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 (candidate[0].itemPage?.olderCursor) break;
-      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('缺少历史分页游标。');
     let position;
     try { position = JSON.parse(cursor); } catch { position = null; }
-    if (position?.threadId !== threadId || position.epoch !== this.epoch) throw Object.assign(new Error('历史游标已失效，需重新核对历史。'), { code: 'history_cursor_expired' });
+    if (position?.threadId !== threadId) throw Object.assign(new Error('历史游标不属于当前对话。'), { code: 'history_cursor_expired' });
     if (position.itemCursor && position.turnId) {
-      const turn = await this.compactTurn(threadId, { id: position.turnId }, position.itemCursor);
+      const turn = await this.compactTurn(threadId, { id: position.turnId }, position.itemCursor, undefined, options.itemLimit ?? 100);
       return { thread: { id: threadId, turns: [turn] },
         nextCursor: this.historyCursor(threadId, turn, position.turnCursor) };
     }
@@ -481,7 +540,7 @@ export class SharedAppServer extends EventEmitter {
     });
     if (!Array.isArray(page.data)) throw new Error('Codex 内核未返回轮次分页。');
     if (page.nextCursor && page.nextCursor === position.turnCursor) throw new Error('轮次分页游标未推进。');
-    const turns = page.data.length ? [await this.compactTurn(threadId, page.data[0])] : [];
+    const turns = page.data.length ? [await this.compactTurn(threadId, page.data[0], null, undefined, options.itemLimit ?? 100)] : [];
     return { thread: { id: threadId, turns }, nextCursor: this.historyCursor(threadId, turns[0], page.nextCursor) };
   }
 
@@ -510,7 +569,7 @@ export class SharedAppServer extends EventEmitter {
   async settings(threadId, model, effort, serviceTier) {
     await this.connect();
     this.requireWritable(threadId);
-    await events.updateSettings((method, params) => this.request(method, params), this.contexts, this.settingsNotifications, threadId, model, effort, serviceTier);
+    await events.updateSettings((method, params) => this.request(method, params), this.contexts, threadId, model, effort, serviceTier);
     return this.context(threadId);
   }
 

package/dist/src/shared-catalog.mjs

@@ -1,40 +1,132 @@
-import events from '../shared/app-server-events.cjs';
-
-export function sharedThreadProjectId(thread, projects) {
-  return events.catalogThreadProjectId(thread, projects);
-}
-
-// Mobile catalog order comes entirely from app-server authority, independent of Desktop UI state.
-export class SharedCatalog {
-  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' }));
-    return { projects, native };
-  }
-
-  async threads(limit, archived = false) {
-    const { projects, native } = await this.projects();
-    const threads = []; let cursor;
-    do {
-      const page = await this.server.request('thread/list', { limit: Math.min(100, limit - threads.length),
-        sortKey: 'recency_at', sortDirection: 'desc', archived, ...(cursor ? { cursor } : {}) });
-      threads.push(...page.data); cursor = page.nextCursor;
-    } while (cursor && threads.length < limit);
-    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) }));
-    return { projects, pinnedThreads: [], threads: summaries };
-  }
-}
-
-function threadActiveFlags(status) {
-  return status && typeof status === 'object' && Array.isArray(status.activeFlags)
-    ? status.activeFlags.filter(flag => typeof flag === 'string')
-    : [];
-}
+import events from '../shared/app-server-events.cjs';
+import { projectSummary } from './project-management.mjs';
+
+export function sharedThreadProjectId(thread, projects) {
+  return events.catalogThreadProjectId(thread, projects);
+}
+
+export function dotsThreadProjectId(thread, projects) {
+  if (thread.projectId && projects.some(project => project.id === thread.projectId)) return thread.projectId;
+  if (thread.environments?.length) {
+    for (const environment of thread.environments) {
+      const roots = Array.isArray(environment.runtimeWorkspaceRoots) ? environment.runtimeWorkspaceRoots : [];
+      for (const root of roots) {
+        if (!root) continue;
+        const projectId = events.threadProjectId({ cwd: root }, projects);
+        if (projectId) return projectId;
+      }
+    }
+    // Display grouping may use the execution directory when workspace roots
+    // do not map to a known project. This never changes the thread's workspace
+    // permissions or its native project assignment.
+    for (const environment of thread.environments) {
+      if (!environment.cwd) continue;
+      const projectId = events.threadProjectId({ cwd: environment.cwd }, projects);
+      if (projectId) return projectId;
+    }
+  }
+  return events.threadProjectId({ cwd: thread.cwd }, projects);
+}
+
+// Mobile catalog order comes entirely from app-server authority, independent of Desktop UI state.
+export class SharedCatalog {
+  constructor(server, dotsServer, dotsChat) {
+    this.server = server; this.dotsServer = dotsServer; this.dotsChat = dotsChat;
+    this.states = new Map();
+    dotsServer?.on('disconnected', () => this.states.clear());
+  }
+
+  threadState(thread, refresh = false) {
+    const client = thread.threadSource === 'aeon' ? this.dotsChat : this.dotsServer;
+    const observed = client?.threads.get(thread.id);
+    if (client?.ready && observed && !observed.needsReload && !observed.hydrating && !observed.refresh) {
+      const current = observed.thread;
+      return { chatRevision: current.chatRevision,
+        ...(thread.threadSource === 'aeon' ? { chatMessageRevision: current.chatMessageRevision, updatedAt: current.updatedAt }
+          : { lastTurnStatus: current.turns.at(-1)?.status || null }) };
+    }
+    const identity = this.dotsServer.profileIdentity;
+    let entry = this.states.get(thread.id);
+    const version = JSON.stringify([thread.updatedAt, thread.status]);
+    if (!entry) { entry = { value: {} }; this.states.set(thread.id, entry); }
+    if (!entry.work && (refresh || entry.version !== version || Date.now() - (entry.at || 0) >= 30000)) {
+      const work = (async () => {
+        try {
+          const value = thread.threadSource === 'aeon'
+            ? await this.dotsChat.latestChatState(thread.id)
+            : await this.dotsServer.latestTaskState(thread.id, refresh || entry.version !== version);
+          if (identity !== this.dotsServer.profileIdentity || this.states.get(thread.id) !== entry) return;
+          const changed = JSON.stringify(entry.value) !== JSON.stringify(value);
+          entry.value = value; entry.version = version; entry.at = Date.now();
+          if (changed) this.dotsServer.emit('notification', {
+            method: 'thread/status/changed', params: { threadId: thread.id, ...value },
+          });
+        } catch (error) {
+          entry.version = version; entry.at = Date.now();
+          console.error('云端目录修订读取失败：', thread.id, error.message);
+        }
+      })().finally(() => { if (entry.work === work) entry.work = null; });
+      entry.work = work;
+    }
+    // The live chat updates its revision before notifying stream listeners.
+    // A directory refresh can still be in flight with an older cached value;
+    // never return that value after the rendered timeline has advanced.
+    if (thread.threadSource === 'aeon') {
+      const current = this.dotsChat.threads.get(thread.id)?.thread;
+      return current?.chatRevision === undefined ? {} : {
+        chatRevision: current.chatRevision, chatMessageRevision: current.chatMessageRevision, updatedAt: current.updatedAt,
+      };
+    }
+    return entry.value;
+  }
+
+  async projects() {
+    const native = await this.server.projects();
+    const projects = native.map(projectSummary);
+    return { projects, native };
+  }
+
+  async threads(limit, archived = false, scope = 'all', refresh = false) {
+    const { projects, native } = await this.projects();
+    const threads = []; let cursor;
+    if (scope !== 'durable') do {
+      const page = await this.server.request('thread/list', { limit: Math.min(100, limit - threads.length),
+        sortKey: 'recency_at', sortDirection: 'desc', archived, ...(cursor ? { cursor } : {}) });
+      threads.push(...page.data); cursor = page.nextCursor;
+    } while (cursor && threads.length < limit);
+    const summaries = threads.map(thread => ({ id: thread.id, kind: 'codex', hostId: 'local',
+      ...(thread.model ? { model: thread.model, reasoningEffort: thread.reasoningEffort } : {}),
+      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) }));
+    let catalogError;
+    if (scope !== 'local' && this.dotsServer) {
+      try {
+        const dots = await this.dotsServer.catalog(archived, refresh);
+        summaries.push(...dots.map(thread => ({ id: thread.id, kind: thread.threadSource === 'aeon' ? 'dots' : 'codex', hostId: 'durable',
+          threadSource: thread.threadSource,
+          ...(thread.threadSource === 'aeon_child' && thread.model ? { model: thread.model, reasoningEffort: thread.reasoningEffort } : {}),
+          ...this.threadState(thread, refresh),
+          ...(thread.threadSource === 'aeon' ? { avatar: thread.avatar || '', color: thread.color || '' } : {}),
+          title: thread.name || (thread.threadSource === 'aeon' ? 'Dots' : thread.preview || ''), cwd: thread.cwd,
+          projectId: thread.threadSource === 'aeon' ? null : dotsThreadProjectId(thread, native),
+          updatedAt: thread.threadSource === 'aeon' ? this.dotsChat.threads.get(thread.id)?.thread.updatedAt || 0 : thread.updatedAt,
+          recencyAt: thread.recencyAt ?? thread.updatedAt,
+          status: thread.threadSource === 'aeon' ? this.dotsChat?.threads.get(thread.id)?.thread.status || 'unknown'
+            : typeof thread.status === 'string' ? thread.status : thread.status?.type || 'unknown',
+          activeFlags: thread.threadSource === 'aeon' ? [] : threadActiveFlags(thread.status) })));
+      } catch (error) { catalogError = `Dots 对话读取失败：${error.message}`; }
+    }
+    summaries.sort((a, b) => b.recencyAt - a.recencyAt);
+    return { catalogScope: scope, projects, pinnedThreads: [], threads: [...summaries.filter(thread => thread.kind === 'dots'),
+      ...summaries.filter(thread => thread.kind !== 'dots').slice(0, limit)], ...(catalogError ? { catalogError } : {}) };
+  }
+}
+
+function threadActiveFlags(status) {
+  return status && typeof status === 'object' && Array.isArray(status.activeFlags)
+    ? status.activeFlags.filter(flag => typeof flag === 'string')
+    : [];
+}