dsh-github-flow 0.6.0 → 0.7.0

package/lib/api/routes-overview.js

@@ -14,7 +14,44 @@ const WORKSPACE_PROBE_CONCURRENCY = 3;
  * 但绝不能改成「每个状态各查一次」——那会把 3 个 gh 子进程变成 6~9 个，
  * 右侧栏首屏本就受 Promise.all 8 秒超时约束。
  */
-const RIGHTBAR_LIST_LIMIT = 20;
+/**
+ * 列表默认每页条数。
+ *
+ * 为什么是 15 而不是 20：与右侧栏「Git 提交」「未提交变更」两个已有分页的默认页大小对齐，
+ * 用户下滑即可继续加载（`prLimit/issueLimit/runLimit` 查询参数），所以首屏不必再靠
+ * 「多拉一点」来换取筛选体验。20 条时代首屏 JSON 实测可达 28,608 字符，直接撞上
+ * executor 的 24,000 字符输出上限 → 被截断 → JSON 解析被跳过 → 面板空列表且无报错。
+ */
+export const RIGHTBAR_LIST_LIMIT = 15;
+/** 单页上限：防止一次请求把几万条拉进内存（gh 自身也没有更细的分页） */
+const LIST_LIMIT_MAX = 100;
+/**
+ * 列表类查询的输出上限（字符）。
+ *
+ * 为什么不能沿用默认的 24,000：那个阈值是按「喂给模型上下文」调的。面板列表是
+ * **程序化消费**——前端只渲染首屏，永不整段进模型上下文。用 24KB 截 15 条 PR 的结果是
+ * 截断后 JSON 解析被跳过、`data` 变 undefined，表现为「这个仓库拉不到 PR」。
+ * 与 pr diff / issue 详情放宽到 2MB 是同一个理由。
+ */
+const LIST_OUTPUT_CAP = 1_048_576;
+/**
+ * 解析分页参数：非法/缺失回落默认页大小，超过上限则截到上限。
+ * 上限存在是因为面板可能被脚本按 `prLimit=999999` 调用。
+ */
+function parseListLimit(raw) {
+    const n = Number(raw);
+    if (!Number.isFinite(n) || n <= 0)
+        return RIGHTBAR_LIST_LIMIT;
+    return Math.min(Math.floor(n), LIST_LIMIT_MAX);
+}
+/**
+ * 缓存键：必须把三个分页参数算进去。
+ * 只用 cwd 当键的话，「先加载 15 条」的缓存会喂给「请求 30 条」的那次刷新，
+ * 表现是点了「加载更多」列表不变——而且因为命中的是缓存，连请求日志都没有。
+ */
+export function overviewCacheKey(cwd, prLimit, issueLimit, runLimit) {
+    return `${cwd}|${prLimit}|${issueLimit}|${runLimit}`;
+}
 export function registerOverviewRoutes(deps, executor, cacheMap, globalCache, checker) {
     const { bindRoute } = deps;
     // 1. 获取全局与当前仓库的 GitHub 概览
@@ -31,6 +68,10 @@ export function registerOverviewRoutes(deps, executor, cacheMap, globalCache, ch
                 let cwd = url.searchParams.get('cwd');
                 const sessionId = url.searchParams.get('sessionId');
                 const force = url.searchParams.get('force') === 'true';
+                // 分页参数：默认 15，非法值回落默认，超过上限截断（见 parseListLimit）
+                const prLimit = parseListLimit(url.searchParams.get('prLimit'));
+                const issueLimit = parseListLimit(url.searchParams.get('issueLimit'));
+                const runLimit = parseListLimit(url.searchParams.get('runLimit'));
                 // 会话 ID → 物理路径，以及「最近活跃工作区」兜底，统一由 workspace 模块提供
                 if (!cwd && sessionId) {
                     cwd = findWorkspacePathBySession(sessionId) || null;
@@ -54,8 +95,12 @@ export function registerOverviewRoutes(deps, executor, cacheMap, globalCache, ch
                 //
                 // 指纹读取是纯本地 readFileSync（几 KB），与 hasGitDir 同级开销，零子进程。
                 const remoteFingerprint = isGitRepo ? executor.getRemoteFingerprint(cwd) : null;
-                cacheMap.invalidateIfFingerprintChanged(cwd, remoteFingerprint);
-                const cachedData = cacheMap.get(cwd, now);
+                // 缓存键带上分页参数：否则「15 条」的缓存会喂给「请求 30 条」的刷新，
+                // 表现为点了加载更多但列表不变（且连请求日志都没有，因为命中的是缓存）。
+                const cacheKey = overviewCacheKey(cwd, prLimit, issueLimit, runLimit);
+                // 指纹失效必须针对**同一个键**，否则「remote url 变了」永远作废不掉缓存条目
+                cacheMap.invalidateIfFingerprintChanged(cacheKey, remoteFingerprint);
+                const cachedData = cacheMap.get(cacheKey, now);
                 if (cachedData && !force) {
                     sendJson(res, 200, {
                         ok: true,
@@ -84,11 +129,13 @@ export function registerOverviewRoutes(deps, executor, cacheMap, globalCache, ch
                         lastUpdated: new Date().toISOString(),
                         updateInfo: checker.getQuickStatus(),
                     };
-                    cacheMap.set(cwd, emptyData, now, remoteFingerprint);
+                    cacheMap.set(cacheKey, emptyData, now, remoteFingerprint);
                     sendJson(res, 200, { ok: true, data: emptyData, fromCache: false, cwd });
                     return;
                 }
                 let pullRequests = [];
+                /** 仓库总量（GraphQL 统计；失败为 null，前端回落已加载条数） */
+                let repoCounts = null;
                 let issues = [];
                 let runs = [];
                 // 确定性降级说明（非错误）：在 if 块内累积、在块外随响应一起落缓存，
@@ -107,18 +154,70 @@ export function registerOverviewRoutes(deps, executor, cacheMap, globalCache, ch
                      * 因为数据在到达浏览器前就被 gh 过滤掉了。
                      * 与全局面板（gh search，phase29 已移除 --state=open）保持同一口径。
                      */
-                    const [prsRes, issuesRes, runsRes] = await Promise.all([
+                    // 仓库标识（owner/name）。只接受该形态，避免把任意字符串拼进 GraphQL / REST 路径。
+                    const repoNwo = repo?.nameWithOwner || '';
+                    const repoNwoValid = /^[\w.-]+\/[\w.-]+$/.test(repoNwo);
+                    const [prsRes, issuesRes, runsRes, totalsRes, runsTotalRes] = await Promise.all([
                         executor.run([
                             'pr', 'list', '--state', 'all',
-                            '--json', 'number,title,state,author,headRefName,baseRefName,isDraft,mergeable,reviewDecision,statusCheckRollup,url,updatedAt',
-                            '-L', String(RIGHTBAR_LIST_LIMIT),
-                        ], { cwd, timeoutMs: 8_000 }),
+                            // 列表只渲染简要信息（编号、标题、分支、状态、合并冲突与 CI），无需拉取 author 等未消费对象
+                            '--json', 'number,title,state,headRefName,baseRefName,isDraft,mergeable,reviewDecision,statusCheckRollup,url,updatedAt',
+                            '-L', String(prLimit),
+                        ], { cwd, timeoutMs: 8_000, maxOutputChars: LIST_OUTPUT_CAP, maxOutputBytes: LIST_OUTPUT_CAP * 4 }),
                         executor.run([
                             'issue', 'list', '--state', 'all',
                             '--json', 'number,title,state,author,labels,assignees,url,updatedAt',
-                            '-L', String(RIGHTBAR_LIST_LIMIT),
-                        ], { cwd, timeoutMs: 8_000 }),
-                        executor.run(['run', 'list', '--json', 'databaseId,name,status,conclusion,event,headBranch,url,createdAt', '-L', '5'], { cwd, timeoutMs: 8_000 }),
+                            '-L', String(issueLimit),
+                        ], { cwd, timeoutMs: 8_000, maxOutputChars: LIST_OUTPUT_CAP, maxOutputBytes: LIST_OUTPUT_CAP * 4 }),
+                        executor.run(['run', 'list', '--json', 'databaseId,name,status,conclusion,event,headBranch,url,createdAt', '-L', String(runLimit)], { cwd, timeoutMs: 8_000, maxOutputChars: LIST_OUTPUT_CAP, maxOutputBytes: LIST_OUTPUT_CAP * 4 }),
+                        /*
+                         * 总量统计（与列表分页彻底解耦）。
+                         *
+                         * 为什么必须单独查：列表是「按页拉」的，`pullRequests.length` 只是**已加载条数**，
+                         * 拿它当总数会在用户下滑时从 15 跳到 30、再跳到 45——看起来像总数在变，是明显的 bug。
+                         * 真正的总数只能靠 GitHub 的计数接口拿。
+                         *
+                         * 为什么用 GraphQL `search.issueCount` 而不是 `repository.pullRequests.totalCount`：
+                         * `Repository.issues` 在 GitHub 语义里**包含 PR**（共用 issue 空间），直接取会把 PR 算进 Issue；
+                         * `search` 加 `is:pr` / `is:issue` 限定符才能精确区分，且一次请求可以并发拿全 7 个口径。
+                         */
+                        (() => {
+                            const nwo = repoNwo;
+                            // 只接受 owner/name 形态，避免把任意字符串拼进 GraphQL 查询
+                            if (!repoNwoValid)
+                                return Promise.resolve({ ok: false });
+                            const scope = `repo:${nwo}`;
+                            // GraphQL 字符串字面量必须用双引号；这里整段 query 作为**单个 argv 元素**传给
+                            // execFile（不经过 shell），所以双引号无需再转义，写了反斜杠反而会让 GitHub 解析失败。
+                            // 注意只产出「带引号的查询值」，`query:` 前缀由调用点写——否则会拼成 query:query:"..."
+                            const q = (extra) => `"${scope} ${extra}"`;
+                            const query = `query{` +
+                                `prAll:search(query:${q('is:pr')},type:ISSUE){issueCount}` +
+                                `prOpen:search(query:${q('is:pr is:open')},type:ISSUE){issueCount}` +
+                                `prMerged:search(query:${q('is:pr is:merged')},type:ISSUE){issueCount}` +
+                                `prClosed:search(query:${q('is:pr is:closed')},type:ISSUE){issueCount}` +
+                                `issAll:search(query:${q('is:issue')},type:ISSUE){issueCount}` +
+                                `issOpen:search(query:${q('is:issue is:open')},type:ISSUE){issueCount}` +
+                                `issClosed:search(query:${q('is:issue is:closed')},type:ISSUE){issueCount}` +
+                                `}`;
+                            return executor.run(['api', 'graphql', '-f', `query=${query}`], { cwd, timeoutMs: 8_000 });
+                        })(),
+                        /*
+                         * Actions 运行总数。
+                         *
+                         * 为什么单独走 REST：GitHub GraphQL **没有** workflow runs 连接
+                         * （`Repository` 上不存在 `workflowRuns` 字段），拿不到 totalCount；
+                         * REST `GET /repos/{owner}/{repo}/actions/runs?per_page=1` 的响应体里带
+                         * `total_count`（实测该仓 1146），per_page=1 只为把响应压到最小。
+                         */
+                        (() => {
+                            if (!repoNwoValid)
+                                return Promise.resolve({ ok: false });
+                            return executor.run(['api', `repos/${repoNwo}/actions/runs?per_page=1`], {
+                                cwd,
+                                timeoutMs: 8_000,
+                            });
+                        })(),
                     ]);
                     // 核心数据拉取故障检测：把失败按语义拆成两堆。
                     //
@@ -130,8 +229,15 @@ export function registerOverviewRoutes(deps, executor, cacheMap, globalCache, ch
                     // 还被客户端重试器当成可恢复抖动反复空烧。
                     const transientFailures = [];
                     const collectFailure = (res, label) => {
-                        if (res.ok)
+                        if (res.ok) {
+                            // 截断不是成功。`executor.run` 在超限时会跳过 JSON.parse（data 变 undefined）
+                            // 但仍返回 ok:true —— 旧实现因此把它当「仓库没有 PR」，面板显示空列表且零报错。
+                            // 这条曾经让一个 579 个 PR 的仓库看起来「无法拉取 PR」，必须显式透出。
+                            if (res.truncated) {
+                                deterministicNotices.push(`${label}: 返回数据过大已被截断，请到 GitHub 查看完整列表`);
+                            }
                             return;
+                        }
                         const msg = res.error || '接口异常';
                         // errorKind 由 GhExecutor 统一分类（单一事实源），这里只做分流
                         if (res.errorKind === 'deterministic') {
@@ -150,7 +256,7 @@ export function registerOverviewRoutes(deps, executor, cacheMap, globalCache, ch
                         // repo 必须用本次新鲜解析值覆盖：列表数据旧一点可以接受，仓库身份旧了就是错的
                         // （典型场景：用户把 origin 从上游换成自己的 fork 后，issue list 永久失败，
                         //  失败分支从不写缓存，旧身份被 freeze 在 fallback 里永远出不来）。
-                        const fallbackCached = cacheMap.getFallback(cwd) || cacheMap.get(cwd, now);
+                        const fallbackCached = cacheMap.getFallback(cacheKey) || cacheMap.get(cacheKey, now);
                         if (fallbackCached && (fallbackCached.pullRequests.length > 0 || fallbackCached.issues.length > 0 || fallbackCached.runs.length > 0)) {
                             sendJson(res, 200, {
                                 ok: true,
@@ -230,15 +336,66 @@ export function registerOverviewRoutes(deps, executor, cacheMap, globalCache, ch
                         .catch(() => null);
                     // 5. 分支列表（纯本地毫秒级）：供右侧栏分支选择器 0ms 秒开，消除独立请求延迟与 404 风险
                     freshExtras.branches = await executor.getGitBranches(cwd).catch(() => null);
+                    /*
+                     * 解析「仓库总量」。
+                     *
+                     * 与列表分页彻底解耦：列表按页拉，`pullRequests.length` 只是已加载条数；
+                     * 总数来自 GraphQL `search.issueCount`（第 4 路）与 REST `actions/runs.total_count`（第 5 路）。
+                     * 任何解析失败都返回 null → 前端回落到「已加载条数」，绝不因计数失败影响列表本身。
+                     */
+                    repoCounts = (() => {
+                        const body = totalsRes?.ok ? totalsRes.data : null;
+                        const root = body && typeof body === 'object' ? body.data : null;
+                        if (!root || typeof root !== 'object')
+                            return null;
+                        const num = (key) => {
+                            const v = root[key];
+                            return v && typeof v.issueCount === 'number' ? v.issueCount : undefined;
+                        };
+                        // Actions 总数来自 REST（GraphQL 没有 workflow runs 连接），响应体里是 total_count
+                        const runsBody = runsTotalRes?.ok ? runsTotalRes.data : null;
+                        const runTotal = runsBody && typeof runsBody.total_count === 'number' ? runsBody.total_count : undefined;
+                        const prTotal = num('prAll');
+                        // PR/Issue 统计失败但 Actions 拿到时，仍要下发 runTotal（两者互相独立）
+                        if (prTotal === undefined)
+                            return runTotal === undefined ? null : { runTotal };
+                        return {
+                            prTotal,
+                            prOpenTotal: num('prOpen'),
+                            prMergedTotal: num('prMerged'),
+                            prClosedTotal: num('prClosed'),
+                            issueTotal: num('issAll'),
+                            issueOpenTotal: num('issOpen'),
+                            issueClosedTotal: num('issClosed'),
+                            ...(runTotal !== undefined ? { runTotal } : {}),
+                        };
+                    })();
                 }
                 const issueStats = calculateIssueStats(issues);
                 /*
-                 * 截断必须可感知：`--state all` + 固定条数上限意味着历史记录可能被截掉，
-                 * 若不透出，用户切到「Closed」看到 3 条会以为仓库只有 3 个已关闭 PR。
-                 * 与全局面板 prsTruncated 同一口径。
+                 * 「还有没有更多」判定。
+                 *
+                 * 有真实总数时用精确比较（loaded < total）——这是「还有更多」的定义本身；
+                 * 拿不到总数才回落到「本次是否拉满」的启发式。
+                 *
+                 * 为什么必须精确：`>= prLimit` 在边界上会误报。例如 loaded=total 时，
+                 * `loaded >= prLimit` 仍为真，页脚一直显示，用户点下去却一条都拉不到。
+                 *
+                 * 为什么还要叠加 `!*Saturated`：`parseListLimit` 把请求夹在 LIST_LIMIT_MAX(100) 内。
+                 * 一旦客户端已经把 limit 顶到这个上限，再点「加载更多」只会拿到同样的 100 条
+                 * （limit 115 → 夹回 100），而 loaded(100) < total(323) 又恒成立 →
+                 * 页脚永远显示、永远点不动，这是比误报更糟的死循环。
+                 * 此时必须停止下发 truncated，由前端改显「已加载 X / 共 Y，更早记录请到 GitHub」。
                  */
-                const prsTruncated = pullRequests.length >= RIGHTBAR_LIST_LIMIT;
-                const issuesTruncated = issues.length >= RIGHTBAR_LIST_LIMIT;
+                const prLimitSaturated = prLimit >= LIST_LIMIT_MAX;
+                const issueLimitSaturated = issueLimit >= LIST_LIMIT_MAX;
+                const runLimitSaturated = runLimit >= LIST_LIMIT_MAX;
+                const prsTruncated = !prLimitSaturated &&
+                    (repoCounts?.prTotal !== undefined ? pullRequests.length < repoCounts.prTotal : pullRequests.length >= prLimit);
+                const issuesTruncated = !issueLimitSaturated &&
+                    (repoCounts?.issueTotal !== undefined ? issues.length < repoCounts.issueTotal : issues.length >= issueLimit);
+                const runsTruncated = !runLimitSaturated &&
+                    (repoCounts?.runTotal !== undefined ? runs.length < repoCounts.runTotal : runs.length >= runLimit);
                 const freshData = {
                     auth,
                     repo: repo || undefined,
@@ -254,9 +411,12 @@ export function registerOverviewRoutes(deps, executor, cacheMap, globalCache, ch
                     // 仅在真的触顶时才下发，避免给正常场景增加无意义字段
                     ...(prsTruncated ? { prsTruncated: true } : {}),
                     ...(issuesTruncated ? { issuesTruncated: true } : {}),
+                    ...(runsTruncated ? { runsTruncated: true } : {}),
+                    // 仓库总量（与分页无关的真实总数）；查询失败时整组缺席，前端回落已加载条数
+                    ...(repoCounts || {}),
                     ...freshExtras,
                 };
-                cacheMap.set(cwd, freshData, now, remoteFingerprint);
+                cacheMap.set(cacheKey, freshData, now, remoteFingerprint);
                 sendJson(res, 200, { ok: true, data: freshData, fromCache: false, cwd });
             }
             catch (err) {
@@ -276,7 +436,13 @@ export function registerOverviewRoutes(deps, executor, cacheMap, globalCache, ch
             // 全局驾驶舱要 spawn 十几次 gh（认证 + 仓库 + PR + Issue + 每个工作区探测），
             // 实测冷启动曾达 18.9 秒。缓存是这里唯一的解药：面板每次挂载都会来取一次。
             const now = Date.now();
-            const cachedGlobal = globalCache.get('global', now);
+            // 全局面板同样支持分页：默认 15，与右侧栏以及 Git/未提交两条列表同口径。
+            // 缓存键必须带分页参数，否则「15 条」的缓存会喂给「请求 30 条」的刷新。
+            const url = new URL(req.url || '', 'http://127.0.0.1');
+            const prLimit = parseListLimit(url.searchParams.get('prLimit'));
+            const issueLimit = parseListLimit(url.searchParams.get('issueLimit'));
+            const globalCacheKey = `global|${prLimit}|${issueLimit}`;
+            const cachedGlobal = globalCache.get(globalCacheKey, now);
             if (cachedGlobal) {
                 sendJson(res, 200, {
                     ok: true,
@@ -289,12 +455,16 @@ export function registerOverviewRoutes(deps, executor, cacheMap, globalCache, ch
                 const auth = await executor.checkAuth();
                 let userRepos = [];
                 let myPrs = [];
+                /** 账号级总量（GraphQL 统计；失败为 null） */
+                let accountCounts = null;
                 let myIssues = [];
                 let issueStats = { total: 0, reported: 0, assigned: 0, created: 0 };
                 let workspaceMatrix = [];
                 let workspaceError;
                 /** PR 检索是否触及 limit（命中即说明可能还有更早的 PR 未返回） */
                 let prsTruncated = false;
+                /** Issues 三路检索是否任一路触及 limit（去重合并后无法从长度反推） */
+                let issuesTruncated = false;
                 // 全局驾驶舱的确定性降级说明（同单仓库口径：在分支内累积、块外落缓存）
                 const globalNotices = [];
                 if (auth.loggedIn) {
@@ -315,19 +485,64 @@ export function registerOverviewRoutes(deps, executor, cacheMap, globalCache, ch
                      * PR 检索上限。提到常量是因为「命中 limit」这个事实要被下游用来判断截断，
                      * 散落的字面量会让两处逻辑（查询与判断）出现漂移。
                      */
-                    const PR_SEARCH_LIMIT = 30;
                     const queryResults = await Promise.allSettled([
                         executor.run(['repo', 'list', '--limit', '20', '--json', 'name,nameWithOwner,description,defaultBranchRef,isPrivate,stargazerCount,updatedAt,url'], { timeoutMs: 8_000 }),
-                        executor.run(['search', 'prs', '--author=@me', '--limit', String(PR_SEARCH_LIMIT), '--json', 'number,title,state,repository,url,updatedAt,isDraft'], { timeoutMs: 8_000 }),
-                        executor.run(['search', 'issues', '--owner=@me', '--sort=updated', '--limit', '25', '--json', issueFields], { timeoutMs: 8_000 }),
-                        executor.run(['search', 'issues', '--assignee=@me', '--sort=updated', '--limit', '25', '--json', issueFields], { timeoutMs: 8_000 }),
-                        executor.run(['search', 'issues', '--author=@me', '--sort=updated', '--limit', '25', '--json', issueFields], { timeoutMs: 8_000 }),
+                        executor.run(['search', 'prs', '--author=@me', '--limit', String(prLimit), '--json', 'number,title,state,repository,url,updatedAt,isDraft'], { timeoutMs: 8_000 }),
+                        executor.run(['search', 'issues', '--owner=@me', '--sort=updated', '--limit', String(issueLimit), '--json', issueFields], { timeoutMs: 8_000 }),
+                        executor.run(['search', 'issues', '--assignee=@me', '--sort=updated', '--limit', String(issueLimit), '--json', issueFields], { timeoutMs: 8_000 }),
+                        executor.run(['search', 'issues', '--author=@me', '--sort=updated', '--limit', String(issueLimit), '--json', issueFields], { timeoutMs: 8_000 }),
+                        /*
+                         * 账号级 PR 总量（与列表分页解耦）。
+                         *
+                         * 为什么必须单独查：`myPrs.length` 只是已加载条数，拿它当总数会在下滑时不断变大。
+                         * PR 侧口径与列表完全一致（都是 `is:pr author:@me`），所以这个总数可以精确比较。
+                         *
+                         * 为什么**不**给 Issue 也配一个总数：列表是 owner/assignee/author 三路的并集，
+                         * 而唯一能给出不重复总数的查询是 `is:issue involves:@me`——它不含「我仓库里
+                         * 别人提的 issue」（实测差集确实存在，不是索引延迟）。拿它当总数会**小于**已加载条数，
+                         * 三路分别计数相加又会因重叠而虚高。既然拿不到正确口径，就不下发假总数，
+                         * 由前端老实显示「已加载 N」。
+                         */
+                        executor.run([
+                            'api', 'graphql', '-f',
+                            'query=' +
+                                `query{` +
+                                `prAll:search(query:"is:pr author:@me",type:ISSUE){issueCount}` +
+                                `prOpen:search(query:"is:pr author:@me is:open",type:ISSUE){issueCount}` +
+                                `prMerged:search(query:"is:pr author:@me is:merged",type:ISSUE){issueCount}` +
+                                `prClosed:search(query:"is:pr author:@me is:closed",type:ISSUE){issueCount}` +
+                                `}`,
+                        ], { timeoutMs: 10_000 }),
                     ]);
                     const reposRes = queryResults[0].status === 'fulfilled' ? queryResults[0].value : { ok: false };
                     const prsRes = queryResults[1].status === 'fulfilled' ? queryResults[1].value : { ok: false };
                     const ownerIssuesRes = queryResults[2].status === 'fulfilled' ? queryResults[2].value : { ok: false };
                     const assignedIssuesRes = queryResults[3].status === 'fulfilled' ? queryResults[3].value : { ok: false };
                     const authorIssuesRes = queryResults[4].status === 'fulfilled' ? queryResults[4].value : { ok: false };
+                    const totalsRes = queryResults[5].status === 'fulfilled' ? queryResults[5].value : { ok: false };
+                    /*
+                     * 解析账号级总量。失败时返回 null → 前端回落「已加载条数」，
+                     * 绝不因计数失败影响列表本身。
+                     */
+                    accountCounts = (() => {
+                        const body = totalsRes?.ok ? totalsRes.data : null;
+                        const root = body && typeof body === 'object' ? body.data : null;
+                        if (!root || typeof root !== 'object')
+                            return null;
+                        const num = (key) => {
+                            const v = root[key];
+                            return v && typeof v.issueCount === 'number' ? v.issueCount : undefined;
+                        };
+                        const prTotal = num('prAll');
+                        if (prTotal === undefined)
+                            return null;
+                        return {
+                            prTotal,
+                            prOpenTotal: num('prOpen'),
+                            prMergedTotal: num('prMerged'),
+                            prClosedTotal: num('prClosed'),
+                        };
+                    })();
                     // 检测全局拉取是否发生网络故障，绝不把网络失败当作「0 仓库、0 PR」伪造成功。
                     // 与单仓库概览同一口径：确定性失败（账号级搜索本就不存在确定性场景，
                     // 但仓库列表拉取可能命中 404/403）不进入网络故障分支，只作为 notice 透出。
@@ -347,7 +562,7 @@ export function registerOverviewRoutes(deps, executor, cacheMap, globalCache, ch
                     collectGlobalFailure(prsRes, '个人 PR 拉取失败');
                     if (globalFailures.length > 0) {
                         const globalNetReason = globalFailures.join('；');
-                        const fallbackGlobal = globalCache.getFallback('global') || globalCache.get('global', now);
+                        const fallbackGlobal = globalCache.getFallback(globalCacheKey) || globalCache.get(globalCacheKey, now);
                         if (fallbackGlobal) {
                             sendJson(res, 200, {
                                 ok: true,
@@ -379,14 +594,20 @@ export function registerOverviewRoutes(deps, executor, cacheMap, globalCache, ch
                     if (prsRes.ok && Array.isArray(prsRes.data)) {
                         myPrs = prsRes.data;
                         /*
-                         * 命中 limit 说明可能还有更早的 PR 未返回。
-                         * 去掉 --state=open 后列表按 updatedAt 降序返回「最近 30 条」，
-                         * 若账号历史 PR 超过 30 条，界面会静默少显示——
-                         * 用户无从知道「列表到此为止」还是「数据丢了」。
-                         * 必须把截断事实透出到 UI。
+                         * PR「还有更多」判定。
+                         *
+                         * 优先用账号级真实总数做精确比较——`accountCounts.prTotal` 与列表查询
+                         * 是**同一个口径**（都是 `is:pr author:@me`），所以 `loaded < total` 就是定义。
+                         * 拿不到总数才回落到「本次是否拉满」的启发式。
+                         *
+                         * 为什么精确比较重要：`>= prLimit` 在边界会误报——用户点够次数后页脚一直显示
+                         * 「加载更多」，点下去却一条都拉不到。
                          */
-                        if (myPrs.length >= PR_SEARCH_LIMIT)
-                            prsTruncated = true;
+                        prsTruncated =
+                            // 顶到单次上限后「再加载」不可能有新结果（parseListLimit 会把更大的 limit 夹回 100），
+                            // 必须停止下发 truncated，否则 loaded < total 恒成立 → 页脚永远显示、点不动
+                            prLimit < LIST_LIMIT_MAX &&
+                                (accountCounts?.prTotal !== undefined ? myPrs.length < accountCounts.prTotal : myPrs.length >= prLimit);
                     }
                     // 多源 Issues 聚合、按 URL 唯一去重并排序
                     const issueMap = new Map();
@@ -402,6 +623,24 @@ export function registerOverviewRoutes(deps, executor, cacheMap, globalCache, ch
                     collectIssues(ownerIssuesRes);
                     collectIssues(assignedIssuesRes);
                     collectIssues(authorIssuesRes);
+                    /*
+                     * Issues 的「还有更多」判定：三路检索只要有一路拉满，就说明可能还有更早的记录。
+                     * 三路结果会被去重合并，所以不能拿 myIssues.length 反推（去重后天然变小）。
+                     *
+                     * 这里**故意不用** accountCounts.issueTotal 做精确比较：那个总数用的是
+                     * `is:issue involves:@me`（author/assignee/mention/commenter 的超集），
+                     * 而列表是三路（owner/assignee/author）的并集，前者恒 ≥ 后者。
+                     * 拿它比较会得到 `loaded < total` 永远成立 → 页脚永远显示、点了却拉不到东西。
+                     */
+                    for (const r of [ownerIssuesRes, assignedIssuesRes, authorIssuesRes]) {
+                        // 已顶到单次上限时不再喊「还有更多」：再点也只会拿到同样的数据（死循环）
+                        if (issueLimit >= LIST_LIMIT_MAX)
+                            break;
+                        if (r.ok && Array.isArray(r.data) && r.data.length >= issueLimit) {
+                            issuesTruncated = true;
+                            break;
+                        }
+                    }
                     const rawList = Array.from(issueMap.values());
                     // 统一按最后更新时间降序排列
                     rawList.sort((a, b) => new Date(b.updatedAt || 0).getTime() - new Date(a.updatedAt || 0).getTime());
@@ -460,9 +699,12 @@ export function registerOverviewRoutes(deps, executor, cacheMap, globalCache, ch
                     ...(workspaceError ? { workspaceError } : {}),
                     // 仅在真的触顶时才下发，避免给正常场景增加无意义字段
                     ...(prsTruncated ? { prsTruncated: true } : {}),
+                    ...(issuesTruncated ? { issuesTruncated: true } : {}),
+                    // 账号级总量（与分页无关）；计数查询失败时整组缺席，前端回落已加载条数
+                    ...(accountCounts || {}),
                     ...(globalNotices.length > 0 ? { notices: globalNotices } : {}),
                 };
-                globalCache.set('global', globalData, now);
+                globalCache.set(globalCacheKey, globalData, now);
                 sendJson(res, 200, { ok: true, data: globalData, fromCache: false });
             }
             catch (err) {

package/lib/api/routes-proxy.js

@@ -1,4 +1,4 @@
-import { sendJson, readJsonBody } from './route-helpers.js';
+import { sendJson, readJsonBody, guardLocalWrite } from './route-helpers.js';
 export function registerProxyRoutes(deps, checker, proxyManager) {
     const { bindRoute } = deps;
     // 1. 代理配置：GET 读取状态 / POST 保存并立即生效（写 proxy.json + 重应用 dispatcher，零插件重载）
@@ -18,6 +18,9 @@ export function registerProxyRoutes(deps, checker, proxyManager) {
                 sendJson(res, 405, { ok: false, message: '仅支持 GET / POST 请求' });
                 return;
             }
+            // 跨站门禁：代理配置写入会改变插件全部外联流量的走向。
+            if (!guardLocalWrite(req, res, { requireJson: true }))
+                return;
             if (!proxyManager) {
                 sendJson(res, 503, { ok: false, message: '当前运行环境未启用代理管理器' });
                 return;
@@ -47,6 +50,10 @@ export function registerProxyRoutes(deps, checker, proxyManager) {
                 sendJson(res, 405, { ok: false, message: '仅支持 POST 请求' });
                 return;
             }
+            // 无请求体，只校验 Origin。保持「每个 POST 端点都有跨站门禁」这条不变量，
+            // 否则下一个人加端点时又会漏。
+            if (!guardLocalWrite(req, res))
+                return;
             if (!proxyManager) {
                 sendJson(res, 503, { ok: false, message: '当前运行环境未启用代理管理器' });
                 return;

package/lib/api/routes.d.ts

@@ -16,4 +16,14 @@ import { UpgradeManager } from '../upgrade-manager.js';
 import { globalCacheTtlMs } from './route-helpers.js';
 import { type ProxyRouteManager } from './routes-proxy.js';
 export { globalCacheTtlMs };
-export declare function registerApiRoutes(ctxOrWebServer: any, executor: GhExecutor, workspaceRegistry?: any, cacheTtlMs?: number, updateChecker?: UpdateChecker, upgradeManager?: UpgradeManager, proxyManager?: ProxyRouteManager): void;
+export declare function registerApiRoutes(ctxOrWebServer: any, executor: GhExecutor, cacheTtlMs?: number, updateChecker?: UpdateChecker, upgradeManager?: UpgradeManager, proxyManager?: ProxyRouteManager, 
+/**
+ * 显式 webServer 覆盖。
+ *
+ * 为什么必须显式传：cordis 的服务只有 `inject` 过才会挂在 `ctx` 上，而未 inject 时
+ * 读 `ctx.webServer` **不是返回 undefined，而是直接抛错**——
+ * `cannot get property "webServer" without inject`（cordis `src/reflect.ts:144-169`
+ * 的 Proxy get 陷阱）。所以 `ctx?.webServer` 这种"安全回退"根本不安全：它在
+ * CLI/TUI profile 里会把插件从「PENDING」变成「加载失败」。
+ */
+webServerOverride?: any): void;

package/lib/api/routes.js

@@ -8,9 +8,22 @@ import { registerLifecycleRoutes } from './routes-lifecycle.js';
 import { registerProxyRoutes } from './routes-proxy.js';
 // 再导出历史公共接口：globalCacheTtlMs 曾被测试直接 import，保持路径稳定避免破坏消费方
 export { globalCacheTtlMs };
-export function registerApiRoutes(ctxOrWebServer, executor, workspaceRegistry, cacheTtlMs = 15_000, updateChecker, upgradeManager, proxyManager) {
+export function registerApiRoutes(ctxOrWebServer, executor, cacheTtlMs = 15_000, updateChecker, upgradeManager, proxyManager, 
+/**
+ * 显式 webServer 覆盖。
+ *
+ * 为什么必须显式传：cordis 的服务只有 `inject` 过才会挂在 `ctx` 上，而未 inject 时
+ * 读 `ctx.webServer` **不是返回 undefined，而是直接抛错**——
+ * `cannot get property "webServer" without inject`（cordis `src/reflect.ts:144-169`
+ * 的 Proxy get 陷阱）。所以 `ctx?.webServer` 这种"安全回退"根本不安全：它在
+ * CLI/TUI profile 里会把插件从「PENDING」变成「加载失败」。
+ */
+webServerOverride) {
     const ctx = ctxOrWebServer;
-    const webServer = ctx?.webServer || ctx;
+    // 只对「真 Context」走 ctx.get()：ctx.get 是 Context 原型方法，读它永远安全；
+    // 而 `ctx.webServer` 只有确定 ctx 不是 cordis Proxy（即测试用的普通对象）时才能读。
+    const isCordisContext = typeof ctx?.get === 'function';
+    const webServer = webServerOverride ?? (isCordisContext ? ctx.get('webServer') : (ctx?.webServer ?? ctx));
     if (!webServer || typeof webServer.register !== 'function')
         return;
     const checker = updateChecker || new UpdateChecker();

package/lib/cache.d.ts

@@ -74,25 +74,4 @@ export declare class TtlCache<T> {
      * 与 matchesFingerprint 分开：判定与处置是两件事，调用点语义更清晰。
      */
     invalidateIfFingerprintChanged(key: string, currentFingerprint: string | null | undefined): boolean;
-    /**
-     * 身份校验：缓存里的「仓库身份」是否仍与当前事实一致。
-     *
-     * @deprecated 自 S1 起由 matchesFingerprint 取代，**当前生产代码与测试均无调用点**。
-     *   保留的唯一目的是 S1 的回滚路径：若指纹方案出问题，把 routes-overview
-     *   的两行调用切回身份比对即可，无需恢复已删除的代码。
-     *   计划在 S2（离线解析对齐 git 规则）完成后连同 getRepoIdentityFromLocal 一并删除。
-     *
-     * 为什么必须取代它：该方法依赖 `.git/config` 的解析结果，而解析器在多 remote
-     * 布局下会取错段（实测），导致身份恒失配 → 缓存永久失效。
-     *
-     * @param key 工作区路径
-     * @param currentNameWithOwner 当前从本地 .git/config 解析出的 owner/repo
-     */
-    matchesIdentity(key: string, currentNameWithOwner: string | null | undefined): boolean;
-    /**
-     * 仅在身份失配时作废该键。返回是否真的作废。
-     *
-     * @deprecated 同 matchesIdentity，改用 invalidateIfFingerprintChanged。
-     */
-    invalidateIfIdentityChanged(key: string, currentNameWithOwner: string | null | undefined): boolean;
 }

package/lib/cache.js

@@ -129,41 +129,4 @@ export class TtlCache {
         this.evict(key);
         return true;
     }
-    /**
-     * 身份校验：缓存里的「仓库身份」是否仍与当前事实一致。
-     *
-     * @deprecated 自 S1 起由 matchesFingerprint 取代，**当前生产代码与测试均无调用点**。
-     *   保留的唯一目的是 S1 的回滚路径：若指纹方案出问题，把 routes-overview
-     *   的两行调用切回身份比对即可，无需恢复已删除的代码。
-     *   计划在 S2（离线解析对齐 git 规则）完成后连同 getRepoIdentityFromLocal 一并删除。
-     *
-     * 为什么必须取代它：该方法依赖 `.git/config` 的解析结果，而解析器在多 remote
-     * 布局下会取错段（实测），导致身份恒失配 → 缓存永久失效。
-     *
-     * @param key 工作区路径
-     * @param currentNameWithOwner 当前从本地 .git/config 解析出的 owner/repo
-     */
-    matchesIdentity(key, currentNameWithOwner) {
-        if (!currentNameWithOwner)
-            return true;
-        const cached = this.fallbackStore.get(key) ?? this.store.get(key)?.data;
-        if (!cached)
-            return true;
-        const cachedRepo = cached?.repo;
-        const cachedName = typeof cachedRepo?.nameWithOwner === 'string' ? cachedRepo.nameWithOwner : '';
-        if (!cachedName)
-            return true;
-        return cachedName.toLowerCase() === currentNameWithOwner.toLowerCase();
-    }
-    /**
-     * 仅在身份失配时作废该键。返回是否真的作废。
-     *
-     * @deprecated 同 matchesIdentity，改用 invalidateIfFingerprintChanged。
-     */
-    invalidateIfIdentityChanged(key, currentNameWithOwner) {
-        if (this.matchesIdentity(key, currentNameWithOwner))
-            return false;
-        this.evict(key);
-        return true;
-    }
 }

package/lib/client.d.ts

@@ -22,7 +22,8 @@ import { SyncStatusBadge } from './ui/sync-status-badge.js';
 import { CommitDetailModal } from './ui/commit-modal.js';
 import { PrDetailModal } from './ui/pr-modal.js';
 import { IssueDetailModal } from './ui/issue-modal.js';
+import { RunDetailModal } from './ui/run-modal.js';
 import { GlobalSyncSettingsModal } from './ui/sync-settings-modal.js';
 import { GithubHelpModal } from './ui/help-modal.js';
 import { GithubWorkspacePanel } from './ui/workspace-panel.js';
-export { formatRelativeTime, rollupCiStatus, reviewDecisionBadge, eventLabel, parseGitStatText, GITHUB_PANEL_CSS, injectStyles, renderOctocat, renderGitIcon, renderOctocatBadge, renderPluginBadge, getLocalSyncSettings, saveLocalSyncSettings, getStoredGlobalOverview, saveStoredGlobalOverview, clearStoredGlobalOverview, getCacheStorageMeta, getRightbarStorageKey, getStoredRightbarSnapshot, saveStoredRightbarData, getStoredHeaderCardsVisible, saveStoredHeaderCardsVisible, HEADER_CARDS_STORAGE_KEY, getStoredRightbarStateFilter, saveStoredRightbarStateFilter, PR_STATE_FILTERS, ISSUE_STATE_FILTERS, BranchSelectorDropdown, RepoSelectorDropdown, AuthGuideCard, UpgradeNotificationCard, NetworkAlertBanner, RepoNoticeBar, resolveRepoBadges, SyncStatusBadge, CommitDetailModal, PrDetailModal, IssueDetailModal, GlobalSyncSettingsModal, GithubHelpModal, GithubWorkspacePanel, };
+export { formatRelativeTime, rollupCiStatus, reviewDecisionBadge, eventLabel, parseGitStatText, GITHUB_PANEL_CSS, injectStyles, renderOctocat, renderGitIcon, renderOctocatBadge, renderPluginBadge, getLocalSyncSettings, saveLocalSyncSettings, getStoredGlobalOverview, saveStoredGlobalOverview, clearStoredGlobalOverview, getCacheStorageMeta, getRightbarStorageKey, getStoredRightbarSnapshot, saveStoredRightbarData, getStoredHeaderCardsVisible, saveStoredHeaderCardsVisible, HEADER_CARDS_STORAGE_KEY, getStoredRightbarStateFilter, saveStoredRightbarStateFilter, PR_STATE_FILTERS, ISSUE_STATE_FILTERS, BranchSelectorDropdown, RepoSelectorDropdown, AuthGuideCard, UpgradeNotificationCard, NetworkAlertBanner, RepoNoticeBar, resolveRepoBadges, SyncStatusBadge, CommitDetailModal, PrDetailModal, IssueDetailModal, RunDetailModal, GlobalSyncSettingsModal, GithubHelpModal, GithubWorkspacePanel, };