@walkhi/code-relax 0.1.0-beta.4 → 0.1.0-beta.40

package/dist/src/shared-catalog.mjs

@@ -1,45 +1,127 @@
 import events from '../shared/app-server-events.cjs';
+import { projectSummary } from './project-management.mjs';
 
 export function sharedThreadProjectId(thread, projects) {
-  if (thread.projectId) return thread.projectId;
-  const local = thread.environments?.find(environment => environment.environmentId === 'local');
-  if (local && Array.isArray(local.runtimeWorkspaceRoots)) {
-    for (const root of local.runtimeWorkspaceRoots) {
-      const projectId = events.threadProjectId({ cwd: root }, projects);
+  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 null;
   }
-  // Unloaded Desktop history omits environments and often has no persisted project ID.
   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) { this.server = server; }
+  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(project => ({ projectId: project.id, name: project.name,
-      label: project.name, path: project.roots[0]?.path || '', cwd: project.roots[0]?.path || '', hostId: 'local' }));
+    const projects = native.map(projectSummary);
     return { projects, native };
   }
 
-  async threads(limit, archived = false) {
+  async threads(limit, archived = false, scope = 'all', refresh = false) {
     const { projects, native } = await this.projects();
     const threads = []; let cursor;
-    do {
+    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) }));
-    return { projects, pinnedThreads: [], threads: summaries };
+    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 } : {}) };
   }
 }
 

package/dist/src/shared-recovery.mjs

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

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

@@ -1,80 +1,164 @@
-// Event-driven subscription adapter. Normal desktop-tool polling remains in its own adapter.
+// Event-driven subscription adapter. Normal desktop-tool polling remains in its own adapter.
 import timelineSync from '../shared/timeline-sync.cjs';
-const threadListNotificationMethods = new Set([
+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, known) {
-  response.startEvents();
-  let closed = false, timer, subscription, streamReady = 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 = () => {
-    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);
-    }
-    emit('update', { ...base, turns, ...(turnPatches.length ? { turnPatches } : {}) });
-    pending.clear();
-    fromSeq = toSeq = undefined;
-  };
-  const onTurn = ({ thread, turn, sequence, immediate }) => {
-    if (thread.id !== threadId) return;
-    if (!fromSeq) fromSeq = sequence;
-    toSeq = sequence;
-    pending.set(turn.id, turn);
-    if (immediate) flush(); else if (!timer) timer = setTimeout(flush, 50);
-  };
+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 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: '完整控制已断开，请重新连接。' }); response.end(); finish(); };
-  response.once('close', () => { closed = true; finish(); });
+  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('notification', onNotification);
-  try {
+  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;
-    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);
-      emit('queue-changed', {});
-      onRequests(threadId);
-      flush();
-    }
-    await done;
-  } catch (error) { emit('bridge-error', { error: error.message }); response.end(); }
-  finally {
-    clearTimeout(timer);
+      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);
+      // A timestamp-confirmed cache only needs the new subscription boundary,
+      // never an empty replacement window or a repeated body snapshot.
+      if (subscription.confirmed && !closed) await emit('sync-ready', {
+        thread: normalized.thread, 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('notification', onNotification);
-    if (subscription) await subscription.release();
-  }
-}
+    client.off('history-invalidated', onInvalidated);
+    client.off('history-sync', onHistorySync);
+    client.off('chat-error', onChatError);
+    if (subscription) await subscription.release();
+  }
+}

package/dist/src/skill-install.mjs

@@ -6,11 +6,8 @@ import { readRecord, writeRecord } from './service-lifecycle.mjs';
 
 const owner = '@walkhi/code-relax';
 const markerName = '.code-relax-install.json';
-const legacyOwner = '@closedhi/codex-remote';
-const legacyMarkerName = '.codex-remote-install.json';
 const digest = value => createHash('sha256').update(value).digest('hex');
 export const skillDirectory = (home = os.homedir()) => path.join(home, '.agents/skills/code-relax');
-const legacySkillDirectory = (home = os.homedir()) => path.join(home, '.agents/skills/codex-remote');
 
 // Refuse junctions/symlinks along managed paths before writing or removing files.
 export function assertPlainPath(target) {
@@ -33,15 +30,6 @@ export function inspectSkill(target = skillDirectory()) {
   return { installed: true, managed, target };
 }
 
-export function removeLegacyManagedSkill(target = legacySkillDirectory()) {
-  const marker = readRecord(path.join(target, legacyMarkerName));
-  const file = path.join(target, 'SKILL.md');
-  if (marker?.owner !== legacyOwner || !fs.existsSync(file) || marker.sha256 !== digest(fs.readFileSync(file))
-    || !fs.readdirSync(target).every(name => ['SKILL.md', legacyMarkerName].includes(name))) return false;
-  fs.unlinkSync(file); fs.unlinkSync(path.join(target, legacyMarkerName)); fs.rmdirSync(target);
-  return true;
-}
-
 export function installSkill(source, target = skillDirectory()) {
   const state = inspectSkill(target);
   if (state.installed && !state.managed) throw new Error(`同名 Skill 非本包管理或已被修改，请保留并手动处理：${target}`);
@@ -49,7 +37,6 @@ export function installSkill(source, target = skillDirectory()) {
   fs.mkdirSync(target, { recursive: true });
   fs.writeFileSync(path.join(target, 'SKILL.md'), content);
   writeRecord(path.join(target, markerName), { owner, sha256: digest(content) });
-  if (path.resolve(target) === path.resolve(skillDirectory())) removeLegacyManagedSkill();
   return { installed: true, target, message: 'Skill 已安装/更新；若 Codex 尚未显示，请重新打开 Codex。' };
 }
 

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/dist/src/usage-reset.mjs

@@ -0,0 +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,
+  });
+}