@walkhi/code-relax 0.1.0-beta.50 → 0.1.0-beta.51

package/dist/src/shared-catalog.mjs

@@ -1,132 +1,132 @@
-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')
-    : [];
-}
+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')
+    : [];
+}

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

@@ -1,165 +1,165 @@
-// Event-driven subscription adapter. Normal desktop-tool polling remains in its own adapter.
-import timelineSync from '../shared/timeline-sync.cjs';
-export 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, releaseActivity, streamReady = false, flushing = false;
-  let tracePending = false, pendingReset;
-  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) return response.event(name, value); };
-  let historySync;
-  const publishHistorySync = () => {
-    if (typeof client.isHistorySyncing !== 'function') return;
-    const active = client.isHistorySyncing(threadId);
-    // End the notice only after the recovered body has been delivered, not
-    // when the upstream read finishes while its update is still being flushed.
-    if (!active && (!streamReady || flushing || pendingReset || pending.size)) return;
-    if (historySync === active) return;
-    historySync = active;
-    emit('history-sync', { threadId, active });
-  };
-  const flush = async () => {
-    clearTimeout(timer); timer = null;
-    const record = client.threads.get(threadId);
-    if (closed || flushing || !streamReady || !record || (!pendingReset && !pending.size)) return;
-    flushing = true;
-    try {
-      if (pendingReset) {
-        const snapshot = pendingReset;
-        pendingReset = undefined;
-        for (const [id, change] of pending) if (change.sequence <= snapshot.sync.seq) pending.delete(id);
-        fromSeq = pending.size ? Math.max(fromSeq, snapshot.sync.seq + 1) : undefined;
-        if (!pending.size) toSeq = undefined;
-        tracePending = [...pending.values()].some(change => change.immediate);
-        const normalized = await normalize(snapshot);
-        if (closed) return;
-        await emit('update', normalized);
-        syncId = normalized.sync.id; epoch = normalized.sync.epoch;
-        sentTurns.clear();
-        for (const turn of normalized.turns) if (!turn.cacheStub) sentTurns.set(turn.id, turn);
-        client.traceSync?.('stream-reset-sent', threadId, { seq: normalized.sync.seq,
-          turnOrder: normalized.turns.map(turn => turn.id) });
-        return;
-      }
-      const batch = structuredClone([...pending.values()].map(change => change.turn));
-      const thread = { ...record.thread, turns: [] }, sync = { id: syncId, epoch, fromSeq, toSeq };
-      const turnOrder = record.thread.turns.map(turn => turn.id), retained = new Set(turnOrder);
-      const trace = tracePending;
-      pending.clear(); fromSeq = toSeq = undefined; tracePending = false;
-      const base = await normalize({ thread, sync });
-      const turns = [], turnPatches = [];
-      const normalizedTurns = [];
-      for (const turn of batch) {
-        if (turn.cacheStub) continue;
-        const normalized = (await normalize({ thread: { ...thread, turns: [turn] } })).turns[0];
-        const patch = timelineSync.diffTurn(sentTurns.get(turn.id), normalized);
-        if (patch) turnPatches.push(patch); else turns.push(normalized);
-        normalizedTurns.push(normalized);
-      }
-      if (closed) return;
-      await emit('update', { ...base, turns, ...(turnPatches.length ? { turnPatches } : {}) });
-      for (const turn of normalizedTurns) sentTurns.set(turn.id, turn);
-      for (const id of sentTurns.keys()) if (!retained.has(id)) sentTurns.delete(id);
-      if (trace || turns.length || (base.sync.fromSeq <= record.recoverAfter && record.recoverAfter <= base.sync.toSeq)) {
-        client.traceSync?.('stream-update-sent', threadId, { closed, fromSeq: base.sync?.fromSeq, toSeq: base.sync?.toSeq, turnOrder,
-        messages: turns.flatMap(turn => turn.entries.map(entry => [turn.id, entry.id])),
-        patches: turnPatches.map(patch => ({ turnId: patch.id, entries: (patch.entries || []).map(entry => entry.id), appended: (patch.appended || []).map(entry => entry.id) })) });
-      }
-    } catch (error) { emit('bridge-error', { error: error.message }); response.end(); finish(); }
-    finally {
-      flushing = false;
-      publishHistorySync();
-      if (!closed && (pendingReset || pending.size) && !timer) timer = setTimeout(flush, 0);
-    }
-  };
-  const onTurn = ({ thread, turn, sequence, immediate }) => {
-    if (thread.id !== threadId) return;
-    if (!fromSeq) fromSeq = sequence;
-    toSeq = sequence;
-    pending.set(turn.id, { turn, sequence, immediate: immediate || pending.get(turn.id)?.immediate });
-    if (immediate) tracePending = true;
-    if (immediate) flush(); else if (!timer) timer = setTimeout(flush, 50);
-  };
-  const onReset = snapshot => {
-    if (snapshot.thread.id !== threadId) return;
-    pendingReset = structuredClone(snapshot);
-    pendingReset.sync.reset = true;
-    flush();
-  };
-  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 onDisconnected = () => { emit('bridge-error', { error: 'Codex 内核连接已断开，请重新连接。' }); response.end(); finish(); };
-  const onInvalidated = id => { if (id === threadId) emit('history-invalidated', {}); };
-  const onHistorySync = id => { if (id === threadId) publishHistorySync(); };
-  const onChatError = value => { if (value.threadId === threadId) emit('chat-error', value); };
-  response.once('close', () => { closed = true; finish(); });
-  client.on('turn', onTurn); client.on('settings', onSettings); client.on('disconnected', onDisconnected);
-  client.on('timeline-reset', onReset);
-  client.on('queue-changed', onQueue);
-  client.on('requests-changed', onRequests);
-  client.on('history-invalidated', onInvalidated);
-  client.on('history-sync', onHistorySync);
-  client.on('chat-error', onChatError);
-  publishHistorySync();
-  try {
-    const started = performance.now();
-    client.traceSync?.('stream-open', threadId, { requestedSeq: requestedSync?.after });
-    subscription = await client.acquire(threadId, requestedSync);
-    syncId = subscription.record.sync.id; epoch = subscription.record.sync.epoch;
-    if (!closed) {
-      const initial = structuredClone(subscription.record), catchup = subscription.catchup && structuredClone(subscription.catchup);
-      if (pendingReset?.sync.seq <= initial.sync.seq) pendingReset = undefined;
-      // Only discard notifications certified by the acquired snapshot/catchup.
-      for (const [id, change] of pending) if (change.sequence <= initial.sync.seq) pending.delete(id);
-      fromSeq = pending.size ? Math.max(fromSeq, initial.sync.seq + 1) : undefined;
-      if (!pending.size) toSeq = undefined;
-      tracePending = [...pending.values()].some(change => change.immediate);
-      const normalized = await normalize(subscription.confirmed ? { ...initial, thread: { ...initial.thread, turns: [] } } : initial);
-      const delivered = subscription.snapshot ? normalized : catchup ? await normalize(catchup) : null;
-      const sent = Boolean(delivered) && !closed;
-      if (sent) await emit('update', delivered);
-      // Confirm every handoff after its catchup/snapshot has been delivered.
-      // This also releases a cached selection with a valid, unchanged token;
-      // transport subscription alone does not confirm the message boundary.
-      if (!closed) await emit('sync-ready', {
-        thread: { ...normalized.thread, turns: [] }, sync: normalized.sync,
-      });
-      client.traceSync?.('stream-initial-sent', threadId, { ms: Math.round(performance.now() - started), closed,
-        snapshot: subscription.snapshot, catchup: Boolean(catchup), sent, seq: normalized.sync?.seq,
-        deliveredSync: sent ? delivered.sync : undefined,
-        messages: sent ? delivered.turns.flatMap(turn => turn.entries.map(entry => [turn.id, entry.id])) : [],
-        windowMessages: normalized.turns.flatMap(turn => turn.entries.map(entry => [turn.id, entry.id])) });
-      for (const turn of normalized.turns) if (!turn.cacheStub) sentTurns.set(turn.id, turn);
-      emit('queue-changed', {});
-      onRequests(threadId);
-      streamReady = true;
-      publishHistorySync();
-      if (!closed && typeof client.acquireActivity === 'function') {
-        releaseActivity = client.acquireActivity(threadId, value => emit('dots-activity', value));
-      }
-      flush();
-    }
-    await done;
-  } catch (error) { emit('bridge-error', { error: error.message }); response.end(); }
-  finally {
-    client.traceSync?.('stream-close', threadId, { ready: streamReady });
-    clearTimeout(timer);
-    releaseActivity?.();
-    client.off('turn', onTurn); client.off('settings', onSettings); client.off('disconnected', onDisconnected);
-    client.off('timeline-reset', onReset);
-    client.off('queue-changed', onQueue);
-    client.off('requests-changed', onRequests);
-    client.off('history-invalidated', onInvalidated);
-    client.off('history-sync', onHistorySync);
-    client.off('chat-error', onChatError);
-    if (subscription) await subscription.release();
-  }
-}
+// Event-driven subscription adapter. Normal desktop-tool polling remains in its own adapter.
+import timelineSync from '../shared/timeline-sync.cjs';
+export 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, releaseActivity, streamReady = false, flushing = false;
+  let tracePending = false, pendingReset;
+  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) return response.event(name, value); };
+  let historySync;
+  const publishHistorySync = () => {
+    if (typeof client.isHistorySyncing !== 'function') return;
+    const active = client.isHistorySyncing(threadId);
+    // End the notice only after the recovered body has been delivered, not
+    // when the upstream read finishes while its update is still being flushed.
+    if (!active && (!streamReady || flushing || pendingReset || pending.size)) return;
+    if (historySync === active) return;
+    historySync = active;
+    emit('history-sync', { threadId, active });
+  };
+  const flush = async () => {
+    clearTimeout(timer); timer = null;
+    const record = client.threads.get(threadId);
+    if (closed || flushing || !streamReady || !record || (!pendingReset && !pending.size)) return;
+    flushing = true;
+    try {
+      if (pendingReset) {
+        const snapshot = pendingReset;
+        pendingReset = undefined;
+        for (const [id, change] of pending) if (change.sequence <= snapshot.sync.seq) pending.delete(id);
+        fromSeq = pending.size ? Math.max(fromSeq, snapshot.sync.seq + 1) : undefined;
+        if (!pending.size) toSeq = undefined;
+        tracePending = [...pending.values()].some(change => change.immediate);
+        const normalized = await normalize(snapshot);
+        if (closed) return;
+        await emit('update', normalized);
+        syncId = normalized.sync.id; epoch = normalized.sync.epoch;
+        sentTurns.clear();
+        for (const turn of normalized.turns) if (!turn.cacheStub) sentTurns.set(turn.id, turn);
+        client.traceSync?.('stream-reset-sent', threadId, { seq: normalized.sync.seq,
+          turnOrder: normalized.turns.map(turn => turn.id) });
+        return;
+      }
+      const batch = structuredClone([...pending.values()].map(change => change.turn));
+      const thread = { ...record.thread, turns: [] }, sync = { id: syncId, epoch, fromSeq, toSeq };
+      const turnOrder = record.thread.turns.map(turn => turn.id), retained = new Set(turnOrder);
+      const trace = tracePending;
+      pending.clear(); fromSeq = toSeq = undefined; tracePending = false;
+      const base = await normalize({ thread, sync });
+      const turns = [], turnPatches = [];
+      const normalizedTurns = [];
+      for (const turn of batch) {
+        if (turn.cacheStub) continue;
+        const normalized = (await normalize({ thread: { ...thread, turns: [turn] } })).turns[0];
+        const patch = timelineSync.diffTurn(sentTurns.get(turn.id), normalized);
+        if (patch) turnPatches.push(patch); else turns.push(normalized);
+        normalizedTurns.push(normalized);
+      }
+      if (closed) return;
+      await emit('update', { ...base, turns, ...(turnPatches.length ? { turnPatches } : {}) });
+      for (const turn of normalizedTurns) sentTurns.set(turn.id, turn);
+      for (const id of sentTurns.keys()) if (!retained.has(id)) sentTurns.delete(id);
+      if (trace || turns.length || (base.sync.fromSeq <= record.recoverAfter && record.recoverAfter <= base.sync.toSeq)) {
+        client.traceSync?.('stream-update-sent', threadId, { closed, fromSeq: base.sync?.fromSeq, toSeq: base.sync?.toSeq, turnOrder,
+        messages: turns.flatMap(turn => turn.entries.map(entry => [turn.id, entry.id])),
+        patches: turnPatches.map(patch => ({ turnId: patch.id, entries: (patch.entries || []).map(entry => entry.id), appended: (patch.appended || []).map(entry => entry.id) })) });
+      }
+    } catch (error) { emit('bridge-error', { error: error.message }); response.end(); finish(); }
+    finally {
+      flushing = false;
+      publishHistorySync();
+      if (!closed && (pendingReset || pending.size) && !timer) timer = setTimeout(flush, 0);
+    }
+  };
+  const onTurn = ({ thread, turn, sequence, immediate }) => {
+    if (thread.id !== threadId) return;
+    if (!fromSeq) fromSeq = sequence;
+    toSeq = sequence;
+    pending.set(turn.id, { turn, sequence, immediate: immediate || pending.get(turn.id)?.immediate });
+    if (immediate) tracePending = true;
+    if (immediate) flush(); else if (!timer) timer = setTimeout(flush, 50);
+  };
+  const onReset = snapshot => {
+    if (snapshot.thread.id !== threadId) return;
+    pendingReset = structuredClone(snapshot);
+    pendingReset.sync.reset = true;
+    flush();
+  };
+  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 onDisconnected = () => { emit('bridge-error', { error: 'Codex 内核连接已断开，请重新连接。' }); response.end(); finish(); };
+  const onInvalidated = id => { if (id === threadId) emit('history-invalidated', {}); };
+  const onHistorySync = id => { if (id === threadId) publishHistorySync(); };
+  const onChatError = value => { if (value.threadId === threadId) emit('chat-error', value); };
+  response.once('close', () => { closed = true; finish(); });
+  client.on('turn', onTurn); client.on('settings', onSettings); client.on('disconnected', onDisconnected);
+  client.on('timeline-reset', onReset);
+  client.on('queue-changed', onQueue);
+  client.on('requests-changed', onRequests);
+  client.on('history-invalidated', onInvalidated);
+  client.on('history-sync', onHistorySync);
+  client.on('chat-error', onChatError);
+  publishHistorySync();
+  try {
+    const started = performance.now();
+    client.traceSync?.('stream-open', threadId, { requestedSeq: requestedSync?.after });
+    subscription = await client.acquire(threadId, requestedSync);
+    syncId = subscription.record.sync.id; epoch = subscription.record.sync.epoch;
+    if (!closed) {
+      const initial = structuredClone(subscription.record), catchup = subscription.catchup && structuredClone(subscription.catchup);
+      if (pendingReset?.sync.seq <= initial.sync.seq) pendingReset = undefined;
+      // Only discard notifications certified by the acquired snapshot/catchup.
+      for (const [id, change] of pending) if (change.sequence <= initial.sync.seq) pending.delete(id);
+      fromSeq = pending.size ? Math.max(fromSeq, initial.sync.seq + 1) : undefined;
+      if (!pending.size) toSeq = undefined;
+      tracePending = [...pending.values()].some(change => change.immediate);
+      const normalized = await normalize(subscription.confirmed ? { ...initial, thread: { ...initial.thread, turns: [] } } : initial);
+      const delivered = subscription.snapshot ? normalized : catchup ? await normalize(catchup) : null;
+      const sent = Boolean(delivered) && !closed;
+      if (sent) await emit('update', delivered);
+      // Confirm every handoff after its catchup/snapshot has been delivered.
+      // This also releases a cached selection with a valid, unchanged token;
+      // transport subscription alone does not confirm the message boundary.
+      if (!closed) await emit('sync-ready', {
+        thread: { ...normalized.thread, turns: [] }, sync: normalized.sync,
+      });
+      client.traceSync?.('stream-initial-sent', threadId, { ms: Math.round(performance.now() - started), closed,
+        snapshot: subscription.snapshot, catchup: Boolean(catchup), sent, seq: normalized.sync?.seq,
+        deliveredSync: sent ? delivered.sync : undefined,
+        messages: sent ? delivered.turns.flatMap(turn => turn.entries.map(entry => [turn.id, entry.id])) : [],
+        windowMessages: normalized.turns.flatMap(turn => turn.entries.map(entry => [turn.id, entry.id])) });
+      for (const turn of normalized.turns) if (!turn.cacheStub) sentTurns.set(turn.id, turn);
+      emit('queue-changed', {});
+      onRequests(threadId);
+      streamReady = true;
+      publishHistorySync();
+      if (!closed && typeof client.acquireActivity === 'function') {
+        releaseActivity = client.acquireActivity(threadId, value => emit('dots-activity', value));
+      }
+      flush();
+    }
+    await done;
+  } catch (error) { emit('bridge-error', { error: error.message }); response.end(); }
+  finally {
+    client.traceSync?.('stream-close', threadId, { ready: streamReady });
+    clearTimeout(timer);
+    releaseActivity?.();
+    client.off('turn', onTurn); client.off('settings', onSettings); client.off('disconnected', onDisconnected);
+    client.off('timeline-reset', onReset);
+    client.off('queue-changed', onQueue);
+    client.off('requests-changed', onRequests);
+    client.off('history-invalidated', onInvalidated);
+    client.off('history-sync', onHistorySync);
+    client.off('chat-error', onChatError);
+    if (subscription) await subscription.release();
+  }
+}

package/dist/src/usage-reset.mjs

@@ -1,17 +1,17 @@
-export async function consumeUsageReset(client, body) {
-  if (typeof body?.idempotencyKey !== 'string' || !body.idempotencyKey.trim() || body.idempotencyKey.length > 200
-    || typeof body.creditId !== 'string' || !body.creditId.trim() || body.creditId.length > 200) {
-    throw Object.assign(new Error('请选择重置卡并确认使用。'), { statusCode: 400, code: 'usage_reset_not_submitted' });
-  }
-  let usage;
-  try { usage = await client.usage(); }
-  catch (error) { throw Object.assign(new Error('用量尚未确认，请恢复连接后重新选择重置卡。', { cause: error }),
-    { statusCode: 503, code: 'usage_reset_not_submitted' }); }
-  if ((usage.accountId || null) !== (body.accountId || null)) {
-    throw Object.assign(new Error('Codex 账号已变化，请重新打开用量详情。'), { statusCode: 409, code: 'usage_reset_not_submitted' });
-  }
-  // The core owns eligibility and the idempotent redemption outcome.
-  return client.request('account/rateLimitResetCredit/consume', {
-    idempotencyKey: body.idempotencyKey, creditId: body.creditId,
-  });
-}
+export async function consumeUsageReset(client, body) {
+  if (typeof body?.idempotencyKey !== 'string' || !body.idempotencyKey.trim() || body.idempotencyKey.length > 200
+    || typeof body.creditId !== 'string' || !body.creditId.trim() || body.creditId.length > 200) {
+    throw Object.assign(new Error('请选择重置卡并确认使用。'), { statusCode: 400, code: 'usage_reset_not_submitted' });
+  }
+  let usage;
+  try { usage = await client.usage(); }
+  catch (error) { throw Object.assign(new Error('用量尚未确认，请恢复连接后重新选择重置卡。', { cause: error }),
+    { statusCode: 503, code: 'usage_reset_not_submitted' }); }
+  if ((usage.accountId || null) !== (body.accountId || null)) {
+    throw Object.assign(new Error('Codex 账号已变化，请重新打开用量详情。'), { statusCode: 409, code: 'usage_reset_not_submitted' });
+  }
+  // The core owns eligibility and the idempotent redemption outcome.
+  return client.request('account/rateLimitResetCredit/consume', {
+    idempotencyKey: body.idempotencyKey, creditId: body.creditId,
+  });
+}