@xgspz/cli-ui 0.6.14 → 0.6.16

package/src/core/store.ts

@@ -16,8 +16,10 @@ import { notifyCallback } from "./callbacks";
 import { CenterError, createCenterClient, firstLine, type CenterClient, type CenterClientOptions } from "./client";
 import { addTurnsIfAbsent, applyItems, applyOlderPage, applySnapshot, closedCallback, convEnded, convKey, emptyConv, isChatTask, NEW_TASK, parseConvKey, TERMINAL_JOB, TERMINAL_TURN, turnCallback, upsertTurns, type ConvState } from "./conversation";
 import { formatAnswersText } from "../ui/format";
+import { KEEP_TRANSCRIPTS, trimToTail } from "../ui/transcriptModel";
 import { backgroundBlock, charCount, MAX_MESSAGE_CHARS, serializeBlock } from "./blocks";
-import { cloneBoardView, reportBoardOwner, activateBoardOwner, selectedBoardOwner, mergeBoardHistory, rememberBoardFile } from "../board/context";
+import { cloneBoardView, mergeBoardHistory, rememberBoardFile } from "../board/context";
+import { createBoardOwners, createBoardSurfaces } from "../board/linkage";
 import { cloneWorkspaceChange, subscribeWorkspaceFiles, retryWorkspaceFiles, type WorkspaceWatchOptions } from "../board/fileWatch";
 import { retainFileScope } from "../board/fileScope";
 import type { WorkspaceChangeEvent, WorkspaceWatchStatus } from "./types";
@@ -193,6 +195,12 @@ export const jitter = (ms: number) => Math.round(ms * (0.7 + Math.random() * 0.6
  * 很多人开着页面不看时，中枢和节点不用一直为他们推数据。
  */
 export const PARK_HIDDEN_MS = 5 * 60_000;
+/**
+ * 没人看的对话（对话、看板都不看了）最多留这么多个的记录在内存里，每个离开时截到最新 SNAPSHOT_TAIL 条（往上翻过的更早消息丢掉，
+ * 再往上翻时重新取）：来回切换最近看过的仍然立刻显示，更早的整个释放，再打开时从实时流重新读。
+ * 与节点适配（useTaskStream）同一条规则、同一组常量（ui/transcriptModel 的 KEEP_TRANSCRIPTS / trimToTail）。
+ */
+export const IDLE_CONV_MAX = KEEP_TRANSCRIPTS;
 /**
  * 401 / 403：多半是宿主的登录会话过期了。隔 30 秒再试，最多 AUTH_RETRIES 次；之后停下等事件
  * （宿主续上会话后切回页面、获得焦点或调用 store.reconnect() 即恢复），不无限重试。
@@ -359,11 +367,14 @@ export function createCliStore(options: CliStoreOptions = {}) {
   }
 
   const refreshAgain = new Set<string>();
+  /** 每个对话任务拉过几次详情（成功或失败都算）：列表排队期间别处拉过了就不再重复。 */
+  const fetches = new Map<string, number>();
   async function refreshJob(jobId: string, force = false) {
     const entry = state.jobs[jobId];
     // 正在拉：拉完再补一次，免得错过这期间的变化（例如轮次刚从排队变成执行中）。
     if (entry?.loading) { refreshAgain.add(jobId); return; }
     if (!force && entry && Date.now() - entry.fetchedAt < JOB_REFRESH_GAP_MS) return;
+    fetches.set(jobId, (fetches.get(jobId) ?? 0) + 1);
     patchJob(jobId, { loading: true });
     try {
       const job = await client.getJob(jobId);
@@ -374,8 +385,11 @@ export function createCliStore(options: CliStoreOptions = {}) {
         firstInput = first?.turns[0]?.input ?? "";
       }
       patchJob(jobId, { job, firstInput, loading: false, error: null, fetchedAt: Date.now() });
-      // 新数据里已包含实时用量，清零累计（这个对话任务里的每个对话）。
-      for (const conv of Object.values(state.convs)) if (conv.jobId === jobId) patchConv(conv.key, (c) => ({ ...c, liveUsage: { fresh: 0, cacheRead: 0 } }));
+      // 新数据里已包含实时用量，清零累计（这个对话任务里的每个对话）。已经是 0 的不动：不然每次刷新都换一个对话对象，
+      // 看着它的对话组件会把整份消息重算、重画一遍。
+      for (const conv of Object.values(state.convs)) {
+        if (conv.jobId === jobId && (conv.liveUsage.fresh || conv.liveUsage.cacheRead)) patchConv(conv.key, (c) => ({ ...c, liveUsage: { fresh: 0, cacheRead: 0 } }));
+      }
     } catch (error) {
       patchJob(jobId, { loading: false, error: error instanceof Error ? error.message : String(error), fetchedAt: Date.now() });
       // 本地记住的对话在 center 已经不存在（被删、换了环境）：从列表里拿掉。宿主给的 jobIds 不动，由宿主决定。
@@ -388,6 +402,38 @@ export function createCliStore(options: CliStoreOptions = {}) {
     if (refreshAgain.delete(jobId)) void refreshJob(jobId, true);
   }
 
+  /** 只要拿到详情就行（打开对话、列表补拉）：已经在拉的不再排一次「拉完再补」。 */
+  function loadJob(jobId: string, force = false) {
+    if (state.jobs[jobId]?.loading) return Promise.resolve();
+    return refreshJob(jobId, force);
+  }
+
+  // 列表的后台拉取（首次加载、刷新、补拉新加进来的）共用一个并发上限 LIST_CONCURRENCY；
+  // 同一个任务排着或正在拉时不再排第二次。打开对话、发消息这类用户在等的不走这里。
+  const listQueue = new Map<string, Promise<void>>();
+  let listActive = 0;
+  const listWaiting: Array<() => void> = [];
+  function queueListJob(jobId: string, force: boolean): Promise<void> {
+    const queued = listQueue.get(jobId);
+    if (queued) return queued;
+    const seen = fetches.get(jobId) ?? 0;
+    const run = (async () => {
+      if (listActive >= LIST_CONCURRENCY) await new Promise<void>((resolve) => listWaiting.push(resolve));
+      listActive += 1;
+      try {
+        // 排队期间别处已经开始拉了（打开了这个对话、轮次变化）：不再重复。
+        if ((fetches.get(jobId) ?? 0) !== seen) return;
+        await loadJob(jobId, force);
+      } finally {
+        listActive -= 1;
+        listWaiting.shift()?.();
+      }
+    })();
+    listQueue.set(jobId, run);
+    void run.finally(() => { if (listQueue.get(jobId) === run) listQueue.delete(jobId); });
+    return run;
+  }
+
   /**
    * 刷新列表。缺省只刷还没结束的对话（结束了的不会再变，轮询不必每次都拉）；all = true 全部重拉（首次加载、手动刷新）。
    */
@@ -398,13 +444,18 @@ export function createCliStore(options: CliStoreOptions = {}) {
         const status = state.jobs[id]?.job?.status;
         return !status || !TERMINAL_JOB.has(status);
       });
-      await runLimited(ids, LIST_CONCURRENCY, (id) => refreshJob(id, true));
+      await Promise.all(ids.map((id) => queueListJob(id, true)));
       set({ listLoading: false });
     } catch (error) {
       set({ listLoading: false, listError: error instanceof Error ? error.message : String(error) });
     }
   }
 
+  /** 列表里还没有数据的对话任务（宿主新给的、别的组件新建的）：排进列表的后台拉取（列表组件用）。 */
+  function loadMissingJobs() {
+    for (const id of state.jobIds) if (!state.jobs[id]) void queueListJob(id, false);
+  }
+
   // ── 实时流（引用计数 + 断线重连） ─────────────────────
 
   // synced：这个流已经收到过快照；之后的快照是断线重连后的补齐。
@@ -430,6 +481,8 @@ export function createCliStore(options: CliStoreOptions = {}) {
     if (streams.get(key) !== entry || entry.refs <= 0) return;
     const { jobId, taskId } = parseConvKey(key);
     let ended = false, retired = false, snapshotReceived = false;
+    // 这条连接上节点回合结束时查过文件、当时的工具执行次数（ConvState.edits）；中枢随后把这一轮标成结束时据此去重。
+    let roundEndEdits: number | null = null;
     let endReason: string | null = null;
     let cleanup: (() => void) | null = null;
     const owns = () => streams.get(key) === entry && entry.refs > 0 && entry.stop === retire;
@@ -526,11 +579,18 @@ export function createCliStore(options: CliStoreOptions = {}) {
               // applyItems also rejects events from another batch task's node session.
               if (next === previous) continue;
               // Observe every event: end + next user in one chunk can leave running=true.
-              if (item.type === "node" && item.event.type === "turn_end" || item.type === "transcript") refresh = true;
+              if (item.type === "transcript") { refresh = true; roundEndEdits = null; }
+              // 节点上一个回合结束就查文件（中枢的这一轮可能还没结束：节点接着跑下一回合）。
+              if (item.type === "node" && item.event.type === "turn_end") { refresh = true; roundEndEdits = next.edits; }
               // 有轮次的对话以中枢把这一轮标成结束为准（节点已停、轮末保存已做）；没有轮次的看节点 turn_end。
               if (item.type === "node" && item.event.type === "turn_end" && !next.turns.length) settled = true;
               if (item.type === "turn" && item.turn.status !== "merged" && TERMINAL_TURN.has(item.turn.status)
-                && !TERMINAL_TURN.has(previous.turns.find((turn) => turn.turn_id === item.turn.turn_id)?.status ?? "")) { refresh = true; settled = true; }
+                && !TERMINAL_TURN.has(previous.turns.find((turn) => turn.turn_id === item.turn.turn_id)?.status ?? "")) {
+                settled = true;
+                // 节点回合结束时已经查过、之后再没有工具执行完：文件不会变，不再查第二次。
+                if (roundEndEdits !== next.edits) refresh = true;
+                roundEndEdits = null;
+              }
             }
             return settled ? { ...next, settled: next.settled + 1 } : next;
           });
@@ -573,12 +633,18 @@ export function createCliStore(options: CliStoreOptions = {}) {
     }
   }
   /** 手动重连：给了对话键只连这一个，否则所有停下的 / 正在退避等待的都立刻再连（重试次数重新计）。 */
-  function reconnect(key?: string) {
+  /**
+   * 立刻重连。缺省只接上停下的（offline、页面停放）或正在等重连的；force：连着的也断开重连一次，
+   * 让中枢重新补发快照（例如会话记录一直没读到时的「重新读取」）。
+   */
+  function reconnect(key?: string, options: { force?: boolean } = {}) {
     if (!key) { reconnectNow(); return; }
     const entry = streams.get(key);
-    if (!entry || entry.refs <= 0 || (!entry.parked && !entry.timer)) return;
+    if (!entry || entry.refs <= 0 || (!options.force && !entry.parked && !entry.timer)) return;
     if (entry.timer) { clearTimeout(entry.timer); entry.timer = null; }
     entry.parked = false; entry.attempt = 0;
+    if (options.force) { settleDrop(entry); patchConv(key, (conv) => ({ ...conv, transcriptError: null })); }
+    // connect 会先关掉还连着的那条（包括已经收到 end 的）。
     connect(key);
   }
   // 页面在后台太久：停掉实时流（主动停止不算断线，不会触发重连），切回来由 reconnectNow 接上。
@@ -602,7 +668,7 @@ export function createCliStore(options: CliStoreOptions = {}) {
   function open(key: string): () => void {
     const { jobId, taskId } = parseConvKey(key);
     if (taskId === NEW_TASK) {
-      void refreshJob(jobId);
+      void loadJob(jobId);
       return () => undefined;
     }
     let entry = streams.get(key);
@@ -613,7 +679,9 @@ export function createCliStore(options: CliStoreOptions = {}) {
     }
     entry.refs += 1;
     if (entry.refs === 1) {
-      void refreshJob(jobId);
+      markActive(key);
+      // 列表正在拉这个任务（页面刚打开时常见）：用它的结果，不再排一次「拉完再补」。
+      void loadJob(jobId);
       connect(key);
     }
     const owned = entry;
@@ -632,10 +700,35 @@ export function createCliStore(options: CliStoreOptions = {}) {
       settleDrop(current);
       syncLive();
       current.stop?.();
-      if (!streams.has(key)) patchConv(key, (conv) => ({ ...conv, stream: conv.stream === "ended" ? "ended" : "idle" }));
+      if (!streams.has(key)) {
+        patchConv(key, (conv) => ({ ...conv, stream: conv.stream === "ended" ? "ended" : "idle" }));
+        markIdle(key);
+      }
     };
   }
 
+  // 没人看的对话按最近不看的先后排着（最早不看的在前），超过 IDLE_CONV_MAX 个就释放最早的那些的记录。
+  const idleConvs: string[] = [];
+  function markIdle(key: string) {
+    markActive(key);
+    idleConvs.push(key);
+    // 离开的对话截回快照大小：往上翻过很远的对话在后台不留几千条消息。
+    patchConv(key, (conv) => {
+      const trimmed = trimToTail(conv.msgs, conv.older);
+      return trimmed.msgs === conv.msgs ? conv : { ...conv, msgs: trimmed.msgs, older: trimmed.older };
+    });
+    if (idleConvs.length <= IDLE_CONV_MAX) return;
+    const drop = idleConvs.splice(0, idleConvs.length - IDLE_CONV_MAX).filter((k) => !streams.has(k) && state.convs[k]);
+    if (!drop.length) return;
+    const convs = { ...state.convs };
+    for (const k of drop) delete convs[k];
+    set({ convs });
+  }
+  function markActive(key: string) {
+    const at = idleConvs.indexOf(key);
+    if (at >= 0) idleConvs.splice(at, 1);
+  }
+
   // ── 发消息 / 新建 / 撤回 / 结束 ───────────────────────
 
   /**
@@ -824,7 +917,8 @@ export function createCliStore(options: CliStoreOptions = {}) {
    * 同一个对话同一时刻只取一页。返回取到没有。
    */
   const loadingOlder = new Set<string>();
-  async function loadOlder(key: string): Promise<boolean> {
+  /** beforeApply：这一页接上去之前调用（界面趁这时量下第一行的位置，接上后视图不跳）。 */
+  async function loadOlder(key: string, opts: { beforeApply?: () => void } = {}): Promise<boolean> {
     const conv = state.convs[key];
     // 节点会话：一次性任务是正在看的那个对话，对话任务是流里这个对话的远端任务。
     const remote = conv ? conv.remoteTaskId ?? conv.task?.remote_task_id ?? null : null;
@@ -834,6 +928,9 @@ export function createCliStore(options: CliStoreOptions = {}) {
     try {
       const page = await client.history(key, remote, first.id, 200);
       // 取的过程中换了节点会话（重建、续派切过去）：这一页作废。
+      const current = state.convs[key];
+      if (!current || (current.remoteTaskId ?? current.task?.remote_task_id ?? null) !== remote || current.msgs[0]?.id !== first.id) return false;
+      notifyCallback(opts.beforeApply, undefined);
       patchConv(key, (c) => ((c.remoteTaskId ?? c.task?.remote_task_id ?? null) === remote && c.msgs[0]?.id === first.id ? applyOlderPage(c, page.messages ?? [], page.older) : c));
       return true;
     } catch (error) {
@@ -845,7 +942,9 @@ export function createCliStore(options: CliStoreOptions = {}) {
   }
 
   // 同一个仓库里登记的看板（cli-board）。后登记的优先（例如弹出的看板盖在常驻的上面）。
-  const surfaces: { surface: BoardSurface; owner?: string; inline?: boolean; priority?: () => number }[] = [];
+  // 「在看板里打开」的接收方和各看板报告的样子：规则与节点适配共用（board/linkage）。
+  const surfaces = createBoardSurfaces<{ jobId: string; target: OpenTarget }>();
+  const boardOwners = createBoardOwners();
   const visibleLists = new Set<string>();
   function reportListPresence(owner: string, visible: boolean) {
     if (visible) visibleLists.add(owner); else visibleLists.delete(owner);
@@ -910,7 +1009,6 @@ export function createCliStore(options: CliStoreOptions = {}) {
    */
   // 每个看板各自报告（按 owner 记），生效的是最近报告、还开着的那个；一个看板撤掉只撤它自己的。
   const viewSources = new Map<string, Map<string, BoardRef>>();
-  const boardSources = new Map<string, Map<string, BoardView>>();
   /** 记下 owner 的报告，返回现在生效的那个（最近报告的）。 */
   function latestReport<T>(sources: Map<string, Map<string, T>>, key: string, owner: string, value: T | null): T | null {
     const m = sources.get(key) ?? new Map<string, T>();
@@ -943,16 +1041,12 @@ export function createCliStore(options: CliStoreOptions = {}) {
     if(contextChanged&&state.boardContext[key]===retained)emit({type:"board_context",jobId:key,view:cloneBoardView(retained!)});
   }
   function reportBoard(key:string,view:BoardView|null,owner="default") {
-    const sources=boardSources.get(key)??new Map<string,BoardView>();
     let history=state.boardContext[key]?.history??[];
-    if(view){history=mergeBoardHistory(history,sources.get(owner),view);reportBoardOwner(sources,owner,cloneBoardView(view));}
-    else sources.delete(owner);
-    if(sources.size)boardSources.set(key,sources);else boardSources.delete(key);
-    const top=selectedBoardOwner(sources)?.[1]??null;applyBoardSelection(key,top,history);
+    if(view)history=mergeBoardHistory(history,boardOwners.previous(key,owner),view);
+    const top=boardOwners.report(key,owner,view?cloneBoardView(view):null);applyBoardSelection(key,top,history);
   }
   function activateBoard(key:string,owner:string) {
-    const sources=boardSources.get(key);if(!sources)return;
-    const top=activateBoardOwner(sources,owner)?.[1];if(!top)return;
+    const top=boardOwners.activate(key,owner);if(!top)return;
     const file=top.current??(top.file?{path:top.file,sourceId:key}:null);
     const history=file?rememberBoardFile(state.boardContext[key]?.history??[],file):state.boardContext[key]?.history??[];
     applyBoardSelection(key,top,history);
@@ -1031,14 +1125,7 @@ export function createCliStore(options: CliStoreOptions = {}) {
   }
 
   function openInBoard(jobId: string, target: OpenTarget, preferredInlineOwner?: string): boolean {
-    let handled = false;
-    const available = [...surfaces].reverse().filter(item => !preferredInlineOwner || !item.inline || item.owner === preferredInlineOwner)
-      .sort((a, b) => (b.priority?.() ?? 2) - (a.priority?.() ?? 2));
-    for (const { surface } of available) {
-      try { handled = surface(jobId, { ...target }); }
-      catch (error) { console.error("[@xgspz/cli-ui] board surface callback failed", error); }
-      if (handled) break;
-    }
+    const handled = surfaces.open({ jobId, target }, (item) => !preferredInlineOwner || !item.inline || item.owner === preferredInlineOwner);
     emit({ type: "open", jobId, target, handled });
     return handled;
   }
@@ -1052,9 +1139,8 @@ export function createCliStore(options: CliStoreOptions = {}) {
     openInBoard,
     /** 看板登记自己；返回注销函数。 */
     registerBoard(surface: BoardSurface, options: { owner?: string; inline?: boolean; priority?: () => number } = {}) {
-      const entry = { surface, ...options };
-      surfaces.push(entry);
-      return () => { const i = surfaces.indexOf(entry); if (i >= 0) surfaces.splice(i, 1); };
+      // 每个接收方拿到自己的一份 target，改了也不影响下一个。
+      return surfaces.register(({ jobId, target }) => surface(jobId, { ...target }), options);
     },
     subscribe(fn: () => void) { listeners.add(fn); return () => { listeners.delete(fn); }; },
     on(fn: (event: CliEvent) => void) { eventListeners.add(fn); return () => { eventListeners.delete(fn); }; },
@@ -1064,6 +1150,8 @@ export function createCliStore(options: CliStoreOptions = {}) {
       emit({ type: "select", jobId });
     },
     setJobIds, addJob, removeJob, replaceJob, refreshJob, refreshAll,
+    /** 列表组件用：补拉列表里还没有数据的对话任务。 */
+    loadMissingJobs,
     addRef, removeRef, takeRefs, restoreRefs,
     setViewing, dismissViewing, takeViewing, restoreViewing,
     /** 看板报告自己的样子（看板组件用）。 */
@@ -1079,14 +1167,6 @@ export function createCliStore(options: CliStoreOptions = {}) {
 export type CliStore = ReturnType<typeof createCliStore>;
 
 
-async function runLimited<T>(items: T[], limit: number, fn: (item: T) => Promise<unknown>) {
-  let index = 0;
-  const workers = Array.from({ length: Math.min(limit, items.length) }, async () => {
-    while (index < items.length) await fn(items[index++]);
-  });
-  await Promise.all(workers);
-}
-
 const REF_MAX = 20;
 const REF_TEXT_MAX = 4_000;
 

package/src/core/types.ts

@@ -251,6 +251,8 @@ export type StreamItem =
   /** remote_task_id：一次性任务的流里才有（大任务里可能同时有几个节点对话）。 */
   /** older：快照只有最新一段时，更早还有几条（往上翻时经 history 分页取）。旧版中枢没有 = 全量。 */
   | { type: "transcript"; remote_task_id?: string; messages: Message[] | null; pending: PendingMessage[] | null; running: boolean | null; older?: number }
+  /** 中枢读不到这个对话的记录（执行节点暂时连不上、读超时），会继续重试；旧版中枢没有。 */
+  | { type: "transcript_unavailable"; remote_task_id?: string; error: string }
   | { type: "node"; remote_task_id?: string; event: NodeEvent }
   | { type: "turn"; turn: CenterTurn }
   | { type: "job"; job: { id: string; status: JobStatus; closed_reason?: string | null; node_id: string | null } }

package/src/msglist/CliMsgList.tsx

@@ -343,8 +343,9 @@ function MsgListInner({ jobIds, selectedId, onSelect, onNew, title = "对话", c
     };
   }, [store]);
 
-  // 新加进来的对话（别的组件新建的 / 接续出来的）还没数据：补拉一次。
-  useEffect(() => { for (const id of ids) if (!jobs[id]) void store.refreshJob(id); }, [ids, jobs, store]);
+  // 新加进来的对话（宿主后给的、别的组件新建的 / 接续出来的）还没数据：补拉一次。
+  // 和首次加载、刷新共用列表的并发上限；已经在排、在拉的不重复。
+  useEffect(() => { store.loadMissingJobs(); }, [ids, store]);
 
   const cards = useMemo(() => ids.map((id) => cardView(id, jobs[id])), [ids, jobs]);
   const q = query.trim().toLowerCase();

package/src/operator/node/AgentConnect.tsx

@@ -1,14 +1,14 @@
 "use client";
 
 import { useCallback, useEffect, useRef, useState } from "react";
-import { Icon } from "./icons";
+import { Icon } from "../../ui/icons";
 import { jget, jsend } from "./api";
 import { Modal } from "./Modal";
 import { AUTH_BANNER_HINT } from "./protocol/authFailure";
 import { isOptInAgent } from "./protocol/agents/optIn";
 import { ProviderAuthPanel } from "./ProviderAuth";
 import type { AgentInfo, AgentInfoT, AgentsResponseT, AgentLoginT, ClaudeVerifyT } from "./types";
-import { useBoundedPoll } from "./boundedPoll";
+import { useRecheckOnReturn } from "./recheckOnReturn";
 
 const NUDGE_DISMISSED = "orch_agent_nudge_dismissed";
 
@@ -247,7 +247,8 @@ function BedrockConnect({ agent, onConnected, compatible = false }: { agent: Age
 // setting, or a device-code `aws sso login` for the SSO profile) and surfaces
 // the device URL + one-time code here. Clicking through lands on the IdP
 // (silent if that session is still live) then the AWS approval page; nothing is
-// pasted back — the command exits on approval and the poll flips to success.
+// pasted back — the command exits on approval; coming back to this tab (or 检查状态)
+// re-reads the login and flips it to success.
 function BedrockRefresh({ agent, onConnected }: { agent: AgentInfoT; onConnected?: () => void }) {
   const [login, setLogin] = useState<AgentLoginT | null>(null);
   const [busy, setBusy] = useState(false);
@@ -283,14 +284,15 @@ function BedrockRefresh({ agent, onConnected }: { agent: AgentInfoT; onConnected
     }
   };
 
-  // Re-check while the CLI waits for the browser-side approval — for a bounded
-  // window, and again whenever the user comes back to this tab (see useBoundedPoll).
-  useBoundedPoll(!!login && (login.status === "starting" || login.status === "awaiting"), () => {
+  // Re-check while the CLI waits for the browser-side approval — whenever the user
+  // comes back to this tab, or presses 检查状态 (useRecheckOnReturn; no polling).
+  const checkLogin = () => {
     jget<AgentLoginT>(base).then((l) => {
       setLogin(l);
       if (l.status === "success") succeed();
     }).catch(() => {});
-  }, 1800, 10 * 60_000);
+  };
+  useRecheckOnReturn(!!login && (login.status === "starting" || login.status === "awaiting"), checkLogin);
 
   if (login?.status === "success") {
     return (
@@ -323,14 +325,14 @@ function BedrockRefresh({ agent, onConnected }: { agent: AgentInfoT; onConnected
           2. 如果页面要求输入验证码，请输入{login.code ? "：" : "页面上显示的验证码。"}
         </div>
         {login.code && <div className="ctx-mono" style={{ fontSize: 20, letterSpacing: 2, margin: "8px 0 2px", fontWeight: 600 }}>{login.code}</div>}
-        <div className="wiz-verify" style={{ marginTop: 10 }}><span className="wiz-spin" /> <span>等待你在浏览器中确认…</span></div>
+        <div className="wiz-verify" style={{ marginTop: 10 }}><span className="wiz-spin" /> <span>等待你在浏览器中确认…回到这个页面时会自动检查。</span> <button className="linkbtn" onClick={checkLogin}>检查状态</button></div>
         <LogToggle log={login.log} show={showLog} setShow={setShowLog} />
       </div>
     );
   }
 
   if (login?.status === "starting") {
-    return <div className="wiz-verify" style={{ marginTop: 12 }}><span className="wiz-spin" /> <span>正在启动 AWS 刷新…获取登录链接。</span></div>;
+    return <div className="wiz-verify" style={{ marginTop: 12 }}><span className="wiz-spin" /> <span>正在启动 AWS 刷新…获取登录链接。</span> <button className="linkbtn" onClick={checkLogin}>检查状态</button></div>;
   }
 
   // idle — the refresh CTA under the verify button
@@ -426,14 +428,15 @@ function SubscriptionConnect({ agent, onConnected, compact }: { agent: AgentInfo
   };
 
   // Re-check while the CLI waits for the user to authorize / exchange the code —
-  // for a bounded window, and again whenever the user comes back (useBoundedPoll).
-  useBoundedPoll(!checkingAuth && !(existingAuth?.authenticated && !chooseLogin) && !!login
-    && (login.status === "starting" || login.status === "awaiting" || login.status === "submitting"), () => {
+  // whenever the user comes back to this tab, or presses 检查状态 (no polling).
+  const checkLogin = () => {
     jget<AgentLoginT>(base).then((l) => {
       setLogin(l);
       if (l.status === "success") succeed();
     }).catch(() => {});
-  }, 1800, 10 * 60_000);
+  };
+  useRecheckOnReturn(!checkingAuth && !(existingAuth?.authenticated && !chooseLogin) && !!login
+    && (login.status === "starting" || login.status === "awaiting" || login.status === "submitting"), checkLogin);
 
   const submitCode = async () => {
     if (!code.trim()) return;
@@ -511,6 +514,7 @@ function SubscriptionConnect({ agent, onConnected, compact }: { agent: AgentInfo
                 {login.status === "submitting" || busy ? "验证中…" : "提交"}
               </button>
             </div>
+            {login.status === "submitting" && <div className="hlp" style={{ marginTop: 6 }}>正在验证授权码… <button className="linkbtn" onClick={checkLogin}>检查状态</button></div>}
           </>
         ) : (
           <>
@@ -518,7 +522,7 @@ function SubscriptionConnect({ agent, onConnected, compact }: { agent: AgentInfo
               2. 出现提示时，输入这个一次性验证码{login.code ? "" : "（显示在登录页上）"}：
             </div>
             {login.code && <div className="ctx-mono" style={{ fontSize: 20, letterSpacing: 2, margin: "8px 0 2px", fontWeight: 600 }}>{login.code}</div>}
-            <div className="wiz-verify" style={{ marginTop: 10 }}><span className="wiz-spin" /> <span>等待你在浏览器中完成授权…</span></div>
+            <div className="wiz-verify" style={{ marginTop: 10 }}><span className="wiz-spin" /> <span>等待你在浏览器中完成授权…回到这个页面时会自动检查。</span> <button className="linkbtn" onClick={checkLogin}>检查状态</button></div>
           </>
         )}
         <LogToggle log={login.log} show={showLog} setShow={setShowLog} />
@@ -527,7 +531,7 @@ function SubscriptionConnect({ agent, onConnected, compact }: { agent: AgentInfo
   }
 
   if (login?.status === "starting") {
-    return <div className="wiz-verify"><span className="wiz-spin" /> <span>正在启动登录…准备授权链接。</span></div>;
+    return <div className="wiz-verify"><span className="wiz-spin" /> <span>正在启动登录…准备授权链接。</span> <button className="linkbtn" onClick={checkLogin}>检查状态</button></div>;
   }
 
   // idle — initial CTA

package/src/operator/node/AppearancePanel.tsx

@@ -1,6 +1,6 @@
 "use client";
 
-import { Icon } from "./icons";
+import { Icon } from "../../ui/icons";
 import type { Appearance } from "./types";
 
 export function AppearancePanel({ appearance, setAppearance, onClose }: { appearance: Appearance; setAppearance: (k: keyof Appearance, v: string) => void; onClose: () => void }) {

package/src/operator/node/BranchNavigator.tsx

@@ -1,6 +1,6 @@
 "use client";
 import { useEffect, useRef } from "react";
-import { Icon } from "./icons";
+import { Icon } from "../../ui/icons";
 import { SLABEL, type TaskRow } from "./types";
 import { branchOptions } from "./branchFlow";
 

package/src/operator/node/BrowserPane.tsx

@@ -1,6 +1,6 @@
 "use client";
 import { useMemo, useState } from "react";
-import { Icon } from "./icons";
+import { Icon } from "../../ui/icons";
 import { BrowserPane as BrowserSurface } from "../../board/BrowserPane";
 import { createOperatorBoardBackend } from "./boardBackend";
 import type { BrowserStatus } from "../../core/types";