dsh-github-flow 0.4.0 → 0.6.0

package/lib/api/routes-actions.js

@@ -141,8 +141,12 @@ export function registerActionRoutes(deps, executor, cacheMap, globalCache) {
         kind: 'exact',
         path: '/api/github/refresh',
         handler: async (req, res) => {
-            cacheMap.clear();
-            globalCache.clear();
+            // 连容灾底座一起清：用户点「重试刷新」的语义是「宁可空白也重来」。
+            // 只清活动缓存会留下一个致命死角——失败分支从不写缓存，于是 fallback
+            // 里的旧快照一旦冻结就永久生效（仓库身份改错了也永远出不来），
+            // 刷新按钮点了等于没点。
+            cacheMap.clear({ keepFallback: false });
+            globalCache.clear({ keepFallback: false });
             sendJson(res, 200, { ok: true, message: '缓存已清空，下次读取将拉取最新数据' });
         },
     });
@@ -155,9 +159,30 @@ export function registerActionRoutes(deps, executor, cacheMap, globalCache) {
                 sendJson(res, 405, { ok: false, message: '仅支持 POST 请求' });
                 return;
             }
+            // 请求体上限：这些 action 的载荷都是短参数（标题/分支/PR 编号），
+            // 正常远小于 1KB。裸 `body += chunk` 无上限意味着一个超大 POST 能把
+            // 整个请求体堆进进程内存——本地服务也不该留这种自伤通道。
+            const MAX_ACTION_BODY_BYTES = 256 * 1024;
             let body = '';
-            req.on('data', (chunk) => { body += chunk; });
+            let bodyBytes = 0;
+            let bodyTooLarge = false;
+            req.on('data', (chunk) => {
+                if (bodyTooLarge)
+                    return;
+                bodyBytes += chunk.length;
+                if (bodyBytes > MAX_ACTION_BODY_BYTES) {
+                    bodyTooLarge = true;
+                    body = '';
+                    // 报 KB 而非字节数：262144 这种数字对人没有意义
+                    sendJson(res, 413, { ok: false, error: `请求体超过 ${MAX_ACTION_BODY_BYTES / 1024}KB 上限` });
+                    req.destroy();
+                    return;
+                }
+                body += chunk;
+            });
             req.on('end', async () => {
+                if (bodyTooLarge)
+                    return;
                 try {
                     const payload = body ? JSON.parse(body) : {};
                     const cwd = payload.cwd || process.cwd();
@@ -243,6 +268,67 @@ export function registerActionRoutes(deps, executor, cacheMap, globalCache) {
                             sendJson(res, 200, { ok: true, currentBranch: r.currentBranch, message: `已成功切换到分支 ${r.currentBranch}` });
                             break;
                         }
+                        case 'set_default_repo':
+                        case 'set_active_repo': {
+                            const target = typeof payload.repo === 'string' ? payload.repo.trim() : (typeof payload.remote === 'string' ? payload.remote.trim() : '');
+                            if (!target) {
+                                sendJson(res, 400, { ok: false, error: '缺少目标仓库全名或 remote 别名' });
+                                return;
+                            }
+                            const r = await executor.setDefaultRepo(cwd, target);
+                            if (!r.ok) {
+                                sendJson(res, 400, { ok: false, error: r.error });
+                                return;
+                            }
+                            // 彻底重置缓存（包含容灾快照），使下一次概览请求立即以新基准重新发起探测
+                            cacheMap.clear({ keepFallback: false });
+                            globalCache.clear({ keepFallback: false });
+                            sendJson(res, 200, {
+                                ok: true,
+                                target: r.target,
+                                message: `已成功将基准仓库切换为 ${r.target}`,
+                            });
+                            break;
+                        }
+                        case 'file_diff':
+                        case 'get_file_diff': {
+                            const fileTarget = typeof payload.file === 'string' ? payload.file.trim() : (typeof payload.filePath === 'string' ? payload.filePath.trim() : '');
+                            if (!fileTarget) {
+                                sendJson(res, 400, { ok: false, error: '缺少目标文件路径' });
+                                return;
+                            }
+                            const resolvedCwd = executor.resolveWorkspaceCwd(cwd);
+                            const r = await executor.getFileDiff(resolvedCwd, fileTarget);
+                            sendJson(res, 200, { ok: r.ok, data: r, error: r.error });
+                            break;
+                        }
+                        case 'uncommitted_files':
+                        case 'get_uncommitted_files': {
+                            const limit = Math.min(Math.max(1, Number(payload.limit) || 15), 100);
+                            const skip = Math.max(0, Number(payload.skip) || 0);
+                            const resolvedCwd = executor.resolveWorkspaceCwd(cwd);
+                            const r = await executor.getUncommittedFiles(resolvedCwd, limit, skip);
+                            sendJson(res, 200, { ok: true, data: r });
+                            break;
+                        }
+                        case 'pr_detail':
+                        case 'get_pr_detail': {
+                            const prNumber = Number(payload.number || payload.prNumber);
+                            const targetRepo = typeof payload.repo === 'string' ? payload.repo.trim() : undefined;
+                            const r = await executor.getPrDetail(cwd, prNumber, targetRepo);
+                            sendJson(res, r.ok ? 200 : 400, r);
+                            break;
+                        }
+                        case 'issue_detail':
+                        case 'get_issue_detail': {
+                            // 与 pr_detail 对称的 Issue 详情通道：供 POST 调用方（Agent/脚本）复用，
+                            // 与 GET /api/github/issue-detail 共用同一个 executor 方法。
+                            const issueNumber = Number(payload.number || payload.issueNumber || payload.issue_number);
+                            const targetRepo = typeof payload.repo === 'string' ? payload.repo.trim() : undefined;
+                            const r = await executor.getIssueDetail(cwd, issueNumber, targetRepo);
+                            sendJson(res, r.ok ? 200 : 400, r);
+                            break;
+                        }
                         default:
                             sendJson(res, 400, { ok: false, message: `未知的操作类型: ${payload.action}` });
                     }
@@ -286,9 +372,30 @@ export function registerActionRoutes(deps, executor, cacheMap, globalCache) {
                 sendJson(res, 405, { ok: false, message: '仅支持 POST 请求' });
                 return;
             }
+            // 请求体上限：这些 action 的载荷都是短参数（标题/分支/PR 编号），
+            // 正常远小于 1KB。裸 `body += chunk` 无上限意味着一个超大 POST 能把
+            // 整个请求体堆进进程内存——本地服务也不该留这种自伤通道。
+            const MAX_ACTION_BODY_BYTES = 256 * 1024;
             let body = '';
-            req.on('data', (chunk) => { body += chunk; });
+            let bodyBytes = 0;
+            let bodyTooLarge = false;
+            req.on('data', (chunk) => {
+                if (bodyTooLarge)
+                    return;
+                bodyBytes += chunk.length;
+                if (bodyBytes > MAX_ACTION_BODY_BYTES) {
+                    bodyTooLarge = true;
+                    body = '';
+                    // 报 KB 而非字节数：262144 这种数字对人没有意义
+                    sendJson(res, 413, { ok: false, error: `请求体超过 ${MAX_ACTION_BODY_BYTES / 1024}KB 上限` });
+                    req.destroy();
+                    return;
+                }
+                body += chunk;
+            });
             req.on('end', async () => {
+                if (bodyTooLarge)
+                    return;
                 try {
                     const payload = body ? JSON.parse(body) : {};
                     const cwd = payload.cwd || undefined;
@@ -316,7 +423,52 @@ export function registerActionRoutes(deps, executor, cacheMap, globalCache) {
             });
         },
     });
-    // 5. 本地 Git 元数据定向监听（专供右侧栏开启「本地 Git 改动实时感知」时长轮询）
+    // 5. PR 在线详情与代码差异比对（在线代码审阅专用，单次往返聚合元数据、评论流与按文件切片的 Unified Diff）
+    bindRoute({
+        kind: 'exact',
+        path: '/api/github/pr-detail',
+        handler: async (req, res) => {
+            if (req.method !== 'GET') {
+                sendJson(res, 405, { ok: false, message: '仅支持 GET 请求' });
+                return;
+            }
+            try {
+                const u = new URL(req.url || '', 'http://127.0.0.1');
+                const number = Number(u.searchParams.get('number') || u.searchParams.get('prNumber'));
+                const cwd = u.searchParams.get('cwd') || undefined;
+                const repo = u.searchParams.get('repo') || undefined;
+                const r = await executor.getPrDetail(cwd, number, repo);
+                sendJson(res, r.ok ? 200 : 400, r);
+            }
+            catch (err) {
+                sendJson(res, 500, { ok: false, error: err?.message || '读取 PR 详情异常' });
+            }
+        },
+    });
+    // 6. Issue 在线详情（正文 / 评论时间线 / 标签 / 里程碑 / 关联 PR）
+    // 与 pr-detail 同构：GET 读语义、单次往返、参数白名单校验全部下沉到 executor。
+    bindRoute({
+        kind: 'exact',
+        path: '/api/github/issue-detail',
+        handler: async (req, res) => {
+            if (req.method !== 'GET') {
+                sendJson(res, 405, { ok: false, message: '仅支持 GET 请求' });
+                return;
+            }
+            try {
+                const u = new URL(req.url || '', 'http://127.0.0.1');
+                const number = Number(u.searchParams.get('number') || u.searchParams.get('issueNumber'));
+                const cwd = u.searchParams.get('cwd') || undefined;
+                const repo = u.searchParams.get('repo') || undefined;
+                const r = await executor.getIssueDetail(cwd, number, repo);
+                sendJson(res, r.ok ? 200 : 400, r);
+            }
+            catch (err) {
+                sendJson(res, 500, { ok: false, error: err?.message || '读取 Issue 详情异常' });
+            }
+        },
+    });
+    // 7. 本地 Git 元数据定向监听（专供右侧栏开启「本地 Git 改动实时感知」时长轮询）
     // 严格安全纪律：只针对 .git/index 与 .git/HEAD 实施定向非递归监听，严禁监听源码目录防句柄耗尽；
     // 800ms 防抖合并；连接断开时自动关闭 watcher 释放系统资源（委托给底层 git-watcher 服务）。
     bindRoute({
@@ -353,4 +505,115 @@ export function registerActionRoutes(deps, executor, cacheMap, globalCache) {
             }
         },
     });
+    // 8. 纯本地 Git 状态毫秒级轻量查询（专供工作区改动时的局部定向刷新）
+    // 严格安全与性能纪律：
+    // 1. 动静解耦：仅执行本地 getLocalGitStatus、getGitCommitLog 与 getGitBranches；
+    // 2. 100% 零网络调用、零远端 GitHub API 请求、零 Token 额度消耗，耗时仅 5~10ms；
+    // 3. 彻底与 PR/Issue/Run 远端数据解耦，切断因修改本地文件误触发远端全量网络风暴与超时报错的恶性循环。
+    bindRoute({
+        kind: 'exact',
+        path: '/api/github/local-git-status',
+        handler: async (req, res) => {
+            if (req.method !== 'GET') {
+                sendJson(res, 405, { ok: false, message: '仅支持 GET 请求' });
+                return;
+            }
+            const url = new URL(req.url || '', 'http://127.0.0.1');
+            const cwd = url.searchParams.get('cwd');
+            if (!cwd || !hasGitDir(cwd)) {
+                sendJson(res, 400, { ok: false, error: '非 Git 仓库，无法获取本地 Git 状态' });
+                return;
+            }
+            try {
+                const gitStatus = await executor.getLocalGitStatus(cwd).catch(() => null);
+                const commitLog = await executor
+                    .getGitCommitLog(cwd, gitStatus ? gitStatus.hasUpstream : false)
+                    .catch(() => null);
+                const branches = await executor.getGitBranches(cwd).catch(() => null);
+                // 同步就地更新内存缓存中的本地元数据，保证后续全量请求也能自然拿到最新的本地状态
+                const cached = cacheMap.getFallback(cwd) || cacheMap.get(cwd, Date.now());
+                if (cached) {
+                    if (gitStatus)
+                        cached.gitStatus = gitStatus;
+                    if (commitLog)
+                        cached.commitLog = commitLog;
+                    if (branches)
+                        cached.branches = branches;
+                }
+                sendJson(res, 200, {
+                    ok: true,
+                    data: {
+                        gitStatus,
+                        commitLog,
+                        branches,
+                    },
+                    cwd,
+                });
+            }
+            catch (err) {
+                sendJson(res, 500, { ok: false, error: err?.message || '获取本地 Git 状态失败' });
+            }
+        },
+    });
+    // 9. 单个未提交文件的 Git Diff 差异查询（供右侧栏 FileDiffModal 调用）
+    bindRoute({
+        kind: 'exact',
+        path: '/api/github/file-diff',
+        handler: async (req, res) => {
+            if (req.method !== 'GET') {
+                sendJson(res, 405, { ok: false, message: '仅支持 GET 请求' });
+                return;
+            }
+            try {
+                const url = new URL(req.url || '', 'http://127.0.0.1');
+                const cwd = url.searchParams.get('cwd') || undefined;
+                const file = url.searchParams.get('file');
+                if (!file || !file.trim()) {
+                    sendJson(res, 400, { ok: false, error: '缺少必需的 file 参数' });
+                    return;
+                }
+                const resolvedCwd = executor.resolveWorkspaceCwd(cwd);
+                if (!hasGitDir(resolvedCwd)) {
+                    sendJson(res, 400, { ok: false, error: '当前工作区不是 Git 仓库' });
+                    return;
+                }
+                const diffResult = await executor.getFileDiff(resolvedCwd, file.trim());
+                if (!diffResult.ok) {
+                    sendJson(res, 400, { ok: false, error: diffResult.error || '获取文件差异失败' });
+                    return;
+                }
+                sendJson(res, 200, { ok: true, data: diffResult });
+            }
+            catch (err) {
+                sendJson(res, 500, { ok: false, error: err?.message || '获取文件差异失败' });
+            }
+        },
+    });
+    // 10. 本地未提交文件列表轻量流式分页查询（供右侧栏滑动加载调用）
+    bindRoute({
+        kind: 'exact',
+        path: '/api/github/uncommitted-files',
+        handler: async (req, res) => {
+            if (req.method !== 'GET') {
+                sendJson(res, 405, { ok: false, message: '仅支持 GET 请求' });
+                return;
+            }
+            try {
+                const url = new URL(req.url || '', 'http://127.0.0.1');
+                const cwd = url.searchParams.get('cwd') || undefined;
+                const limit = Math.min(Math.max(1, Number(url.searchParams.get('limit')) || 15), 100);
+                const skip = Math.max(0, Number(url.searchParams.get('skip')) || 0);
+                const resolvedCwd = executor.resolveWorkspaceCwd(cwd);
+                if (!hasGitDir(resolvedCwd)) {
+                    sendJson(res, 400, { ok: false, error: '当前工作区不是 Git 仓库' });
+                    return;
+                }
+                const result = await executor.getUncommittedFiles(resolvedCwd, limit, skip);
+                sendJson(res, 200, { ok: true, data: result });
+            }
+            catch (err) {
+                sendJson(res, 500, { ok: false, error: err?.message || '获取未提交文件列表失败' });
+            }
+        },
+    });
 }

package/lib/api/routes-overview.js

@@ -1,7 +1,20 @@
 import { mapLimit, tryReadWorkspaces, findWorkspacePathBySession, findMostRecentWorkspacePath, hasGitDir } from '../workspace.js';
 import { resolveIssueCategories, calculateIssueStats, basenameSafe, sendJson } from './route-helpers.js';
+import { describeDeterministicError } from '../executor/error-classifier.js';
 /** 探测单个工作区时在途的 gh 进程数上限；libuv 线程池默认 4，留出余量给其他请求 */
 const WORKSPACE_PROBE_CONCURRENCY = 3;
+/**
+ * 右侧栏单仓库 PR / Issue 的展示条数上限。
+ *
+ * 为什么从 10 提到 20：加上 `--state all` 后列表里混入了 closed/merged，
+ * 而 `gh pr list` 的排序依据是 **number 降序**（实测 30 条验证：14763、14752、
+ * 14751 …… 严格递减），不是 updatedAt。取 10 条时实测 cli/cli 只剩 5 条非 OPEN，
+ * 用户切到「Merged」可能只有 2-3 条，筛选体验形同虚设。
+ * 多拉 10 条的代价可忽略（同一个 gh 进程，仅 JSON 体积略增），
+ * 但绝不能改成「每个状态各查一次」——那会把 3 个 gh 子进程变成 6~9 个，
+ * 右侧栏首屏本就受 Promise.all 8 秒超时约束。
+ */
+const RIGHTBAR_LIST_LIMIT = 20;
 export function registerOverviewRoutes(deps, executor, cacheMap, globalCache, checker) {
     const { bindRoute } = deps;
     // 1. 获取全局与当前仓库的 GitHub 概览
@@ -29,6 +42,19 @@ export function registerOverviewRoutes(deps, executor, cacheMap, globalCache, ch
                     cwd = process.cwd();
                 }
                 const now = Date.now();
+                // 先行检查当前工作区是否真实包含 .git，无 .git 铁证判定为未关联仓库
+                const isGitRepo = hasGitDir(cwd);
+                // 缓存失效判定：比对 remote 配置指纹，而不是比对解析出的仓库身份。
+                //
+                // 为什么换：身份比对把「解析器的正确性」变成了「缓存有效性的前置条件」。
+                // 多 remote 布局下（如 upstream 段写在 origin 段之前），取「第一个
+                // github.com 匹配」会拿到上游仓库，与缓存里的 fork 身份恒失配，于是
+                // 每次请求都作废缓存、重拉 6 个 gh 子进程。指纹只回答「配置变没变」，
+                // 不依赖任何语义理解，对该类偏差免疫。
+                //
+                // 指纹读取是纯本地 readFileSync（几 KB），与 hasGitDir 同级开销，零子进程。
+                const remoteFingerprint = isGitRepo ? executor.getRemoteFingerprint(cwd) : null;
+                cacheMap.invalidateIfFingerprintChanged(cwd, remoteFingerprint);
                 const cachedData = cacheMap.get(cwd, now);
                 if (cachedData && !force) {
                     sendJson(res, 200, {
@@ -40,9 +66,12 @@ export function registerOverviewRoutes(deps, executor, cacheMap, globalCache, ch
                     return;
                 }
                 const auth = await executor.checkAuth(cwd);
-                // 先行检查当前工作区是否真实包含 .git，无 .git 铁证判定为未关联仓库
-                const isGitRepo = hasGitDir(cwd);
                 const repo = isGitRepo ? await executor.getRepoMetadata(cwd) : null;
+                if (repo) {
+                    // 推导当前工作区可用的关联仓库（如 origin/Fork 与 upstream/Parent），
+                    // 仅在存在多个关联仓库或 Fork 场景下供 UI 渲染手动切换控件。
+                    repo.associatedRepos = executor.getAssociatedRepos(cwd, repo, auth?.user);
+                }
                 // 若当前工作区未关联 Git 仓库，直接返回纯净空状态，坚决不拉取远端数据
                 if (!isGitRepo || !repo) {
                     const emptyData = {
@@ -55,35 +84,72 @@ export function registerOverviewRoutes(deps, executor, cacheMap, globalCache, ch
                         lastUpdated: new Date().toISOString(),
                         updateInfo: checker.getQuickStatus(),
                     };
-                    cacheMap.set(cwd, emptyData, now);
+                    cacheMap.set(cwd, emptyData, now, remoteFingerprint);
                     sendJson(res, 200, { ok: true, data: emptyData, fromCache: false, cwd });
                     return;
                 }
                 let pullRequests = [];
                 let issues = [];
                 let runs = [];
+                // 确定性降级说明（非错误）：在 if 块内累积、在块外随响应一起落缓存，
+                // 因此必须在请求作用域声明，不能藏在分支里。
+                const deterministicNotices = [];
                 // 面板增强信息载体（git 状态/Release 锚定/分支 PR——全部可选字段，
                 // 进缓存与快照时旧消费方零破坏，渲染层 ?. 兜底）
                 const freshExtras = {};
                 if (repo && auth.loggedIn) {
-                    // 并发拉取当前文件夹仓库的 PRs、Issues 和 Runs
+                    /*
+                     * 并发拉取当前文件夹仓库的 PRs、Issues 和 Runs。
+                     *
+                     * 必须显式传 `--state all`：gh 的默认值是 open，不传就只剩未关闭记录。
+                     * 本仓库实测 `pr list` 默认返回 []、`--state all` 才返回 [#6 CLOSED]——
+                     * 右侧栏「只显示已打开」的根因就在这里，靠前端加筛选器救不回来，
+                     * 因为数据在到达浏览器前就被 gh 过滤掉了。
+                     * 与全局面板（gh search，phase29 已移除 --state=open）保持同一口径。
+                     */
                     const [prsRes, issuesRes, runsRes] = await Promise.all([
-                        executor.run(['pr', 'list', '--json', 'number,title,state,author,headRefName,baseRefName,isDraft,mergeable,reviewDecision,statusCheckRollup,url,updatedAt', '-L', '10'], { cwd, timeoutMs: 8_000 }),
-                        executor.run(['issue', 'list', '--json', 'number,title,state,author,labels,assignees,url,updatedAt', '-L', '10'], { cwd, timeoutMs: 8_000 }),
+                        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 }),
+                        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 }),
                     ]);
-                    // 核心数据拉取故障检测：若拉取核心业务数据遭遇失败（网络超时/断网/接口报错），
-                    // 绝对不能把失败伪装成「0 个 PR、0 个 Issue」并假装成功返回！
-                    const failures = [];
-                    if (!prsRes.ok)
-                        failures.push(`PR 获取失败: ${prsRes.error || '网络或接口异常'}`);
-                    if (!issuesRes.ok)
-                        failures.push(`Issue 获取失败: ${issuesRes.error || '网络或接口异常'}`);
-                    if (!runsRes.ok)
-                        failures.push(`Actions 获取失败: ${runsRes.error || '网络或接口异常'}`);
-                    if (failures.length > 0) {
-                        const failureReason = failures.join('；');
-                        // 若此前内存有缓存，保全已有缓存内容，附加 networkError 与 partialFailure
+                    // 核心数据拉取故障检测：把失败按语义拆成两堆。
+                    //
+                    // 为什么必须拆：`gh` 对所有失败都返回非零退出，但两类失败的性质完全不同——
+                    // · 确定性（仓库关了 Issues / 仓库不存在 / 无权限）：重试一万次也还是失败，
+                    //   正确处置是「该字段降级为空列表 + 一句说明」，绝不能伪装成网络故障；
+                    // · 传输层（超时 / 断连 / 代理阻断）：值得回退历史快照并允许重试。
+                    // 旧实现把两者混为一谈，导致「仓库关了 Issues」弹出「网络连接失败」横幅，
+                    // 还被客户端重试器当成可恢复抖动反复空烧。
+                    const transientFailures = [];
+                    const collectFailure = (res, label) => {
+                        if (res.ok)
+                            return;
+                        const msg = res.error || '接口异常';
+                        // errorKind 由 GhExecutor 统一分类（单一事实源），这里只做分流
+                        if (res.errorKind === 'deterministic') {
+                            deterministicNotices.push(`${label}: ${describeDeterministicError(msg) || msg}`);
+                        }
+                        else {
+                            transientFailures.push(`${label}: ${msg}`);
+                        }
+                    };
+                    collectFailure(prsRes, 'PR 获取失败');
+                    collectFailure(issuesRes, 'Issue 获取失败');
+                    collectFailure(runsRes, 'Actions 获取失败');
+                    if (transientFailures.length > 0) {
+                        const failureReason = transientFailures.join('；');
+                        // 若此前内存有缓存，保全已有缓存内容，附加 networkError 与 partialFailure。
+                        // repo 必须用本次新鲜解析值覆盖：列表数据旧一点可以接受，仓库身份旧了就是错的
+                        // （典型场景：用户把 origin 从上游换成自己的 fork 后，issue list 永久失败，
+                        //  失败分支从不写缓存，旧身份被 freeze 在 fallback 里永远出不来）。
                         const fallbackCached = cacheMap.getFallback(cwd) || cacheMap.get(cwd, now);
                         if (fallbackCached && (fallbackCached.pullRequests.length > 0 || fallbackCached.issues.length > 0 || fallbackCached.runs.length > 0)) {
                             sendJson(res, 200, {
@@ -93,6 +159,7 @@ export function registerOverviewRoutes(deps, executor, cacheMap, globalCache, ch
                                 error: failureReason,
                                 data: {
                                     ...fallbackCached,
+                                    repo: repo || fallbackCached.repo,
                                     networkError: true,
                                     networkErrorReason: failureReason,
                                     auth: { ...fallbackCached.auth, networkError: true, networkErrorReason: failureReason },
@@ -165,6 +232,13 @@ export function registerOverviewRoutes(deps, executor, cacheMap, globalCache, ch
                     freshExtras.branches = await executor.getGitBranches(cwd).catch(() => null);
                 }
                 const issueStats = calculateIssueStats(issues);
+                /*
+                 * 截断必须可感知：`--state all` + 固定条数上限意味着历史记录可能被截掉，
+                 * 若不透出，用户切到「Closed」看到 3 条会以为仓库只有 3 个已关闭 PR。
+                 * 与全局面板 prsTruncated 同一口径。
+                 */
+                const prsTruncated = pullRequests.length >= RIGHTBAR_LIST_LIMIT;
+                const issuesTruncated = issues.length >= RIGHTBAR_LIST_LIMIT;
                 const freshData = {
                     auth,
                     repo: repo || undefined,
@@ -174,9 +248,15 @@ export function registerOverviewRoutes(deps, executor, cacheMap, globalCache, ch
                     runs,
                     lastUpdated: new Date().toISOString(),
                     updateInfo: checker.getQuickStatus(),
+                    // 确定性降级说明随数据一起落缓存：它是仓库的稳定属性（Issues 关着就一直关着），
+                    // 每次请求重新声明没有意义，也不该让它冒泡成 networkError。
+                    ...(deterministicNotices.length > 0 ? { notices: deterministicNotices } : {}),
+                    // 仅在真的触顶时才下发，避免给正常场景增加无意义字段
+                    ...(prsTruncated ? { prsTruncated: true } : {}),
+                    ...(issuesTruncated ? { issuesTruncated: true } : {}),
                     ...freshExtras,
                 };
-                cacheMap.set(cwd, freshData, now);
+                cacheMap.set(cwd, freshData, now, remoteFingerprint);
                 sendJson(res, 200, { ok: true, data: freshData, fromCache: false, cwd });
             }
             catch (err) {
@@ -213,6 +293,10 @@ export function registerOverviewRoutes(deps, executor, cacheMap, globalCache, ch
                 let issueStats = { total: 0, reported: 0, assigned: 0, created: 0 };
                 let workspaceMatrix = [];
                 let workspaceError;
+                /** PR 检索是否触及 limit（命中即说明可能还有更早的 PR 未返回） */
+                let prsTruncated = false;
+                // 全局驾驶舱的确定性降级说明（同单仓库口径：在分支内累积、块外落缓存）
+                const globalNotices = [];
                 if (auth.loggedIn) {
                     // 并发执行：1. 账号下仓库列表 2. 个人 PRs 3. 三维 Issue 检索（名下仓库用户提单 + 指派待办 + 我创建的）
                     // 为什么三路并发搜索：
@@ -220,25 +304,47 @@ export function registerOverviewRoutes(deps, executor, cacheMap, globalCache, ch
                     // - --assignee=@me: 捕获团队成员或自己指派给当前账号的待办任务 (含跨组织/第三方项目)
                     // - --author=@me: 捕获当前账号亲自发起的任务与向外部提起的议题
                     // 3 个轻量进程与 repo/prs 同步 spawn，经 OS 并发调度实测仅耗时 3 秒出头，完全满足 8 秒超时门限。
-                    const issueFields = 'number,title,repository,author,assignees,labels,url,updatedAt';
+                    // 为什么不再限定 --state=open：
+                    // 实测当前账号 7 个 PR 全为 merged/closed、5 个 Issue 全为 closed，
+                    // `--state=open` 恒返回空数组（退出码仍为 0，属于"正确但无用"）。
+                    // 用户看到的就是一片空白，且无法区分「确实没有」与「请求失败」。
+                    // 改为拉全量并在前端做状态筛选：数据先可见，再谈收敛。
+                    // 同时 --json 必须补上 state 字段——不下发的话前端根本无从筛选。
+                    const issueFields = 'number,title,state,repository,author,assignees,labels,url,updatedAt';
+                    /**
+                     * 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', '--state=open', '--limit', '10', '--json', 'number,title,repository,url,updatedAt,isDraft'], { timeoutMs: 8_000 }),
-                        executor.run(['search', 'issues', '--owner=@me', '--state=open', '--sort=updated', '--limit', '15', '--json', issueFields], { timeoutMs: 8_000 }),
-                        executor.run(['search', 'issues', '--assignee=@me', '--state=open', '--sort=updated', '--limit', '15', '--json', issueFields], { timeoutMs: 8_000 }),
-                        executor.run(['search', 'issues', '--author=@me', '--state=open', '--sort=updated', '--limit', '15', '--json', issueFields], { 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 }),
                     ]);
                     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 };
-                    // 检测全局拉取是否发生网络故障，绝不把网络失败当作「0 仓库、0 PR」伪造成功
+                    // 检测全局拉取是否发生网络故障，绝不把网络失败当作「0 仓库、0 PR」伪造成功。
+                    // 与单仓库概览同一口径：确定性失败（账号级搜索本就不存在确定性场景，
+                    // 但仓库列表拉取可能命中 404/403）不进入网络故障分支，只作为 notice 透出。
                     const globalFailures = [];
-                    if (!reposRes.ok)
-                        globalFailures.push(`仓库列表拉取失败: ${reposRes.error || '网络或接口异常'}`);
-                    if (!prsRes.ok)
-                        globalFailures.push(`个人 PR 拉取失败: ${prsRes.error || '网络或接口异常'}`);
+                    const collectGlobalFailure = (res, label) => {
+                        if (res.ok)
+                            return;
+                        const msg = res.error || '接口异常';
+                        if (res.errorKind === 'deterministic') {
+                            globalNotices.push(`${label}: ${describeDeterministicError(msg) || msg}`);
+                        }
+                        else {
+                            globalFailures.push(`${label}: ${msg}`);
+                        }
+                    };
+                    collectGlobalFailure(reposRes, '仓库列表拉取失败');
+                    collectGlobalFailure(prsRes, '个人 PR 拉取失败');
                     if (globalFailures.length > 0) {
                         const globalNetReason = globalFailures.join('；');
                         const fallbackGlobal = globalCache.getFallback('global') || globalCache.get('global', now);
@@ -272,6 +378,15 @@ 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。
+                         */
+                        if (myPrs.length >= PR_SEARCH_LIMIT)
+                            prsTruncated = true;
                     }
                     // 多源 Issues 聚合、按 URL 唯一去重并排序
                     const issueMap = new Map();
@@ -343,6 +458,9 @@ export function registerOverviewRoutes(deps, executor, cacheMap, globalCache, ch
                     lastUpdated: new Date().toISOString(),
                     updateInfo: checker.getQuickStatus(),
                     ...(workspaceError ? { workspaceError } : {}),
+                    // 仅在真的触顶时才下发，避免给正常场景增加无意义字段
+                    ...(prsTruncated ? { prsTruncated: true } : {}),
+                    ...(globalNotices.length > 0 ? { notices: globalNotices } : {}),
                 };
                 globalCache.set('global', globalData, now);
                 sendJson(res, 200, { ok: true, data: globalData, fromCache: false });