@walkhi/code-relax 0.1.0-beta.22 → 0.1.0-beta.23

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

@@ -8,7 +8,6 @@ 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 {
@@ -38,13 +37,15 @@ export class SharedAppServer extends EventEmitter {
     this.epoch = randomUUID();
     this.sequence = 0;
     this.pending = new Map();
-    this.serverRequests = new serverRequests.Store(randomUUID(), id => this.emit('requests-changed', id));
+    this.serverRequests = new serverRequests.Store(randomUUID(), id => {
+      this.emit('requests-changed', id);
+      this.releaseInactiveThread(id);
+    });
     this.threads = new Map();
     this.contexts = new Map();
     this.settingsNotifications = new Map();
     this.permissionOptions = new events.PermissionOptionsCache();
     this.subscriptions = new Map();
-    this.operationGroups = new Map();
     this.usageCache = new events.UsageCache(value => this.emit('usage', value));
   }
 
@@ -74,9 +75,13 @@ export class SharedAppServer extends EventEmitter {
         const text = String(message.error.message || 'app-server 请求失败');
         pending.reject(writerConflictMessages.some(value => text.toLowerCase().includes(value))
           ? new ThreadWriterConflictError(pending.threadId, text)
-          : Object.assign(new Error(text), { rpcCode: message.error.code, details: message.error.data }));
+          : Object.assign(new Error(text), { rpcCode: message.error.code, details: message.error.data,
+            ...(/^invalid cursor:/i.test(text) ? { code: 'history_cursor_expired' } : {}) }));
+      }
+      else {
+        try { pending.resolve(pending.transform(message.result)); }
+        catch (error) { pending.reject(error); }
       }
-      else pending.resolve(message.result);
     });
     socket.on('close', () => {
       this.ready = false;
@@ -88,7 +93,6 @@ export class SharedAppServer extends EventEmitter {
       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();
@@ -110,14 +114,14 @@ export class SharedAppServer extends EventEmitter {
     } catch (error) { socket.close(); throw error; }
   }
 
-  request(method, params) {
+  request(method, params, transform = value => value) {
     const id = ++this.sequence;
     return new Promise((resolve, reject) => {
       const timer = setTimeout(() => {
         this.pending.delete(id);
         reject(new Error(`${method} 超时；不会自动重发，请先检查对话。`));
       }, 30000);
-      this.pending.set(id, { resolve, reject, timer, threadId: params?.threadId });
+      this.pending.set(id, { resolve, reject, timer, transform, threadId: params?.threadId });
       this.socket.send(JSON.stringify({ id, method, params }), error => {
         if (!error || !this.pending.delete(id)) return;
         clearTimeout(timer); reject(error);
@@ -136,18 +140,18 @@ export class SharedAppServer extends EventEmitter {
     // 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') {
+    if (status === 'active') {
       const page = await this.request('thread/turns/list', {
-        threadId: args.threadId, limit: 1, sortDirection: 'desc', itemsView: 'summary',
+        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);
-      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 } };
-    }
-    const result = await this.request('turn/start', args);
-    return { result, usage: { kind: 'start', turnId: result?.turn?.id || null } };
+      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 } };
+    }
+    const result = await this.request('turn/start', args);
+    return { result, usage: { kind: 'start', turnId: result?.turn?.id || null } };
   }
 
   respondApproval(threadId, body) {
@@ -178,11 +182,22 @@ export class SharedAppServer extends EventEmitter {
     }
     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)
+    const slot = this.subscriptions.get(id);
+    if (!slot?.users && !slot?.readers && !record.tokens.size) {
+      // 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: [] } });
+      else if (method === 'thread/status/changed') record.thread.status = params.status;
+      record.thread.turns = (record.thread.turns || []).slice(-1).map(turn => ({ ...turn, items: [] }));
+      record.changes.clear(); record.changeBytes = 0;
+      if (['turn/completed', 'thread/status/changed'].includes(method)) this.releaseInactiveThread(id);
+      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)
       ? { ...params, turn: { ...params.turn,
-        items: params.turn.items.filter(item => ['userMessage', 'agentMessage'].includes(item?.type)) } }
+        items: params.turn.items.filter(item => current?.items?.some(loaded => loaded.id === item.id)) } }
       : params;
     const turn = events.applyNotification(record.thread, method, appliedParams);
     if (turn) {
@@ -197,14 +212,16 @@ export class SharedAppServer extends EventEmitter {
         immediate: ['turn/completed', 'item/completed'].includes(method) });
     }
     if (method === 'turn/completed') record.thread.turns = record.thread.turns.slice(-10);
+    if (['turn/completed', 'thread/status/changed'].includes(method)) this.releaseInactiveThread(id);
   }
 
   async timeline(threadId, pageOptions = {}) {
     await this.connect();
     const slot = this.slot(threadId);
+    slot.readers++;
     const task = slot.tail.then(async () => {
       let record = this.threads.get(threadId);
-      if (record?.readOnly) {
+      if (record?.readOnly || record?.needsReload) {
         this.threads.delete(threadId);
         this.contexts.delete(threadId);
         record = null;
@@ -213,13 +230,20 @@ export class SharedAppServer extends EventEmitter {
         let result;
         try {
           result = await this.request('thread/resume', { threadId, excludeTurns: true,
-            initialTurnsPage: { limit: 1, sortDirection: 'desc', itemsView: 'summary' } });
+            initialTurnsPage: { limit: 1, sortDirection: 'desc', itemsView: 'notLoaded' } }, value => {
+            if (!Array.isArray(value.initialTurnsPage?.data)) throw new Error('Codex 内核未返回分页历史。');
+            record = { thread: { ...value.thread, turns: [...value.initialTurnsPage.data].reverse().map(turn => ({ ...turn, items: [] })) },
+              nextCursor: value.initialTurnsPage.nextCursor ?? null, sequence: 0, recoverAfter: 0,
+              changes: new Map(), changeBytes: 0, tokens: new Map(), hydrating: true };
+            this.threads.set(threadId, record);
+            return value;
+          });
         } catch (error) {
           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: historyPageMaxTurns, sortDirection: 'desc', itemsView: 'summary',
+              threadId, limit: 1, sortDirection: 'desc', itemsView: 'notLoaded',
             }),
           ]);
           const compact = await Promise.all([...(page.data || [])].reverse().map(turn => this.compactTurn(threadId, turn)));
@@ -233,11 +257,11 @@ export class SharedAppServer extends EventEmitter {
         }
         if (result) {
           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);
+          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 };
+          })));
+          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);
@@ -246,11 +270,13 @@ export class SharedAppServer extends EventEmitter {
       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,
+      return { thread: record.thread, 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(() => {});
     task.catch(() => {
+      const record = this.threads.get(threadId);
+      if (record?.hydrating) { record.needsReload = true; record.hydrating = false; this.scheduleCleanup(threadId, slot); }
       if (!slot.users && !this.threads.has(threadId) && this.subscriptions.get(threadId) === slot) {
         clearTimeout(slot.expiry);
         this.subscriptions.delete(threadId);
@@ -261,10 +287,18 @@ export class SharedAppServer extends EventEmitter {
 
   slot(threadId) {
     let slot = this.subscriptions.get(threadId);
-    if (!slot) { slot = { users: 0, tail: Promise.resolve(), expiry: null }; this.subscriptions.set(threadId, slot); }
+    if (!slot) { slot = { users: 0, readers: 0, tail: Promise.resolve(), expiry: null }; this.subscriptions.set(threadId, slot); }
     return slot;
   }
 
+  keepSnapshotAlive(threadId, sync) {
+    const token = this.threads.get(threadId)?.tokens.get(sync?.id);
+    const slot = this.subscriptions.get(threadId);
+    if (!token || !slot || sync.epoch !== this.epoch) return;
+    token.expires = Date.now() + syncTokenTtlMs;
+    this.scheduleCleanup(threadId, slot);
+  }
+
   scheduleCleanup(threadId, slot) {
     clearTimeout(slot.expiry);
     const record = this.threads.get(threadId);
@@ -276,18 +310,34 @@ export class SharedAppServer extends EventEmitter {
   cleanup(threadId, slot) {
     const record = this.threads.get(threadId), now = Date.now();
     if (record) for (const [id, token] of record.tokens) if (token.expires <= now) record.tokens.delete(id);
-    if (slot.users) { clearTimeout(slot.expiry); slot.expiry = null; return; }
+    if (slot.users || slot.readers) { clearTimeout(slot.expiry); slot.expiry = null; return; }
     if (record?.tokens.size) { this.scheduleCleanup(threadId, slot); return; }
+    if (this.keepThreadLoaded(threadId, record)) { clearTimeout(slot.expiry); slot.expiry = null; return; }
     slot.tail = slot.tail.then(async () => {
-      if (slot.users || this.threads.get(threadId)?.tokens.size) return;
+      if (this.subscriptions.get(threadId) !== slot) return;
+      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.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));
   }
 
+  keepThreadLoaded(threadId, record) {
+    if (!record || record.readOnly) return false;
+    const status = typeof record.thread.status === 'string' ? record.thread.status : record.thread.status?.type;
+    return status === 'active' || record.thread.turns?.some(turn => turn.status === 'inProgress')
+      || this.serverRequests.list(threadId).length > 0;
+  }
+
+  releaseInactiveThread(threadId) {
+    // Run after the current notification has updated both request and turn state.
+    queueMicrotask(() => {
+      const slot = this.subscriptions?.get(threadId);
+      if (slot && !slot.users && this.ready) this.cleanup(threadId, slot);
+    });
+  }
+
   async acquire(threadId, requested) {
     const slot = this.slot(threadId);
     let record = this.threads.get(threadId), token;
@@ -317,7 +367,7 @@ export class SharedAppServer extends EventEmitter {
       this.cleanup(threadId, slot);
       return slot.tail;
     };
-    return { record: { thread: record.thread, nextCursor: record.nextCursor,
+    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 };
   }
@@ -330,66 +380,43 @@ export class SharedAppServer extends EventEmitter {
     };
   }
 
-  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', 'imageView'].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 };
+  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,
+      itemCursor: itemCursor || null, turnCursor: turnCursor || null });
   }
 
-  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 compactTurn(threadId, turn, cursor = null, apply) {
+    if (!turn?.id) return events.compactTurn(turn);
+    return this.request('thread/items/list', {
+      threadId, turnId: turn.id, ...(cursor ? { cursor } : {}), limit: 100, sortDirection: 'desc',
+    }, page => {
+      const result = this.projectItemPage(threadId, turn, cursor, page);
+      apply?.(result); return result;
+    });
+  }
+
+  projectItemPage(threadId, turn, cursor, page) {
+    const compact = events.compactTurn(turn);
+    if (!Array.isArray(page.data)) throw new Error('Codex 内核未返回单轮条目索引。');
+    if (page.nextCursor && page.nextCursor === cursor) throw new Error('条目分页游标未推进。');
+    if (page.data.some(entry => entry.turnId !== turn.id)) throw new Error('条目所属轮次不匹配。');
+    const items = [...page.data].reverse().map(entry => events.compactItem(entry.item));
+    return { ...compact, items, itemPage: { olderCursor: page.nextCursor ?? null,
+      hasLoadedOldest: !page.nextCursor, oldestItemId: items[0]?.id || null,
+      newestItemId: items.at(-1)?.id || null, requestedCursor: cursor, projection: 'mobile-skeleton' } };
   }
 
   async turnContext(threadId, turnId) {
     await this.connect();
     if (!threadId || !turnId) throw new Error('缺少图片所属的对话或轮次。');
-    return this.compactTurn(threadId, { id: turnId });
+    let turn = await this.compactTurn(threadId, { id: turnId });
+    while (turn.itemPage.olderCursor) {
+      const older = await this.compactTurn(threadId, { id: turnId }, turn.itemPage.olderCursor);
+      turn = { ...turn, items: [...older.items, ...turn.items], itemPage: older.itemPage };
+    }
+    return turn;
   }
 
   fitTurns(base, turns, options = {}) {
@@ -408,13 +435,13 @@ export class SharedAppServer extends EventEmitter {
 
   async extendHistoryRecord(threadId, record, options = {}) {
     const settings = this.pageSettings(options);
-    if (!record.nextCursor || !record.thread.turns.length) return;
+    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: 'summary',
+        threadId, cursor, limit: 1, sortDirection: 'desc', itemsView: 'notLoaded',
       });
       if (!Array.isArray(page.data) || !page.data.length) {
         record.nextCursor = page.nextCursor ?? null;
@@ -425,6 +452,7 @@ export class SharedAppServer extends EventEmitter {
       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;
     }
   }
@@ -432,29 +460,21 @@ export class SharedAppServer extends EventEmitter {
   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;
+    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.itemCursor && position.turnId) {
+      const turn = await this.compactTurn(threadId, { id: position.turnId }, position.itemCursor);
+      return { thread: { id: threadId, turns: [turn] },
+        nextCursor: this.historyCursor(threadId, turn, position.turnCursor) };
     }
-    return { thread: { id: threadId, turns }, nextCursor };
+    const page = await this.request('thread/turns/list', {
+      threadId, cursor: position.turnCursor, limit: 1, sortDirection: 'desc', itemsView: 'notLoaded',
+    });
+    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])] : [];
+    return { thread: { id: threadId, turns }, nextCursor: this.historyCursor(threadId, turns[0], page.nextCursor) };
   }
 
   async interrupt(threadId, turnId) {
@@ -513,7 +533,3 @@ export class SharedAppServer extends EventEmitter {
 
   close() { this.socket?.close(); }
 }
-
-function isSubAgentItem(item) {
-  return item?.type === 'collabAgentToolCall' || item?.type === 'subAgentActivity';
-}

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

@@ -1,33 +1,42 @@
 // Event-driven subscription adapter. Normal desktop-tool polling remains in its own adapter.
-import timelineSync from '../shared/timeline-sync.cjs';
-const threadListNotificationMethods = new Set([
-  'thread/started', 'thread/status/changed', 'thread/name/updated',
-  'thread/archived', 'thread/unarchived', 'thread/deleted',
-  'thread/project/updated', 'project/changed', 'turn/started', 'turn/completed',
-]);
-export async function streamSharedThread(response, threadId, client, normalize, requestedSync, known) {
+import timelineSync from '../shared/timeline-sync.cjs';
+const threadListNotificationMethods = new Set([
+  'thread/started', 'thread/status/changed', 'thread/name/updated',
+  'thread/archived', 'thread/unarchived', 'thread/deleted',
+  'thread/project/updated', 'project/changed', 'turn/started', 'turn/completed',
+]);
+export async function streamSharedThread(response, threadId, client, normalize, requestedSync) {
   response.startEvents();
-  let closed = false, timer, subscription, streamReady = false;
+  let closed = false, timer, subscription, streamReady = false, flushing = false;
   const pending = new Map(), sentTurns = new Map();
   let fromSeq, toSeq, syncId = requestedSync?.id, epoch = requestedSync?.epoch;
   let finish;
   const done = new Promise(resolve => { finish = resolve; });
-  const emit = (name, value) => { if (!closed) response.event(name, value); };
-  const flush = () => {
+  const emit = (name, value) => { if (!closed) return response.event(name, value); };
+  const flush = async () => {
     clearTimeout(timer); timer = null;
     const record = client.threads.get(threadId);
-    if (!streamReady || !record || !pending.size) return;
-    const base = normalize({ thread: { ...record.thread, turns: [] }, sync: { id: syncId, epoch, fromSeq, toSeq } });
-    const turns = [], turnPatches = [];
-    for (const turn of pending.values()) {
-      const normalized = normalize({ thread: { ...record.thread, turns: [turn] } }).turns[0];
-      const patch = timelineSync.diffTurn(sentTurns.get(turn.id), normalized);
-      if (patch) turnPatches.push(patch); else turns.push(normalized);
-      sentTurns.set(turn.id, normalized);
+    if (closed || flushing || !streamReady || !record || !pending.size) return;
+    flushing = true;
+    try {
+      const base = normalize({ thread: { ...record.thread, turns: [] }, sync: { id: syncId, epoch, fromSeq, toSeq } });
+      const turns = [], turnPatches = [];
+      for (const turn of pending.values()) {
+        const normalized = normalize({ thread: { ...record.thread, turns: [turn] } }).turns[0];
+        const patch = timelineSync.diffTurn(sentTurns.get(turn.id), normalized);
+        if (patch) turnPatches.push(patch); else turns.push(normalized);
+        sentTurns.set(turn.id, normalized);
+      }
+      const retained = new Set(record.thread.turns.map(turn => turn.id));
+      for (const id of sentTurns.keys()) if (!retained.has(id)) sentTurns.delete(id);
+      pending.clear();
+      fromSeq = toSeq = undefined;
+      await emit('update', { ...base, turns, ...(turnPatches.length ? { turnPatches } : {}) });
+    } catch (error) { emit('bridge-error', { error: error.message }); response.end(); finish(); }
+    finally {
+      flushing = false;
+      if (!closed && pending.size && !timer) timer = setTimeout(flush, 0);
     }
-    emit('update', { ...base, turns, ...(turnPatches.length ? { turnPatches } : {}) });
-    pending.clear();
-    fromSeq = toSeq = undefined;
   };
   const onTurn = ({ thread, turn, sequence, immediate }) => {
     if (thread.id !== threadId) return;
@@ -36,45 +45,42 @@ export async function streamSharedThread(response, threadId, client, normalize,
     pending.set(turn.id, turn);
     if (immediate) flush(); else if (!timer) timer = setTimeout(flush, 50);
   };
-  const onSettings = id => { if (id === threadId) emit('settings', client.context(id)); };
-  const onRequests = id => { if (id === threadId) emit('approvals', { requests: client.serverRequests.list(threadId) }); };
-  const onQueue = id => { if (id === threadId) emit('queue-changed', {}); };
-  const onNotification = ({ method, params }) => {
-    if (!threadListNotificationMethods.has(method)) return;
-    emit('thread-list-changed', { method, threadId: params.threadId || params.thread?.id || '' });
-  };
-  const onDisconnected = () => { emit('bridge-error', { error: 'Codex 内核连接已断开，请重新连接。' }); response.end(); finish(); };
+  const onSettings = id => { if (id === threadId) emit('settings', client.context(id)); };
+  const onRequests = id => { if (id === threadId) emit('approvals', { requests: client.serverRequests.list(threadId) }); };
+  const onQueue = id => { if (id === threadId) emit('queue-changed', {}); };
+  const onNotification = ({ method, params }) => {
+    if (!threadListNotificationMethods.has(method)) return;
+    emit('thread-list-changed', { method, threadId: params.threadId || params.thread?.id || '' });
+  };
+  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);
-  client.on('requests-changed', onRequests);
-  client.on('notification', onNotification);
+  client.on('turn', onTurn); client.on('settings', onSettings); client.on('disconnected', onDisconnected);
+  client.on('queue-changed', onQueue);
+  client.on('requests-changed', onRequests);
+  client.on('notification', onNotification);
   try {
-    subscription = await client.acquire(threadId, requestedSync);
-    syncId = subscription.record.sync.id; epoch = subscription.record.sync.epoch;
-    streamReady = true;
-    if (!closed) {
-      const normalized = normalize(subscription.record);
-      const latest = normalized.turns.at(-1);
-      const unchanged = subscription.snapshot && known?.turnId && known.turnId === latest?.id
-        && known.updatedAt > 0 && known.updatedAt === Number(normalized.thread.updatedAt)
-        && normalized.thread.status === 'idle' && latest?.status !== 'inProgress'
-        && known.turnStatus && known.turnStatus !== 'inProgress';
-      if (subscription.snapshot) emit('update', unchanged ? { ...normalized, turns: [], notModified: true } : normalized);
-      else if (subscription.catchup) emit('update', normalize(subscription.catchup));
-      for (const turn of normalized.turns) sentTurns.set(turn.id, turn);
+    subscription = await client.acquire(threadId, requestedSync);
+    syncId = subscription.record.sync.id; epoch = subscription.record.sync.epoch;
+    if (!closed) {
+      const normalized = normalize(subscription.record);
+      // The acquired snapshot/catchup already includes pre-acquire notifications.
+      pending.clear(); fromSeq = toSeq = undefined;
+      if (subscription.snapshot) await emit('update', normalized);
+      else if (subscription.catchup) await emit('update', normalize(subscription.catchup));
+      for (const turn of normalized.turns) sentTurns.set(turn.id, turn);
       emit('queue-changed', {});
       onRequests(threadId);
+      streamReady = true;
       flush();
     }
     await done;
   } catch (error) { emit('bridge-error', { error: error.message }); response.end(); }
   finally {
     clearTimeout(timer);
-    client.off('turn', onTurn); client.off('settings', onSettings); client.off('disconnected', onDisconnected);
-    client.off('queue-changed', onQueue);
-    client.off('requests-changed', onRequests);
-    client.off('notification', onNotification);
+    client.off('turn', onTurn); client.off('settings', onSettings); client.off('disconnected', onDisconnected);
+    client.off('queue-changed', onQueue);
+    client.off('requests-changed', onRequests);
+    client.off('notification', onNotification);
     if (subscription) await subscription.release();
   }
 }

package/dist/src/turn-model-history.mjs

@@ -0,0 +1,47 @@
+import fs from 'node:fs';
+
+// Read authoritative turn contexts locally; never send rollout text to a terminal.
+export class TurnModelHistory {
+  constructor() { this.files = new Map(); }
+
+  async read(file, turnIds) {
+    if (!file || !turnIds.length) return [];
+    let state = this.files.get(file);
+    if (!state) {
+      state = { offset: 0, lastModel: '', turns: new Map(), changes: new Map(), tail: Promise.resolve() };
+      this.files.set(file, state);
+      if (this.files.size > 16) this.files.delete(this.files.keys().next().value);
+    }
+    const task = state.tail.then(async () => {
+      const stat = await fs.promises.stat(file);
+      if (stat.size < state.offset) {
+        state.offset = 0; state.lastModel = ''; state.turns.clear(); state.changes.clear();
+      }
+      if (stat.size > state.offset) {
+        let pending = Buffer.alloc(0);
+        const stream = fs.createReadStream(file, { start: state.offset, end: stat.size - 1 });
+        for await (const chunk of stream) {
+          const data = pending.length ? Buffer.concat([pending, chunk]) : chunk;
+          let start = 0, end;
+          while ((end = data.indexOf(10, start)) !== -1) {
+            const line = data.subarray(start, end);
+            if (line.subarray(0, 160).includes(Buffer.from('"turn_context"'))) {
+              const event = JSON.parse(line.toString('utf8'));
+              const { turn_id: turnId, model } = event.payload || {};
+              if (event.type === 'turn_context' && typeof turnId === 'string' && typeof model === 'string' && model && !state.turns.has(turnId)) {
+                if (state.lastModel && state.lastModel !== model) state.changes.set(turnId, { turnId, fromModel: state.lastModel, toModel: model });
+                state.turns.set(turnId, model); state.lastModel = model;
+              }
+            }
+            state.offset += end - start + 1;
+            start = end + 1;
+          }
+          pending = data.subarray(start);
+        }
+      }
+      return turnIds.flatMap(id => state.changes.has(id) ? [state.changes.get(id)] : []);
+    });
+    state.tail = task.catch(() => {});
+    return task;
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@walkhi/code-relax",
-  "version": "0.1.0-beta.22",
+  "version": "0.1.0-beta.23",
   "license": "UNLICENSED",
   "type": "module",
   "scripts": {