@walkhi/code-relax 0.1.0-beta.30 → 0.1.0-beta.32

package/dist/src/dots-task-catalog.mjs

@@ -1,430 +1,430 @@
-import WebSocket from 'ws';
-import { HostedHistoryAppServer } from './hosted-history-app-server.mjs';
-import { createDotsAvatarReader } from './dots-avatar.mjs';
-import { readDotsCatalog } from './dots-profile.mjs';
-import { DotsRoomClient } from './dots-room-client.mjs';
-import { uploadTaskFiles, taskFilePrompt } from './dots-task-files.mjs';
-
-const hostedAppServerUrl = 'wss://codex-cloud-backend.chatgpt.com/';
-export const dotsTaskRevision = turn => turn ? JSON.stringify([turn.id, turn.status]) : '';
-
-// Dots delegated tasks live in Desktop's durable host. Reuse the app-server
-// protocol client; only the authenticated transport differs from the local host.
-export class DotsAppServer extends HostedHistoryAppServer {
-  constructor(localServer, readProfiles = async () => new Map(), historyCache = null, { uploadsRoot } = {}) {
-    super(localServer.url, historyCache);
-    this.historySource = 'aeon_child';
-    this.localServer = localServer;
-    this.uploadsRoot = uploadsRoot;
-    this.filesClient = new DotsRoomClient(this);
-    this.url = hostedAppServerUrl;
-    this.threadSources = new Map();
-    this.catalogWatches = new Map();
-    this.readProfiles = readProfiles;
-    this.readAvatar = createDotsAvatarReader(localServer);
-    this.profileNames = new Map();
-    this.liveProfiles = new Map();
-    this.liveRoots = new Map();
-    this.rootIdentity = null;
-    this.catalogPages = new Map();
-    this.profileRefresh = null;
-    this.profileAttemptAt = 0;
-    this.on('turn', ({ thread }) => {
-      thread.chatRevision = dotsTaskRevision(thread.turns.at(-1));
-      this.saveHistoryWindow(thread.id);
-    });
-    this.on('disconnected', () => {
-      this.filesClient.close();
-      this.profileIdentity = null;
-      this.catalogPages.clear(); this.profileRefresh = null; this.profileAttemptAt = 0;
-      this.catalogWatches.clear();
-    });
-  }
-
-  get historyIdentity() { return this.profileIdentity; }
-
-  async connect() {
-    if (this.resetting) await this.resetting;
-    if (this.connecting) return this.connecting;
-    return super.connect();
-  }
-
-  async open() {
-    await super.open();
-    const socket = this.socket, identity = this.profileIdentity;
-    // Load confirmed display metadata before chat snapshots can publish a name
-    // or avatar. This reads local state, not the slow live profile request.
-    await this.refreshProfiles().catch(error => this.emit('profile-error', error));
-    if (!this.ready || this.socket !== socket || this.profileIdentity !== identity) throw new Error('点点连接已变化，请重新连接。');
-    this.emit('connected');
-  }
-
-  setProfileIdentity(identity) {
-    const key = JSON.stringify([identity.accountId, identity.userId]);
-    if (this.rootIdentity !== key) {
-      this.liveRoots.clear(); this.profileNames.clear(); this.liveProfiles.clear();
-    }
-    this.profileIdentity = identity; this.rootIdentity = key;
-  }
-
-  async openSocket() {
-    await this.localServer.connect();
-    const auth = await this.localServer.request('getAuthStatus', { includeToken: true, refreshToken: false });
-    if (!['chatgpt', 'chatgptAuthTokens'].includes(auth.authMethod) || !auth.authToken) {
-      throw new Error('读取 Dots 任务需要 Codex 内核已登录 ChatGPT。');
-    }
-    const identity = JSON.parse(Buffer.from(auth.authToken.split('.')[1], 'base64url').toString('utf8'));
-    const accountId = identity['https://api.openai.com/auth']?.chatgpt_account_id;
-    if (!accountId) throw new Error('Codex 内核没有可用于读取 Dots 任务的 ChatGPT 账号身份。');
-    this.setProfileIdentity({ accountId, userId: identity['https://api.openai.com/auth']?.chatgpt_user_id });
-    // Credentials stay in this process and go only to the fixed official host.
-    return new WebSocket(hostedAppServerUrl,
-      ['codex-app-server', 'codex-client.desktop', `openai-bearer.${auth.authToken}`], {
-        headers: { 'ChatGPT-Account-Id': accountId, 'X-OpenAI-Product-Sku': 'codex' },
-        handshakeTimeout: 15000,
-      });
-  }
-
-  request(method, params, transform = value => value) {
-    return this.nativeRequest(method, params, value => {
-      if (method === 'thread/read' || method === 'thread/resume') {
-        if (value.thread.threadSource !== 'aeon_child') throw new Error('该会话不是 Dots 委派任务。');
-        value.thread = { ...value.thread, hostId: 'durable', cwd: dotsTaskCwd(value.thread) };
-        if (method === 'thread/resume') value.cwd = value.thread.cwd;
-      }
-      return transform(value);
-    });
-  }
-
-  nativeRequest(method, params, transform) {
-    const socket = this.socket;
-    return super.request(method, params, transform).catch(error => {
-      if (error.code === 'app_server_request_timeout' && !error.deliveryResult && this.ready && this.socket === socket && !this.resetting) {
-        // An OPEN hosted socket can stop answering RPCs while still delivering
-        // notifications. Invalidate it once; reconnect through the existing
-        // observer lifecycle, never replay the request whose outcome is unknown.
-        this.ready = false;
-        const resetting = new Promise(resolve => socket.once('close', resolve)).finally(() => {
-          if (this.resetting === resetting) this.resetting = null;
-        });
-        this.resetting = resetting;
-        console.warn(JSON.stringify({ time: new Date().toISOString(), event: 'dots-connection-reset',
-          reason: error.code, method, threadId: params?.threadId }));
-        socket.terminate();
-      }
-      throw error;
-    });
-  }
-
-  watchCatalogTask(threadId) {
-    return this.watchExecution(threadId, 'aeon_child');
-  }
-
-  watchExecution(threadId, expectedSource) {
-    const current = this.catalogWatches.get(threadId);
-    if (current) return current;
-    // Hosted thread/list does not subscribe to task notifications. Resume only
-    // metadata, with no settings overrides or history window, to register a watch.
-    // A slow background watch does not prove the shared socket has stalled.
-    // Keep foreground history/streams alive; this read reports its own failure.
-    const work = super.request('thread/resume', { threadId, excludeTurns: true }).then(result => {
-      if (result.thread.threadSource !== expectedSource) throw new Error('执行订阅返回了不同来源的对话。');
-    }).catch(error => {
-      if (this.catalogWatches.get(threadId) === work) this.catalogWatches.delete(threadId);
-      throw error;
-    });
-    this.catalogWatches.set(threadId, work);
-    return work;
-  }
-
-  async latestTaskState(threadId, refresh = false) {
-    const record = this.threads.get(threadId);
-    const epoch = this.epoch, sequence = record?.sequence;
-    let turn;
-    if (!refresh && record && !record.needsReload && !record.hydrating && !record.historyTrimmed) {
-      turn = record.thread.turns.at(-1);
-    } else {
-      const page = await this.initialTurnsPage(threadId);
-      if (epoch !== this.epoch) throw new Error('云端连接已变化，请重新核对任务状态。');
-      const current = this.threads.get(threadId);
-      // Live events received during the metadata read outrank its older result.
-      turn = current && current.sequence !== sequence ? current.thread.turns.at(-1) : page.data[0];
-      if (current && !current.hydrating && dotsTaskRevision(current.thread.turns.at(-1)) !== dotsTaskRevision(turn)) {
-        current.needsReload = true;
-      }
-    }
-    return { chatRevision: dotsTaskRevision(turn), lastTurnStatus: turn?.status || null };
-  }
-
-  async timeline(threadId, pageOptions = {}, knownSync) {
-    const result = await super.timeline(threadId, { ...pageOptions, maxTurns: 1 }, knownSync);
-    result.thread.chatRevision = dotsTaskRevision(this.threads.get(threadId)?.thread.turns.at(-1));
-    await this.saveHistoryWindow(threadId, true);
-    return result;
-  }
-
-  async source(threadId, expected) {
-    let source = this.threadSources.get(threadId);
-    if (!source) {
-      await this.connect();
-      const { thread } = await this.nativeRequest('thread/read', { threadId, includeTurns: false });
-      source = thread.threadSource; this.threadSources.set(threadId, source);
-    }
-    if (!['aeon', 'aeon_child'].includes(source) || expected && source !== expected) throw new Error('该会话不是对应的 Dots 对话。');
-    return source;
-  }
-
-  notification(method, params) {
-    if (['thread/started', 'thread/archived', 'thread/unarchived', 'thread/deleted',
-      'thread/name/updated', 'thread/status/changed', 'thread/project/updated', 'turn/started', 'turn/completed'].includes(method)) {
-      this.catalogPages.clear();
-    }
-    if (this.threadSources.get(params.threadId) === 'aeon') this.serverRequests.notification(method, params);
-    if (params.thread?.threadSource) this.threadSources.set(params.thread.id, params.thread.threadSource);
-    this.emit('host-notification', { method, params });
-    if (this.threadSources.get(params.threadId || params.thread?.id) !== 'aeon') {
-      this.invalidateHistory(method, params);
-      super.notification(method, params);
-    }
-  }
-
-  async unsubscribeThread() {
-    // Page interest is local; the hosted watch/window last until socket disconnect.
-    // Do not turn page closure into thread/stop or another execution command.
-  }
-
-  keepThreadLoaded(_threadId, record) {
-    // Hosted watches last for the socket, independently of phone snapshot tokens.
-    return this.ready && Boolean(record && !record.readOnly);
-  }
-
-  isThreadObserved(threadId, record) { return this.keepThreadLoaded(threadId, record); }
-
-  async resumeTimeline(threadId, apply, options = {}) {
-    // The hosted protocol loads history separately. Register the resumed thread
-    // before requesting its page so notifications can update the hydrating record.
-    const scope = this.historyScope(threadId), head = options.reconcileObserved ? null : await this.restoreHistoryHead(threadId);
-    return this.request('thread/resume', { threadId, excludeTurns: true }, value => {
-      if (scope !== this.historyScope(threadId)) throw new Error('云端账号连接已变化，请重新读取历史。');
-      this.diskHeads.set(threadId, { head, updatedAt: value.thread.updatedAt, scope });
-      return apply({ ...value, initialTurnsPage: { data: [], nextCursor: null } });
-    });
-  }
-
-  async history(threadId, cursor, options = {}) {
-    await this.connect(); await this.source(threadId, 'aeon_child');
-    return super.history(threadId, cursor, options);
-  }
-
-  initialTurnsPage(threadId) {
-    return this.request('thread/turns/list', {
-      threadId, limit: 1, sortDirection: 'desc', itemsView: 'notLoaded',
-    });
-  }
-
-  async models() {
-    await this.connect();
-    const models = []; let cursor;
-    do {
-      const result = await this.request('model/list', { limit: 100, ...(cursor ? { cursor } : {}) });
-      models.push(...result.data); cursor = result.nextCursor;
-    } while (cursor);
-    // Hosted app-server has model/list but no local config/read.
-    return { models: models.filter(model => !model.hidden), enabledReasoningEfforts: null };
-  }
-
-  async readContext(threadId, refreshSettings = false) {
-    if (refreshSettings) {
-      await this.connect();
-      const previous = this.settingsNotifications.get(threadId);
-      // Hosted thread/read can report stored defaults even after a turn override.
-      // Resume without overrides reads the live settings, as Desktop does.
-      const settings = await this.request('thread/resume', { threadId, excludeTurns: true });
-      if (settings.model && this.settingsNotifications.get(threadId) === previous) {
-        this.contexts.set(threadId, { ...this.contexts.get(threadId), model: settings.model,
-          thinking: settings.reasoningEffort, serviceTier: settings.serviceTier ?? null });
-      }
-    }
-    return this.context(threadId);
-  }
-
-  async send(args) {
-    const { uploadFiles = [], ...turnArgs } = args;
-    let assertCurrent;
-    try {
-      await this.connect();
-      const record = this.threads.get(args.threadId);
-      if (!record || record.needsReload) await this.timeline(args.threadId);
-      if (uploadFiles.length) {
-        this.requireWritable(args.threadId);
-        const epoch = this.epoch, identity = this.profileIdentity;
-        const current = () => {
-          if (epoch !== this.epoch || identity !== this.profileIdentity || !this.ready) throw new Error('云端连接已变化，请核对后发送。');
-        };
-        assertCurrent = current;
-        const references = await uploadTaskFiles(uploadFiles, { uploadsRoot: this.uploadsRoot, client: this.filesClient, current });
-        current();
-        const text = turnArgs.input.filter(item => item.type === 'text').map(item => item.text).join('\n');
-        turnArgs.input = [{ type: 'text', text: taskFilePrompt(text, references) }, ...turnArgs.input.filter(item => item.type !== 'text')];
-      }
-    } catch (error) { error.deliveryUnknown = false; throw error; }
-    return super.send(turnArgs, { assertCurrent });
-  }
-
-  async interrupt(threadId) {
-    await this.connect();
-    this.requireWritable(threadId);
-    const result = await this.request('thread/stop', { threadId });
-    const record = this.threads.get(threadId);
-    if (record) record.needsReload = true;
-    return result;
-  }
-
-  async taskCatalog(archived = false, refresh = false) {
-    await this.connect();
-    const cached = this.catalogPages.get(archived);
-    if (cached?.work) return cached.work;
-    if (!refresh && cached?.tasks && Date.now() - cached.at < 30000) return cached.tasks;
-    const identity = this.profileIdentity;
-    const entry = {};
-    const work = this.readTaskCatalog(archived).then(tasks => {
-      if (identity !== this.profileIdentity) throw new Error('点点账号已变化，请重新读取目录。');
-      entry.tasks = tasks; entry.at = Date.now();
-      return tasks;
-    }).finally(() => { entry.work = null; });
-    entry.work = work;
-    this.catalogPages.set(archived, entry);
-    return work;
-  }
-
-  async readTaskCatalog(archived) {
-    const tasks = [];
-    let cursor;
-    do {
-      const page = await this.request('thread/list', {
-        // Hosted recency_at can omit existing delegated threads with no cursor.
-        // Fetch by updated_at; the merged catalog still uses each thread's recency.
-        limit: 100, sortKey: 'updated_at', sortDirection: 'desc', archived,
-        ...(cursor ? { cursor } : {}),
-      });
-      for (const thread of page.data) this.threadSources.set(thread.id, thread.threadSource);
-      tasks.push(...page.data.filter(thread => ['aeon', 'aeon_child'].includes(thread.threadSource))
-        .map(thread => ({ ...thread, cwd: dotsTaskCwd(thread) })));
-      cursor = page.nextCursor;
-    } while (cursor);
-    return tasks;
-  }
-
-  async catalog(archived = false, refresh = false) {
-    const tasks = await this.taskCatalog(archived, refresh);
-    await this.refreshProfiles();
-    this.refreshLiveProfiles();
-    // Subscription failure must not discard an authoritative catalog snapshot.
-    // Watches continue independently; failed watches are retried by the next catalog read.
-    if (!archived) for (const thread of tasks.filter(thread => thread.threadSource === 'aeon_child')) {
-      void this.watchCatalogTask(thread.id).catch(error => {
-        console.error('Dots 任务订阅失败：', thread.id, error.message);
-      });
-    }
-    return [...tasks.filter(thread => thread.threadSource === 'aeon_child'),
-      ...(archived ? [] : this.liveRoots.values())].map(thread => thread.threadSource === 'aeon' ? { ...thread,
-      name: this.profileName(thread.id), avatar: this.profileAvatar(thread.id), color: this.profileColor(thread.id) } : thread);
-  }
-
-  async tasks(archived = false) { return (await this.taskCatalog(archived)).filter(thread => thread.threadSource === 'aeon_child'); }
-
-  async refreshProfiles() {
-    const identity = this.profileIdentity;
-    const names = identity ? await this.readProfiles(identity) : new Map();
-    if (identity !== this.profileIdentity) throw new Error('点点账号已变化，请重新读取目录。');
-    const byProfile = new Map([...this.liveProfiles.values()].map(profile => [profile.profileId, profile]));
-    for (const [id, profile] of names) {
-      if (byProfile.has(profile.profileId)) names.set(id, byProfile.get(profile.profileId));
-    }
-    for (const [id, profile] of this.liveProfiles) names.set(id, byProfile.get(profile.profileId));
-    for (const [id, profile] of names) {
-      const previous = this.profileNames.get(id);
-      if (previous?.avatar && previous.avatarFileId === profile.avatarFileId) profile.avatar = previous.avatar;
-    }
-    if (identity === this.profileIdentity) this.profileNames = names;
-  }
-
-  refreshLiveProfiles() {
-    if (this.profileRefresh || Date.now() - this.profileAttemptAt < 60000) return;
-    const identity = this.profileIdentity;
-    this.profileAttemptAt = Date.now();
-    const snapshot = () => JSON.stringify([[...this.profileNames], [...this.liveRoots]]);
-    let published = snapshot();
-    const publish = () => {
-      const next = snapshot();
-      if (identity !== this.profileIdentity || published === next) return;
-      published = next;
-      this.emit('notification', { method: 'thread/name/updated', params: {} });
-    };
-    const work = (async () => {
-      try {
-        const { profiles: live, rootThreadIds } = await readDotsCatalog(this.localServer, identity);
-        if (identity !== this.profileIdentity) return;
-        const roots = new Map();
-        for (const threadId of rootThreadIds) {
-          const { thread } = await this.nativeRequest('thread/read', { threadId, includeTurns: false });
-          if (identity !== this.profileIdentity) return;
-          if (thread.id !== threadId || thread.threadSource !== 'aeon') throw new Error('点点目录返回了非主线程。');
-          roots.set(threadId, { ...thread, cwd: dotsTaskCwd(thread) });
-        }
-        if (identity !== this.profileIdentity) return;
-        this.liveProfiles = live;
-        this.liveRoots = roots;
-        for (const id of roots.keys()) this.threadSources.set(id, 'aeon');
-        await this.refreshProfiles();
-        publish();
-      } catch (error) {
-        if (identity !== this.profileIdentity) return;
-        this.emit('profile-error', error);
-      }
-      await Promise.all([...new Set(this.profileNames.values())].map(async profile => {
-        try { profile.avatar = await this.readAvatar(profile, identity); }
-        catch (error) { this.emit('profile-error', error); }
-      }));
-      publish();
-      if (identity === this.profileIdentity && this.liveProfiles.size) await this.readProfiles.save?.(identity, this.liveProfiles);
-    })().catch(error => this.emit('profile-error', error))
-      .finally(() => { if (this.profileRefresh === work) this.profileRefresh = null; });
-    this.profileRefresh = work;
-  }
-
-  profileName(threadId) { return this.profileNames.get(threadId)?.name || 'Dots'; }
-  profileAvatar(threadId) { return this.profileNames.get(threadId)?.avatar || ''; }
-  profileColor(threadId) { return this.profileNames.get(threadId)?.color || ''; }
-}
-
-function dotsTaskCwd(thread) {
-  return thread.environments?.[0]?.cwd || thread.cwd;
-}
-
-export async function readDotsTasks(localAppServerUrl) {
-  const local = new SharedAppServer(localAppServerUrl);
-  const cloud = new DotsAppServer(local);
-  try {
-    const tasks = await cloud.tasks();
-    const summaries = await Promise.all(tasks.map(async thread => {
-      const turns = await cloud.request('thread/turns/list', {
-        threadId: thread.id, limit: 1, sortDirection: 'desc', itemsView: 'notLoaded',
-      });
-      const latest = turns.data[0];
-      return {
-        id: thread.id, hostId: 'durable', threadSource: thread.threadSource,
-        title: thread.name || thread.preview || '', model: thread.model,
-        cwd: thread.environments?.[0]?.cwd || thread.cwd,
-        environments: thread.environments, createdAt: thread.createdAt, updatedAt: thread.updatedAt,
-        recencyAt: thread.recencyAt ?? thread.updatedAt, status: thread.status?.type,
-        latestTurn: latest ? { id: latest.id, status: latest.status,
-          startedAt: latest.startedAt, completedAt: latest.completedAt, error: latest.error } : null,
-      };
-    }));
-    return { source: 'codex-cloud-app-server', readAt: new Date().toISOString(), tasks: summaries };
-  } finally {
-    cloud.close();
-    local.close();
-  }
-}
+import WebSocket from 'ws';
+import { HostedHistoryAppServer } from './hosted-history-app-server.mjs';
+import { createDotsAvatarReader } from './dots-avatar.mjs';
+import { readDotsCatalog } from './dots-profile.mjs';
+import { DotsRoomClient } from './dots-room-client.mjs';
+import { uploadTaskFiles, taskFilePrompt } from './dots-task-files.mjs';
+
+const hostedAppServerUrl = 'wss://codex-cloud-backend.chatgpt.com/';
+export const dotsTaskRevision = turn => turn ? JSON.stringify([turn.id, turn.status]) : '';
+
+// Dots delegated tasks live in Desktop's durable host. Reuse the app-server
+// protocol client; only the authenticated transport differs from the local host.
+export class DotsAppServer extends HostedHistoryAppServer {
+  constructor(localServer, readProfiles = async () => new Map(), historyCache = null, { uploadsRoot } = {}) {
+    super(localServer.url, historyCache);
+    this.historySource = 'aeon_child';
+    this.localServer = localServer;
+    this.uploadsRoot = uploadsRoot;
+    this.filesClient = new DotsRoomClient(this);
+    this.url = hostedAppServerUrl;
+    this.threadSources = new Map();
+    this.catalogWatches = new Map();
+    this.readProfiles = readProfiles;
+    this.readAvatar = createDotsAvatarReader(localServer);
+    this.profileNames = new Map();
+    this.liveProfiles = new Map();
+    this.liveRoots = new Map();
+    this.rootIdentity = null;
+    this.catalogPages = new Map();
+    this.profileRefresh = null;
+    this.profileAttemptAt = 0;
+    this.on('turn', ({ thread }) => {
+      thread.chatRevision = dotsTaskRevision(thread.turns.at(-1));
+      this.saveHistoryWindow(thread.id);
+    });
+    this.on('disconnected', () => {
+      this.filesClient.close();
+      this.profileIdentity = null;
+      this.catalogPages.clear(); this.profileRefresh = null; this.profileAttemptAt = 0;
+      this.catalogWatches.clear();
+    });
+  }
+
+  get historyIdentity() { return this.profileIdentity; }
+
+  async connect() {
+    if (this.resetting) await this.resetting;
+    if (this.connecting) return this.connecting;
+    return super.connect();
+  }
+
+  async open() {
+    await super.open();
+    const socket = this.socket, identity = this.profileIdentity;
+    // Load confirmed display metadata before chat snapshots can publish a name
+    // or avatar. This reads local state, not the slow live profile request.
+    await this.refreshProfiles().catch(error => this.emit('profile-error', error));
+    if (!this.ready || this.socket !== socket || this.profileIdentity !== identity) throw new Error('点点连接已变化，请重新连接。');
+    this.emit('connected');
+  }
+
+  setProfileIdentity(identity) {
+    const key = JSON.stringify([identity.accountId, identity.userId]);
+    if (this.rootIdentity !== key) {
+      this.liveRoots.clear(); this.profileNames.clear(); this.liveProfiles.clear();
+    }
+    this.profileIdentity = identity; this.rootIdentity = key;
+  }
+
+  async openSocket() {
+    await this.localServer.connect();
+    const auth = await this.localServer.request('getAuthStatus', { includeToken: true, refreshToken: false });
+    if (!['chatgpt', 'chatgptAuthTokens'].includes(auth.authMethod) || !auth.authToken) {
+      throw new Error('读取 Dots 任务需要 Codex 内核已登录 ChatGPT。');
+    }
+    const identity = JSON.parse(Buffer.from(auth.authToken.split('.')[1], 'base64url').toString('utf8'));
+    const accountId = identity['https://api.openai.com/auth']?.chatgpt_account_id;
+    if (!accountId) throw new Error('Codex 内核没有可用于读取 Dots 任务的 ChatGPT 账号身份。');
+    this.setProfileIdentity({ accountId, userId: identity['https://api.openai.com/auth']?.chatgpt_user_id });
+    // Credentials stay in this process and go only to the fixed official host.
+    return new WebSocket(hostedAppServerUrl,
+      ['codex-app-server', 'codex-client.desktop', `openai-bearer.${auth.authToken}`], {
+        headers: { 'ChatGPT-Account-Id': accountId, 'X-OpenAI-Product-Sku': 'codex' },
+        handshakeTimeout: 15000,
+      });
+  }
+
+  request(method, params, transform = value => value) {
+    return this.nativeRequest(method, params, value => {
+      if (method === 'thread/read' || method === 'thread/resume') {
+        if (value.thread.threadSource !== 'aeon_child') throw new Error('该会话不是 Dots 委派任务。');
+        value.thread = { ...value.thread, hostId: 'durable', cwd: dotsTaskCwd(value.thread) };
+        if (method === 'thread/resume') value.cwd = value.thread.cwd;
+      }
+      return transform(value);
+    });
+  }
+
+  nativeRequest(method, params, transform) {
+    const socket = this.socket;
+    return super.request(method, params, transform).catch(error => {
+      if (error.code === 'app_server_request_timeout' && !error.deliveryResult && this.ready && this.socket === socket && !this.resetting) {
+        // An OPEN hosted socket can stop answering RPCs while still delivering
+        // notifications. Invalidate it once; reconnect through the existing
+        // observer lifecycle, never replay the request whose outcome is unknown.
+        this.ready = false;
+        const resetting = new Promise(resolve => socket.once('close', resolve)).finally(() => {
+          if (this.resetting === resetting) this.resetting = null;
+        });
+        this.resetting = resetting;
+        console.warn(JSON.stringify({ time: new Date().toISOString(), event: 'dots-connection-reset',
+          reason: error.code, method, threadId: params?.threadId }));
+        socket.terminate();
+      }
+      throw error;
+    });
+  }
+
+  watchCatalogTask(threadId) {
+    return this.watchExecution(threadId, 'aeon_child');
+  }
+
+  watchExecution(threadId, expectedSource) {
+    const current = this.catalogWatches.get(threadId);
+    if (current) return current;
+    // Hosted thread/list does not subscribe to task notifications. Resume only
+    // metadata, with no settings overrides or history window, to register a watch.
+    // A slow background watch does not prove the shared socket has stalled.
+    // Keep foreground history/streams alive; this read reports its own failure.
+    const work = super.request('thread/resume', { threadId, excludeTurns: true }).then(result => {
+      if (result.thread.threadSource !== expectedSource) throw new Error('执行订阅返回了不同来源的对话。');
+    }).catch(error => {
+      if (this.catalogWatches.get(threadId) === work) this.catalogWatches.delete(threadId);
+      throw error;
+    });
+    this.catalogWatches.set(threadId, work);
+    return work;
+  }
+
+  async latestTaskState(threadId, refresh = false) {
+    const record = this.threads.get(threadId);
+    const epoch = this.epoch, sequence = record?.sequence;
+    let turn;
+    if (!refresh && record && !record.needsReload && !record.hydrating && !record.historyTrimmed) {
+      turn = record.thread.turns.at(-1);
+    } else {
+      const page = await this.initialTurnsPage(threadId);
+      if (epoch !== this.epoch) throw new Error('云端连接已变化，请重新核对任务状态。');
+      const current = this.threads.get(threadId);
+      // Live events received during the metadata read outrank its older result.
+      turn = current && current.sequence !== sequence ? current.thread.turns.at(-1) : page.data[0];
+      if (current && !current.hydrating && dotsTaskRevision(current.thread.turns.at(-1)) !== dotsTaskRevision(turn)) {
+        current.needsReload = true;
+      }
+    }
+    return { chatRevision: dotsTaskRevision(turn), lastTurnStatus: turn?.status || null };
+  }
+
+  async timeline(threadId, pageOptions = {}, knownSync) {
+    const result = await super.timeline(threadId, { ...pageOptions, maxTurns: 1 }, knownSync);
+    result.thread.chatRevision = dotsTaskRevision(this.threads.get(threadId)?.thread.turns.at(-1));
+    await this.saveHistoryWindow(threadId, true);
+    return result;
+  }
+
+  async source(threadId, expected) {
+    let source = this.threadSources.get(threadId);
+    if (!source) {
+      await this.connect();
+      const { thread } = await this.nativeRequest('thread/read', { threadId, includeTurns: false });
+      source = thread.threadSource; this.threadSources.set(threadId, source);
+    }
+    if (!['aeon', 'aeon_child'].includes(source) || expected && source !== expected) throw new Error('该会话不是对应的 Dots 对话。');
+    return source;
+  }
+
+  notification(method, params) {
+    if (['thread/started', 'thread/archived', 'thread/unarchived', 'thread/deleted',
+      'thread/name/updated', 'thread/status/changed', 'thread/project/updated', 'turn/started', 'turn/completed'].includes(method)) {
+      this.catalogPages.clear();
+    }
+    if (this.threadSources.get(params.threadId) === 'aeon') this.serverRequests.notification(method, params);
+    if (params.thread?.threadSource) this.threadSources.set(params.thread.id, params.thread.threadSource);
+    this.emit('host-notification', { method, params });
+    if (this.threadSources.get(params.threadId || params.thread?.id) !== 'aeon') {
+      this.invalidateHistory(method, params);
+      super.notification(method, params);
+    }
+  }
+
+  async unsubscribeThread() {
+    // Page interest is local; the hosted watch/window last until socket disconnect.
+    // Do not turn page closure into thread/stop or another execution command.
+  }
+
+  keepThreadLoaded(_threadId, record) {
+    // Hosted watches last for the socket, independently of phone snapshot tokens.
+    return this.ready && Boolean(record && !record.readOnly);
+  }
+
+  isThreadObserved(threadId, record) { return this.keepThreadLoaded(threadId, record); }
+
+  async resumeTimeline(threadId, apply, options = {}) {
+    // The hosted protocol loads history separately. Register the resumed thread
+    // before requesting its page so notifications can update the hydrating record.
+    const scope = this.historyScope(threadId), head = options.reconcileObserved ? null : await this.restoreHistoryHead(threadId);
+    return this.request('thread/resume', { threadId, excludeTurns: true }, value => {
+      if (scope !== this.historyScope(threadId)) throw new Error('云端账号连接已变化，请重新读取历史。');
+      this.diskHeads.set(threadId, { head, updatedAt: value.thread.updatedAt, scope });
+      return apply({ ...value, initialTurnsPage: { data: [], nextCursor: null } });
+    });
+  }
+
+  async history(threadId, cursor, options = {}) {
+    await this.connect(); await this.source(threadId, 'aeon_child');
+    return super.history(threadId, cursor, options);
+  }
+
+  initialTurnsPage(threadId) {
+    return this.request('thread/turns/list', {
+      threadId, limit: 1, sortDirection: 'desc', itemsView: 'notLoaded',
+    });
+  }
+
+  async models() {
+    await this.connect();
+    const models = []; let cursor;
+    do {
+      const result = await this.request('model/list', { limit: 100, ...(cursor ? { cursor } : {}) });
+      models.push(...result.data); cursor = result.nextCursor;
+    } while (cursor);
+    // Hosted app-server has model/list but no local config/read.
+    return { models: models.filter(model => !model.hidden), enabledReasoningEfforts: null };
+  }
+
+  async readContext(threadId, refreshSettings = false) {
+    if (refreshSettings) {
+      await this.connect();
+      const previous = this.settingsNotifications.get(threadId);
+      // Hosted thread/read can report stored defaults even after a turn override.
+      // Resume without overrides reads the live settings, as Desktop does.
+      const settings = await this.request('thread/resume', { threadId, excludeTurns: true });
+      if (settings.model && this.settingsNotifications.get(threadId) === previous) {
+        this.contexts.set(threadId, { ...this.contexts.get(threadId), model: settings.model,
+          thinking: settings.reasoningEffort, serviceTier: settings.serviceTier ?? null });
+      }
+    }
+    return this.context(threadId);
+  }
+
+  async send(args) {
+    const { uploadFiles = [], ...turnArgs } = args;
+    let assertCurrent;
+    try {
+      await this.connect();
+      const record = this.threads.get(args.threadId);
+      if (!record || record.needsReload) await this.timeline(args.threadId);
+      if (uploadFiles.length) {
+        this.requireWritable(args.threadId);
+        const epoch = this.epoch, identity = this.profileIdentity;
+        const current = () => {
+          if (epoch !== this.epoch || identity !== this.profileIdentity || !this.ready) throw new Error('云端连接已变化，请核对后发送。');
+        };
+        assertCurrent = current;
+        const references = await uploadTaskFiles(uploadFiles, { uploadsRoot: this.uploadsRoot, client: this.filesClient, current });
+        current();
+        const text = turnArgs.input.filter(item => item.type === 'text').map(item => item.text).join('\n');
+        turnArgs.input = [{ type: 'text', text: taskFilePrompt(text, references) }, ...turnArgs.input.filter(item => item.type !== 'text')];
+      }
+    } catch (error) { error.deliveryUnknown = false; throw error; }
+    return super.send(turnArgs, { assertCurrent });
+  }
+
+  async interrupt(threadId) {
+    await this.connect();
+    this.requireWritable(threadId);
+    const result = await this.request('thread/stop', { threadId });
+    const record = this.threads.get(threadId);
+    if (record) record.needsReload = true;
+    return result;
+  }
+
+  async taskCatalog(archived = false, refresh = false) {
+    await this.connect();
+    const cached = this.catalogPages.get(archived);
+    if (cached?.work) return cached.work;
+    if (!refresh && cached?.tasks && Date.now() - cached.at < 30000) return cached.tasks;
+    const identity = this.profileIdentity;
+    const entry = {};
+    const work = this.readTaskCatalog(archived).then(tasks => {
+      if (identity !== this.profileIdentity) throw new Error('点点账号已变化，请重新读取目录。');
+      entry.tasks = tasks; entry.at = Date.now();
+      return tasks;
+    }).finally(() => { entry.work = null; });
+    entry.work = work;
+    this.catalogPages.set(archived, entry);
+    return work;
+  }
+
+  async readTaskCatalog(archived) {
+    const tasks = [];
+    let cursor;
+    do {
+      const page = await this.request('thread/list', {
+        // Hosted recency_at can omit existing delegated threads with no cursor.
+        // Fetch by updated_at; the merged catalog still uses each thread's recency.
+        limit: 100, sortKey: 'updated_at', sortDirection: 'desc', archived,
+        ...(cursor ? { cursor } : {}),
+      });
+      for (const thread of page.data) this.threadSources.set(thread.id, thread.threadSource);
+      tasks.push(...page.data.filter(thread => ['aeon', 'aeon_child'].includes(thread.threadSource))
+        .map(thread => ({ ...thread, cwd: dotsTaskCwd(thread) })));
+      cursor = page.nextCursor;
+    } while (cursor);
+    return tasks;
+  }
+
+  async catalog(archived = false, refresh = false) {
+    const tasks = await this.taskCatalog(archived, refresh);
+    await this.refreshProfiles();
+    this.refreshLiveProfiles();
+    // Subscription failure must not discard an authoritative catalog snapshot.
+    // Watches continue independently; failed watches are retried by the next catalog read.
+    if (!archived) for (const thread of tasks.filter(thread => thread.threadSource === 'aeon_child')) {
+      void this.watchCatalogTask(thread.id).catch(error => {
+        console.error('Dots 任务订阅失败：', thread.id, error.message);
+      });
+    }
+    return [...tasks.filter(thread => thread.threadSource === 'aeon_child'),
+      ...(archived ? [] : this.liveRoots.values())].map(thread => thread.threadSource === 'aeon' ? { ...thread,
+      name: this.profileName(thread.id), avatar: this.profileAvatar(thread.id), color: this.profileColor(thread.id) } : thread);
+  }
+
+  async tasks(archived = false) { return (await this.taskCatalog(archived)).filter(thread => thread.threadSource === 'aeon_child'); }
+
+  async refreshProfiles() {
+    const identity = this.profileIdentity;
+    const names = identity ? await this.readProfiles(identity) : new Map();
+    if (identity !== this.profileIdentity) throw new Error('点点账号已变化，请重新读取目录。');
+    const byProfile = new Map([...this.liveProfiles.values()].map(profile => [profile.profileId, profile]));
+    for (const [id, profile] of names) {
+      if (byProfile.has(profile.profileId)) names.set(id, byProfile.get(profile.profileId));
+    }
+    for (const [id, profile] of this.liveProfiles) names.set(id, byProfile.get(profile.profileId));
+    for (const [id, profile] of names) {
+      const previous = this.profileNames.get(id);
+      if (previous?.avatar && previous.avatarFileId === profile.avatarFileId) profile.avatar = previous.avatar;
+    }
+    if (identity === this.profileIdentity) this.profileNames = names;
+  }
+
+  refreshLiveProfiles() {
+    if (this.profileRefresh || Date.now() - this.profileAttemptAt < 60000) return;
+    const identity = this.profileIdentity;
+    this.profileAttemptAt = Date.now();
+    const snapshot = () => JSON.stringify([[...this.profileNames], [...this.liveRoots]]);
+    let published = snapshot();
+    const publish = () => {
+      const next = snapshot();
+      if (identity !== this.profileIdentity || published === next) return;
+      published = next;
+      this.emit('notification', { method: 'thread/name/updated', params: {} });
+    };
+    const work = (async () => {
+      try {
+        const { profiles: live, rootThreadIds } = await readDotsCatalog(this.localServer, identity);
+        if (identity !== this.profileIdentity) return;
+        const roots = new Map();
+        for (const threadId of rootThreadIds) {
+          const { thread } = await this.nativeRequest('thread/read', { threadId, includeTurns: false });
+          if (identity !== this.profileIdentity) return;
+          if (thread.id !== threadId || thread.threadSource !== 'aeon') throw new Error('点点目录返回了非主线程。');
+          roots.set(threadId, { ...thread, cwd: dotsTaskCwd(thread) });
+        }
+        if (identity !== this.profileIdentity) return;
+        this.liveProfiles = live;
+        this.liveRoots = roots;
+        for (const id of roots.keys()) this.threadSources.set(id, 'aeon');
+        await this.refreshProfiles();
+        publish();
+      } catch (error) {
+        if (identity !== this.profileIdentity) return;
+        this.emit('profile-error', error);
+      }
+      await Promise.all([...new Set(this.profileNames.values())].map(async profile => {
+        try { profile.avatar = await this.readAvatar(profile, identity); }
+        catch (error) { this.emit('profile-error', error); }
+      }));
+      publish();
+      if (identity === this.profileIdentity && this.liveProfiles.size) await this.readProfiles.save?.(identity, this.liveProfiles);
+    })().catch(error => this.emit('profile-error', error))
+      .finally(() => { if (this.profileRefresh === work) this.profileRefresh = null; });
+    this.profileRefresh = work;
+  }
+
+  profileName(threadId) { return this.profileNames.get(threadId)?.name || 'Dots'; }
+  profileAvatar(threadId) { return this.profileNames.get(threadId)?.avatar || ''; }
+  profileColor(threadId) { return this.profileNames.get(threadId)?.color || ''; }
+}
+
+function dotsTaskCwd(thread) {
+  return thread.environments?.[0]?.cwd || thread.cwd;
+}
+
+export async function readDotsTasks(localAppServerUrl) {
+  const local = new SharedAppServer(localAppServerUrl);
+  const cloud = new DotsAppServer(local);
+  try {
+    const tasks = await cloud.tasks();
+    const summaries = await Promise.all(tasks.map(async thread => {
+      const turns = await cloud.request('thread/turns/list', {
+        threadId: thread.id, limit: 1, sortDirection: 'desc', itemsView: 'notLoaded',
+      });
+      const latest = turns.data[0];
+      return {
+        id: thread.id, hostId: 'durable', threadSource: thread.threadSource,
+        title: thread.name || thread.preview || '', model: thread.model,
+        cwd: thread.environments?.[0]?.cwd || thread.cwd,
+        environments: thread.environments, createdAt: thread.createdAt, updatedAt: thread.updatedAt,
+        recencyAt: thread.recencyAt ?? thread.updatedAt, status: thread.status?.type,
+        latestTurn: latest ? { id: latest.id, status: latest.status,
+          startedAt: latest.startedAt, completedAt: latest.completedAt, error: latest.error } : null,
+      };
+    }));
+    return { source: 'codex-cloud-app-server', readAt: new Date().toISOString(), tasks: summaries };
+  } finally {
+    cloud.close();
+    local.close();
+  }
+}