@walkhi/code-relax 0.1.0-beta.1 → 0.1.0-beta.2

package/dist/web/station-connection-controller.js

@@ -0,0 +1,75 @@
+(function (root) {
+  function createStationConnectionController(options) {
+    let recoveryTask = null;
+    let epoch = 0;
+    let paused = false;
+
+    function isCurrent(value) {
+      return !paused && value === epoch;
+    }
+
+    function suspend() {
+      paused = true;
+      epoch++;
+      recoveryTask = null;
+      options.onSuspend?.();
+    }
+
+    function activate() {
+      paused = false;
+    }
+
+    function recover() {
+      if (paused) return Promise.resolve();
+      if (recoveryTask) return recoveryTask;
+      const recoveryEpoch = ++epoch;
+      recoveryTask = Promise.resolve().then(async () => {
+        let attempts = 0;
+        options.onStarted?.();
+        while (isCurrent(recoveryEpoch)) {
+          options.onAttempt?.();
+          try {
+            await options.connect();
+            if (!isCurrent(recoveryEpoch)) return;
+            try { await options.restore(); }
+            catch (error) {
+              if (!isCurrent(recoveryEpoch)) return;
+              if (options.isConnected?.()) {
+                options.onRestoreFailure?.(error);
+                return;
+              }
+              throw error;
+            }
+            if (!isCurrent(recoveryEpoch)) return;
+            options.onRecovered?.(attempts + 1);
+            return;
+          } catch (error) {
+            if (!isCurrent(recoveryEpoch)) return;
+            if (options.isTerminal(error)) {
+              options.onTerminal?.(error);
+              return;
+            }
+            options.onRetry?.(error, attempts + 1);
+            const delay = Math.min(1000 * 2 ** Math.min(attempts++, 5), 30000) * (0.8 + Math.random() * 0.2);
+            await new Promise(resolve => setTimeout(resolve, delay));
+          }
+        }
+      }).finally(() => {
+        if (recoveryEpoch === epoch) recoveryTask = null;
+      });
+      return recoveryTask;
+    }
+
+    return Object.freeze({
+      recover,
+      suspend,
+      activate,
+      isPaused: () => paused,
+      isRecovering: () => Boolean(recoveryTask),
+      generation: () => epoch,
+      isCurrent,
+    });
+  }
+
+  root.createStationConnectionController = createStationConnectionController;
+})(globalThis);

package/dist/web/task-list-view.js

@@ -0,0 +1,296 @@
+(function (root, factory) {
+  const create = factory();
+  if (typeof module === 'object' && module.exports) module.exports = create;
+  else root.createTaskListView = create;
+})(globalThis, function () {
+  function createTaskListView(options) {
+    const {
+      document, el, state, archiveBusy, archivedThreadsEntryVisible,
+      archiveSupported, isThreadRunning, isThreadWaitingForApproval,
+      resolvedThreadTitle, statusText, onSelectThread, onArchiveThread,
+      onOpenNewThread, onFeedback,
+    } = options;
+    function statusIcon(className, label, text = '') {
+      const icon = document.createElement('span');
+      icon.className = className;
+      icon.textContent = text;
+      icon.title = label;
+      icon.setAttribute('role', 'status');
+      icon.setAttribute('aria-label', label);
+      return icon;
+    }
+
+    function projectFolderIcon(closed) {
+      const namespace = 'http://www.w3.org/2000/svg';
+      const folder = document.createElement('span');
+      folder.className = 'project-folder';
+      folder.setAttribute('aria-hidden', 'true');
+      const svg = document.createElementNS(namespace, 'svg');
+      svg.setAttribute('viewBox', '0 0 18 18');
+      const path = document.createElementNS(namespace, 'path');
+      path.setAttribute('d', closed
+        ? 'M2.25 6.25V5.1c0-.9.73-1.63 1.63-1.63h3.06l1.42 1.45h5.76c.9 0 1.63.73 1.63 1.63v6.35c0 .9-.73 1.63-1.63 1.63H3.88c-.9 0-1.63-.73-1.63-1.63V6.25Z'
+        : 'M2.25 12.9V5.1c0-.9.73-1.63 1.63-1.63h3.06l1.42 1.45h5.76c.9 0 1.63.73 1.63 1.63v1.12 M2.4 12.84l1.63-3.66c.25-.57.81-.93 1.43-.93h9.31c.71 0 1.19.72.92 1.37l-1.55 3.66c-.32.76-1.06 1.25-1.88 1.25H3.49c-.86 0-1.44-.9-1.09-1.69Z');
+      svg.append(path);
+      folder.append(svg);
+      return folder;
+    }
+
+    function newThreadIcon() {
+      const namespace = 'http://www.w3.org/2000/svg';
+      const svg = document.createElementNS(namespace, 'svg');
+      svg.setAttribute('viewBox', '0 0 18 18');
+      const frame = document.createElementNS(namespace, 'path');
+      frame.setAttribute('d', 'M7.3 3H4.5A1.5 1.5 0 0 0 3 4.5v9A1.5 1.5 0 0 0 4.5 15h9a1.5 1.5 0 0 0 1.5-1.5v-2.8');
+      const pencil = document.createElementNS(namespace, 'path');
+      pencil.setAttribute('d', 'm7.1 10.9.35-2.05 5.7-5.7a1.2 1.2 0 0 1 1.7 1.7l-5.7 5.7-2.05.35Z M12.25 4.05l1.7 1.7');
+      svg.append(frame, pencil);
+      return svg;
+    }
+
+    function projectActions(project, projectId) {
+      const actions = document.createElement('div');
+      actions.className = 'project-actions';
+      const more = document.createElement('button');
+      more.className = 'project-action more';
+      more.type = 'button';
+      more.textContent = '···';
+      more.title = '更多操作（暂未实现）';
+      more.setAttribute('aria-label', more.title);
+      more.setAttribute('aria-disabled', 'true');
+      const create = document.createElement('button');
+      create.className = 'project-action create-thread';
+      create.type = 'button';
+      create.title = '新建对话';
+      create.setAttribute('aria-label', create.title);
+      create.append(newThreadIcon());
+      create.onclick = () => onOpenNewThread(project, projectId);
+      actions.append(more, create);
+      return actions;
+    }
+
+    function bindTaskSwipe(wrapper, button, action, onCommit) {
+      let startX = 0, startY = 0, direction = '', suppressClick = false;
+      let pointerId = null, distance = 0, threshold = 81;
+      const label = action.textContent;
+      const reset = () => {
+        button.style.removeProperty('transition');
+        button.style.removeProperty('transform');
+        wrapper.classList.remove('swiping', 'swipe-ready');
+        wrapper.style.removeProperty('--swipe-offset');
+        wrapper.style.removeProperty('--swipe-progress');
+        action.textContent = label;
+        const captured = pointerId;
+        pointerId = null;
+        if (captured !== null && button.hasPointerCapture(captured)) button.releasePointerCapture(captured);
+      };
+      button.addEventListener('pointerdown', event => {
+        if (event.button !== 0 || !event.isPrimary) return;
+        pointerId = event.pointerId;
+        button.setPointerCapture(pointerId);
+        startX = event.clientX; startY = event.clientY;
+        threshold = Math.min(102, Math.max(81, wrapper.clientWidth * .31875));
+        wrapper.style.setProperty('--swipe-threshold', `${threshold}px`);
+        distance = 0; direction = ''; suppressClick = false;
+        button.style.transition = 'none';
+      });
+      button.addEventListener('pointermove', event => {
+        if (event.pointerId !== pointerId) return;
+        const dx = event.clientX - startX, dy = event.clientY - startY;
+        if (!direction && Math.max(Math.abs(dx), Math.abs(dy)) < 8) return;
+        if (!direction) direction = Math.abs(dx) > Math.abs(dy) * 1.15 ? 'horizontal' : 'vertical';
+        if (direction !== 'horizontal') return;
+        suppressClick = true;
+        distance = Math.max(0, -dx);
+        const offset = Math.min(distance, threshold) + Math.max(0, distance - threshold) * .25;
+        button.style.transform = `translateX(${-offset}px)`;
+        wrapper.classList.add('swiping');
+        wrapper.classList.toggle('swipe-ready', distance >= threshold);
+        wrapper.style.setProperty('--swipe-progress', String(Math.min(1, distance / threshold)));
+        action.textContent = distance >= threshold ? `松手${label}` : `左滑${label}`;
+        wrapper.style.setProperty('--swipe-offset', `${offset}px`);
+      });
+      button.addEventListener('pointerup', event => {
+        if (event.pointerId !== pointerId) return;
+        const commit = direction === 'horizontal' && distance >= threshold;
+        reset();
+        if (commit) onCommit();
+      });
+      const cancel = event => {
+        if (event.pointerId !== pointerId) return;
+        reset(); direction = '';
+      };
+      button.addEventListener('pointercancel', cancel);
+      button.addEventListener('lostpointercapture', event => { if (event.target === button) cancel(event); });
+      button.addEventListener('click', event => {
+        if (!suppressClick) return;
+        event.preventDefault(); event.stopImmediatePropagation(); suppressClick = false;
+      }, true);
+    }
+
+    function render() {
+      const container = el('tasks');
+      const scrollOwner = document.body.classList.contains('embedded-terminal') ? container : container.closest('aside');
+      const previousScrollTop = scrollOwner?.scrollTop || 0;
+      container.replaceChildren();
+      const projectsById = new Map(state.projects.map(project => [project.projectId, project]));
+      const groups = new Map();
+      for (const project of state.projects) groups.set(project.projectId, []);
+      const visibleThreads = state.showingArchived ? state.archivedThreads : state.threads;
+      el('archivedThreads').hidden = !archivedThreadsEntryVisible || !archiveSupported();
+      el('archivedThreadsLabel').textContent = state.showingArchived ? '返回对话' : '已归档对话';
+      document.querySelector('.sidebar-title').textContent = state.showingArchived ? '已归档 · 左滑恢复' : '项目';
+      for (const thread of visibleThreads) {
+        const groupId = thread.projectId || '__unassigned__';
+        if (!groups.has(groupId)) groups.set(groupId, []);
+        groups.get(groupId).push(thread);
+      }
+
+      for (const [projectId, threads] of groups) {
+        if (!threads.length && projectId === '__unassigned__') continue;
+        const project = projectsById.get(projectId);
+        const group = document.createElement('div');
+        const recent = projectId === '__unassigned__';
+        const collapsed = !recent && state.collapsedProjects.has(projectId);
+        const hasApprovalTask = threads.some(isThreadWaitingForApproval);
+        const hasRunningTask = threads.some(isThreadRunning);
+        const hasUnreadTask = threads.some(thread => state.unreadThreads.has(thread.id));
+        group.className = `project${recent ? ' recent' : ''}${collapsed ? ' collapsed' : ''}`;
+        if (recent) {
+          const heading = document.createElement('div');
+          heading.className = 'recent-heading';
+          heading.textContent = '最近';
+          group.append(heading);
+        } else {
+          const header = document.createElement('div');
+          header.className = 'project-header';
+          const toggle = document.createElement('button');
+          toggle.className = 'project-toggle';
+          toggle.type = 'button';
+          toggle.setAttribute('aria-expanded', String(!collapsed));
+          const name = document.createElement('div');
+          name.className = 'project-name';
+          name.textContent = project?.label || (projectId === '__unassigned__' ? '未归属项目' : projectId);
+          toggle.title = project?.path || name.textContent;
+          toggle.append(projectFolderIcon(collapsed), name);
+          toggle.onclick = () => {
+            if (state.collapsedProjects.has(projectId)) state.collapsedProjects.delete(projectId);
+            else state.collapsedProjects.add(projectId);
+            render();
+          };
+          header.append(toggle);
+          if (collapsed && hasApprovalTask) header.append(statusIcon('approval-status', '项目中有任务等待批准', '等待批准'));
+          else if (collapsed && hasRunningTask) header.append(statusIcon('running-status', '项目中有任务正在进行'));
+          else if (collapsed && hasUnreadTask) header.append(statusIcon('unread-status', '项目中有未读更新'));
+          if (!state.showingArchived) header.append(projectActions(project, projectId));
+          group.append(header);
+        }
+
+        const taskList = document.createElement('div');
+        taskList.className = 'project-tasks';
+        for (const thread of threads) {
+          const archivePending = archiveBusy.has(thread.id);
+          const swipe = document.createElement('div');
+          swipe.className = 'task-swipe';
+          swipe.dataset.threadId = thread.id;
+          const action = document.createElement('div');
+          action.className = `task-swipe-action${state.showingArchived ? ' restore' : ''}`;
+          action.textContent = state.showingArchived ? '恢复' : '归档';
+          const running = !state.showingArchived && isThreadRunning(thread);
+          action.title = running ? '请先停止当前任务' : action.textContent;
+          action.setAttribute('aria-hidden', 'true');
+          const button = document.createElement('button');
+          button.className = `task${thread.id === state.selectedId ? ' active' : ''}`;
+          button.disabled = archivePending;
+          const title = document.createElement('div');
+          title.className = 'task-title';
+          const displayTitle = resolvedThreadTitle(thread);
+          title.textContent = displayTitle;
+          button.title = [displayTitle, thread.transport === 'app-server' ? 'app-server 独立任务' : '', statusText(thread.status), thread.cwd].filter(Boolean).join(' · ');
+          button.append(title);
+          if (thread.transport === 'app-server') {
+            const badge = document.createElement('span');
+            badge.className = 'transport-badge';
+            badge.textContent = 'AS';
+            badge.title = '独立 app-server 任务';
+            button.append(badge);
+          }
+          if (archivePending) button.append(statusIcon('archive-status', state.showingArchived ? '恢复中' : '归档中', state.showingArchived ? '恢复中…' : '归档中…'));
+          else if (isThreadWaitingForApproval(thread)) button.append(statusIcon('approval-status', '等待批准', '等待批准'));
+          else if (isThreadRunning(thread)) button.append(statusIcon('running-status', '任务正在进行'));
+          else if (state.unreadThreads.has(thread.id)) button.append(statusIcon('unread-status', '有未读更新'));
+          button.onclick = () => state.showingArchived ? onFeedback('左滑可以恢复这个对话') : onSelectThread(thread);
+          const supported = archiveSupported(thread);
+          action.hidden = !supported || archivePending;
+          if (supported && !running && !archivePending) {
+            bindTaskSwipe(swipe, button, action, () => onArchiveThread(thread, state.showingArchived));
+          }
+          swipe.append(action, button);
+          taskList.append(swipe);
+        }
+        group.append(taskList);
+        container.append(group);
+      }
+      if (!visibleThreads.length && state.showingArchived) {
+        const empty = document.createElement('div');
+        empty.className = 'recent-heading';
+        empty.textContent = '暂无已归档对话';
+        container.append(empty);
+      }
+      if (scrollOwner) scrollOwner.scrollTop = previousScrollTop;
+    }
+
+    function syncSelection(thread) {
+      const expandedProject = state.collapsedProjects.delete(thread.projectId || '__unassigned__');
+      if (expandedProject) { render(); return; }
+      let selectedFound = false;
+      for (const swipe of el('tasks').querySelectorAll('.task-swipe')) {
+        const button = swipe.querySelector('.task');
+        const selected = swipe.dataset.threadId === thread.id;
+        button?.classList.toggle('active', selected);
+        if (selected) {
+          selectedFound = true;
+          button.querySelector('.unread-status')?.remove();
+        }
+      }
+      if (!selectedFound) render();
+    }
+
+    function setArchivePending(threadId, pending) {
+      const wrapper = [...el('tasks').querySelectorAll('.task-swipe')]
+        .find(item => item.dataset.threadId === threadId);
+      if (!wrapper) return;
+      const button = wrapper.querySelector('.task');
+      const action = wrapper.querySelector('.task-swipe-action');
+      button.disabled = true;
+      action.hidden = true;
+      button.querySelector('.archive-status')?.remove();
+      button.append(statusIcon('archive-status', pending, `${pending}…`));
+    }
+
+    function clearArchivePending(threadId) {
+      const wrapper = [...el('tasks').querySelectorAll('.task-swipe')]
+        .find(item => item.dataset.threadId === threadId);
+      if (!wrapper) return;
+      const button = wrapper.querySelector('.task');
+      button.disabled = false;
+      button.querySelector('.archive-status')?.remove();
+      const action = wrapper.querySelector('.task-swipe-action');
+      if (action) action.hidden = false;
+    }
+
+    function removeThread(threadId) {
+      const wrapper = [...el('tasks').querySelectorAll('.task-swipe')]
+        .find(item => item.dataset.threadId === threadId);
+      if (!wrapper) return;
+      const tasks = wrapper.parentElement;
+      const group = tasks?.parentElement;
+      wrapper.remove();
+      if (tasks && !tasks.children.length && group?.classList.contains('recent')) group.remove();
+    }
+
+    return { clearArchivePending, removeThread, render, setArchivePending, syncSelection };
+  }
+
+  return createTaskListView;
+});

package/dist/web/thread-attention-controller.js

@@ -0,0 +1,124 @@
+(function (root, factory) {
+  const create = factory();
+  if (typeof module === 'object' && module.exports) module.exports = create;
+  else root.createThreadAttentionController = create;
+})(globalThis, function () {
+  function createThreadAttentionController(options) {
+    const { state, platform, localStorage, scope, isThreadRunning, isSelectedVisible, report } = options;
+    const storageKey = 'codexRemoteThreadAttentionV2';
+    const nativeStorage = platform.has('readThreadAttention') && platform.has('saveThreadAttention');
+
+    function metric(action, thread, previous, source, reason = '') {
+      const safe = value => String(value ?? '').replace(/[^A-Za-z0-9._/-]/g, '_').slice(0, 48);
+      report(`stage=attention;action=${safe(action)};source=${safe(source)};reason=${safe(reason)};id=${safe(thread?.id)};prevStatus=${safe(previous?.status)};status=${safe(thread?.status)};prevAt=${recency(previous)};at=${recency(thread)}`);
+    }
+
+    function recency(thread) {
+      return Number(thread?.recencyAt ?? thread?.updatedAt) || 0;
+    }
+
+    function restore() {
+      try {
+        const serialized = nativeStorage
+          ? platform.readThreadAttention(scope)
+          : localStorage.getItem(storageKey);
+        const saved = JSON.parse(serialized || '{}');
+        state.unreadThreads = new Set(Array.isArray(saved.unread) ? saved.unread.filter(Boolean) : []);
+        state.threadSnapshots = new Map(Object.entries(saved.snapshots || {}));
+        report(`stage=attention;action=restore;source=${nativeStorage ? 'native' : 'local'};unread=${state.unreadThreads.size};snapshots=${state.threadSnapshots.size}`);
+      } catch {
+        state.unreadThreads = new Set();
+        state.threadSnapshots = new Map();
+        report(`stage=attention;action=restore;source=${nativeStorage ? 'native' : 'local'};reason=invalid;unread=0;snapshots=0`);
+      }
+    }
+
+    function persist() {
+      try {
+        const snapshots = [...state.threadSnapshots.entries()].slice(-100);
+        const serialized = JSON.stringify({
+          unread: [...state.unreadThreads],
+          snapshots: Object.fromEntries(snapshots),
+        });
+        if (nativeStorage) platform.saveThreadAttention(scope, serialized);
+        else localStorage.setItem(storageKey, serialized);
+      } catch {}
+    }
+
+    function reconcile(threads, source = 'list') {
+      let changed = false;
+      for (const thread of threads) {
+        const previous = state.threadSnapshots.get(thread.id);
+        const currentRecency = recency(thread);
+        const previousRecency = recency(previous);
+        const changedWhileIdle = previous && !isThreadRunning(thread)
+          && (isThreadRunning(previous) || currentRecency > previousRecency);
+        if (thread.id === state.selectedId && isSelectedVisible()) {
+          if (state.unreadThreads.delete(thread.id)) {
+            metric('read', thread, previous, source, 'selected');
+            changed = true;
+          }
+        } else if (changedWhileIdle && !state.unreadThreads.has(thread.id)) {
+          state.unreadThreads.add(thread.id);
+          const statusCompleted = isThreadRunning(previous);
+          const timeAdvanced = currentRecency > previousRecency;
+          metric('unread', thread, previous, source,
+            statusCompleted && timeAdvanced ? 'status-time' : statusCompleted ? 'status' : 'time');
+          changed = true;
+        }
+        if (previous && currentRecency < previousRecency) metric('baseline-backward', thread, previous, source, 'list');
+        const snapshot = { status: thread.status || '', recencyAt: currentRecency,
+          lastReadTurnId: previous?.lastReadTurnId || '' };
+        if (!previous || previous.status !== snapshot.status || recency(previous) !== snapshot.recencyAt) {
+          state.threadSnapshots.delete(thread.id);
+          state.threadSnapshots.set(thread.id, snapshot);
+          changed = true;
+        }
+      }
+      if (changed) persist();
+    }
+
+    function markRead(thread, source = 'timeline', lastReadTurnId = '') {
+      const previous = state.threadSnapshots.get(thread.id);
+      const snapshot = {
+        status: thread.status || previous?.status || '',
+        recencyAt: Math.max(recency(previous), recency(thread)),
+        lastReadTurnId: lastReadTurnId || previous?.lastReadTurnId || '',
+      };
+      const hadUnread = state.unreadThreads.delete(thread.id);
+      const baselineAdvanced = Boolean(previous) && snapshot.recencyAt > recency(previous);
+      if (hadUnread || baselineAdvanced) {
+        metric(hadUnread ? 'read' : 'baseline-read', { ...thread, ...snapshot }, previous, source,
+          hadUnread ? 'opened' : 'time');
+      }
+      const changed = hadUnread
+        || !previous || previous.status !== snapshot.status || recency(previous) !== snapshot.recencyAt
+        || previous.lastReadTurnId !== snapshot.lastReadTurnId;
+      state.threadSnapshots.delete(thread.id);
+      state.threadSnapshots.set(thread.id, snapshot);
+      if (changed) persist();
+    }
+
+    function recordSelectedStatus(thread, source = 'stream-status') {
+      const previous = state.threadSnapshots.get(thread.id);
+      const snapshot = { status: thread.status || '', recencyAt: recency(thread),
+        lastReadTurnId: previous?.lastReadTurnId || '' };
+      if (previous && snapshot.recencyAt < recency(previous)) {
+        metric('baseline-backward', { ...thread, ...snapshot }, previous, source, 'selected');
+      }
+      state.threadSnapshots.set(thread.id, snapshot);
+      persist();
+    }
+
+    function remove(threadId) {
+      const removedUnread = state.unreadThreads.delete(threadId);
+      const removedSnapshot = state.threadSnapshots.delete(threadId);
+      if (removedUnread || removedSnapshot) persist();
+    }
+
+    restore();
+    return { metric, reconcile, markRead, recordSelectedStatus, remove };
+  }
+
+  return createThreadAttentionController;
+});

package/dist/web/thread-context-controller.js

@@ -0,0 +1,30 @@
+(function (root) {
+  function createThreadContextController(options) {
+    const interval = Math.max(1000, Number(options.interval) || 10000);
+    let timer = null;
+
+    async function update(threadId) {
+      try {
+        const usage = await options.load(threadId);
+        if (options.isCurrent(threadId)) options.onUsage(usage);
+      } catch (error) {
+        if (options.isCurrent(threadId)) options.onUnavailable(error);
+      }
+    }
+
+    function stop() {
+      if (timer) clearInterval(timer);
+      timer = null;
+    }
+
+    function start(threadId) {
+      stop();
+      void update(threadId);
+      timer = setInterval(() => void update(threadId), interval);
+    }
+
+    return Object.freeze({ start, stop, update });
+  }
+
+  root.createThreadContextController = createThreadContextController;
+})(globalThis);

package/dist/web/thread-list-controller.js

@@ -0,0 +1,61 @@
+(function (root, factory) {
+  const create = factory();
+  if (typeof module === 'object' && module.exports) module.exports = create;
+  else root.createThreadListController = create;
+})(globalThis, function () {
+  function createThreadListController(options) {
+    const {
+      state, approvalOverrides, resolveTitle, attention,
+      isWaitingForApproval, setApprovalFlag, onSelected, onRender,
+    } = options;
+
+    function listed(threadData) {
+      return [...(threadData.pinnedThreads || []), ...(threadData.threads || [])]
+        .filter((thread, index, array) => array.findIndex(item => item.id === thread.id) === index);
+    }
+
+    function signature(threads = state.threads) {
+      const projects = state.projects.map(project => [
+        project.projectId || '',
+        project.label || '',
+        project.path || '',
+      ].join('\u0001')).join('\u0002');
+      const threadList = threads.map(thread => [
+        thread.id,
+        thread.projectId || '',
+        thread.title || '',
+        thread.status || '',
+        Array.isArray(thread.activeFlags) ? thread.activeFlags.join(',') : '',
+        state.unreadThreads.has(thread.id) ? 'unread' : '',
+      ].join('\u0001')).join('\u0002');
+      return `${projects}\u0003${threadList}`;
+    }
+
+    function apply(threadData, forceRender = false, source = 'list') {
+      const before = signature();
+      if (Array.isArray(threadData.projects)) state.projects = threadData.projects;
+      const threads = listed(threadData).map(thread => ({ ...thread, title: resolveTitle(thread) }));
+      for (const thread of threads) {
+        if (!approvalOverrides.has(thread.id)) continue;
+        const pending = approvalOverrides.get(thread.id);
+        const serverPending = isWaitingForApproval(thread);
+        setApprovalFlag(thread, pending);
+        if (!pending && !serverPending) approvalOverrides.delete(thread.id);
+      }
+      attention.reconcile(threads, source);
+      state.threads = threads;
+      state.threadListComplete = true;
+      const selected = threads.find(thread => thread.id === state.selectedId);
+      if (selected) {
+        state.selectedThread = selected;
+        onSelected(selected);
+      }
+      if (forceRender || before !== signature()) onRender();
+      return threads;
+    }
+
+    return { listed, apply };
+  }
+
+  return createThreadListController;
+});

package/dist/web/thread-list-sync.js

@@ -0,0 +1,86 @@
+(function (root, factory) {
+  const create = factory();
+  if (typeof module === 'object' && module.exports) module.exports = create;
+  else root.createThreadListSync = create;
+})(globalThis, function () {
+  function createThreadListSync(options) {
+    const {
+      api, isBlocked, isVisible, apply, count,
+      setStatus, setRefreshDisabled, report,
+    } = options;
+    let pollingTimer = null;
+    let wakeTimer = null;
+    let wakeForced = false;
+    let activeRequests = 0;
+    let activeLoads = 0;
+    let generation = 0;
+
+    async function request(reason, forceRender, required) {
+      if (!forceRender && (isBlocked() || activeRequests > 0)) return false;
+      const requestGeneration = ++generation;
+      activeRequests += 1;
+      if (forceRender) {
+        activeLoads += 1;
+        setRefreshDisabled(true);
+      }
+      const started = performance.now();
+      try {
+        const threadData = await api('/api/threads?limit=200');
+        if (requestGeneration !== generation) return false;
+        const renderStarted = performance.now();
+        apply(threadData, forceRender, reason);
+        report(`stage=list;reason=${reason};totalMs=${Math.round(performance.now() - started)};renderMs=${Math.round(performance.now() - renderStarted)};threads=${count(threadData)}`);
+        setStatus('已连接', true);
+        return true;
+      } catch (error) {
+        if (required && requestGeneration === generation) throw error;
+        if (requestGeneration === generation) setStatus(error.message, false);
+        return false;
+      } finally {
+        activeRequests -= 1;
+        if (forceRender) {
+          activeLoads -= 1;
+          if (activeLoads === 0) setRefreshDisabled(false);
+        }
+      }
+    }
+
+    function refresh(reason = 'refresh') {
+      return request(reason, false, false);
+    }
+
+    function load(required = false) {
+      return request('load', true, required);
+    }
+
+    function start() {
+      if (pollingTimer) clearInterval(pollingTimer);
+      pollingTimer = setInterval(() => {
+        if (isVisible()) void refresh('poll');
+      }, 30_000);
+    }
+
+    function schedule(delay = 0, force = false, reason = 'scheduled') {
+      if (wakeTimer) clearTimeout(wakeTimer);
+      wakeForced ||= force;
+      wakeTimer = setTimeout(() => {
+        const forced = wakeForced;
+        wakeTimer = null;
+        wakeForced = false;
+        if (forced || isVisible()) void refresh(reason);
+      }, delay);
+    }
+
+    function stop() {
+      if (pollingTimer) clearInterval(pollingTimer);
+      if (wakeTimer) clearTimeout(wakeTimer);
+      pollingTimer = null;
+      wakeTimer = null;
+      wakeForced = false;
+    }
+
+    return { refresh, load, start, schedule, stop };
+  }
+
+  return createThreadListSync;
+});