dsh-github-flow 0.5.0 → 0.7.0

package/lib/executor.js

@@ -1,16 +1,122 @@
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
+import crypto from 'node:crypto';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { findMostRecentWorkspacePath, findWorkspacePathBySession, hasGitDir } from './workspace.js';
+// 图片 URL 提取复用 Agent 工具链的同一份实现：弹窗只展示计数与外链，
+// 但「哪些 URL 算图片」必须与 github_issue(view_images) 完全同源，否则
+// 用户会看到「附件 2 张」却下载不到对应图片。
+import { extractImageUrls } from './tools/image-utils.js';
 // 子模块纯函数解耦导入并对外部 Re-export 保证 100% 向后兼容
 import { parseGhVersion, compareGhVersions } from './executor/version-utils.js';
 import { spawnWithStdin, safeSlice, cutByUtf8Bytes, truncateOutput } from './executor/process-utils.js';
-import { parseGitStatusOutput, parseGitLogLines, parseGitBranchLines, parseUncommittedDiff, parseGitStatText } from './executor/git-parser.js';
+import { buildPrReviewPayload, foldCommentsIntoBody, isLineCommentRejected } from './executor/pr-review.js';
+import { parseGitStatusOutput, parseGitLogLines, parseGitBranchLines, parseUncommittedDiff, parseGitStatText, parseRemoteUrls, parseGitConfig, resolveRemoteTarget, parseGithubUrl, parseRemoteHost, classifyRepoLayout, pickGithubRemote, splitUnifiedDiff, } from './executor/git-parser.js';
 import { getPlatformInstallGuide, getGhUpgradeHint } from './executor/platform-guide.js';
-export { parseGhVersion, compareGhVersions, spawnWithStdin, safeSlice, cutByUtf8Bytes, truncateOutput, parseGitStatusOutput, parseGitLogLines, parseGitBranchLines, parseUncommittedDiff, parseGitStatText, getPlatformInstallGuide, getGhUpgradeHint, };
+import { buildPlainFailureExcerpt, interpretRunLogError } from './executor/run-log.js';
+import { classifyGhError, describeDeterministicError, isRetryableError, permissionRemedy, isPermissionError } from './executor/error-classifier.js';
+export { parseGhVersion, compareGhVersions, spawnWithStdin, safeSlice, cutByUtf8Bytes, truncateOutput, parseGitStatusOutput, parseGitLogLines, parseGitBranchLines, parseUncommittedDiff, parseGitStatText, parseRemoteUrls, parseGitConfig, resolveRemoteTarget, parseGithubUrl, parseRemoteHost, classifyRepoLayout, pickGithubRemote, splitUnifiedDiff, getPlatformInstallGuide, getGhUpgradeHint, classifyGhError, describeDeterministicError, isRetryableError, permissionRemedy, isPermissionError, };
 const execFileAsync = promisify(execFile);
+/**
+ * `gh repo view` 的字段集。
+ *
+ * 为什么必须集中一处：同一份字段列表此前在 getRepoMetadata 里重复了两遍，
+ * 补字段时漏改一处就会出现「在线路径有 isFork、兜底路径没有」的不一致。
+ *
+ * 字段取舍：
+ *   - parent 只返回骨架（id/name/owner.login），不含 stargazerCount
+ *     ——`--json` 不支持嵌套子字段（实测 `Unknown JSON field: "parent.stargazerCount"`）
+ *   - viewerPermission 是只读仓库的写操作前置拦截依据
+ */
+const REPO_VIEW_FIELDS = 'nameWithOwner,name,owner,defaultBranchRef,description,isPrivate,url,stargazerCount,forkCount,isFork,parent,viewerPermission';
+/**
+ * `gh issue view --json` 的完整字段集（gh 2.96.0 实测的合法全集子集）。
+ *
+ * 为什么集中一处：同一份字段列表要被「常规调用」与「降级重试」两处消费，
+ * 散落成字面量必然漂移。字段取舍全部基于实测响应形态：
+ *   - `closedByPullRequestsReferences` 节点只有 id/number/repository/url，
+ *     不含 title/state，UI 因此只渲染编号链接；
+ *   - `milestone` 形态为 {number,title,description,dueOn}，没有 state；
+ *   - `subIssuesSummary` 为 {completed,percentCompleted,total}。
+ */
+const ISSUE_DETAIL_FULL_FIELDS = 'number,title,state,stateReason,author,createdAt,updatedAt,closedAt,url,body,labels,assignees,milestone,isPinned,issueType,comments,closedByPullRequestsReferences,subIssuesSummary';
+/**
+ * Issue 详情的降级字段集。
+ *
+ * 为什么需要：老版本 gh 遇到未知 JSON 字段会**整体失败**（实测
+ * `gh issue view --json bogusField` → `Unknown JSON field: "bogusField"`）。
+ * 这里只保留长期稳定、几乎不可能被移除的字段，保证低版本宿主仍能看到
+ * 正文与评论时间线——缺失的里程碑/关联 PR 只是少几个装饰位，不致命。
+ */
+const ISSUE_DETAIL_BASE_FIELDS = 'number,title,state,author,createdAt,updatedAt,url,body,labels,assignees,milestone,comments';
+/**
+ * `gh run view --json` 的完整字段集（gh 2.96.0 实测合法全集）。
+ *
+ * `jobs` 的值是一个树：job{ databaseId,name,status,conclusion,startedAt,
+ * completedAt,url,steps[] }，step{ number,name,status,conclusion,startedAt,
+ * completedAt }。**step 没有 url**，所以 UI 只能给到 job 级外链。
+ * `attempt` 供「第 N 次重跑」显示；`displayTitle` 在 workflow 名称之外给出
+ * 这次运行的业务描述（PR 标题/提交信息）。
+ */
+const RUN_DETAIL_FULL_FIELDS = 'attempt,conclusion,createdAt,databaseId,displayTitle,event,headBranch,headSha,jobs,name,number,startedAt,status,updatedAt,url,workflowDatabaseId,workflowName';
+/**
+ * Run 详情的降级字段集（老 gh 遇未知字段会整体失败，与 issue 详情同一处置）。
+ *
+ * 只保留 jobs 这一棵不可替代的树 + 少量基础元数据：缺了 attempt/displayTitle
+ * 只是少两个装饰位，缺了 jobs 这个功能就不存在了。
+ */
+const RUN_DETAIL_BASE_FIELDS = 'databaseId,name,status,conclusion,jobs,url,createdAt';
+/** 单次按需拉日志的 job 上限：矩阵构建下几十个失败 job 不再是「一次点击」能承受的量 */
+const RUN_LOG_MAX_JOBS = 3;
+/** 日志摘要的字符预算：不进程模型上下文，只进浏览器 DOM，但仍要防几万字拖卡渲染 */
+const RUN_LOG_BUDGET_CHARS = 120_000;
+/**
+ * 单次日志请求的总时间预算（毫秒）。
+ *
+ * 为什么不是「每个 job 60s，有 3 个就 180s」：这条链路挂在 HTTP 路由上，宿主
+ * WebServer 是整个 GUI 共享的。一次点击把连接占住三分钟，等于把面板卡死。
+ * 超预算的 job 会进 errors[]（可单独重试），用户能在 90s 内拿到已拉到的部分。
+ */
+const RUN_LOG_TOTAL_BUDGET_MS = 90_000;
+/**
+ * 把 `gh repo view --json` 的原始结果映射为 RepoMetadata。
+ *
+ * 抽出的理由：同一段映射原先在 getRepoMetadata 里写了两遍（上下文探测 + 精确探测），
+ * 逐字符相同。补 3 个字段要改两处，必然漂移。
+ *
+ * @param fallbackNameWithOwner d.nameWithOwner 缺失时的兜底（离线解析结果）
+ */
+function mapRepoMetadata(d, fallbackNameWithOwner) {
+    const nameWithOwner = d?.nameWithOwner || fallbackNameWithOwner || '';
+    const meta = {
+        nameWithOwner,
+        name: d?.name || '',
+        owner: d?.owner?.login || '',
+        defaultBranch: d?.defaultBranchRef?.name || 'main',
+        description: d?.description || '',
+        isPrivate: Boolean(d?.isPrivate),
+        url: d?.url || `https://github.com/${nameWithOwner}`,
+        stargazerCount: typeof d?.stargazerCount === 'number' ? d.stargazerCount : 0,
+        forkCount: typeof d?.forkCount === 'number' ? d.forkCount : 0,
+    };
+    if (typeof d?.isFork === 'boolean')
+        meta.isFork = d.isFork;
+    // parent 的 nameWithOwner 需自行拼接：gh 只给 {name, owner:{login}}
+    const parentOwner = d?.parent?.owner?.login;
+    const parentName = d?.parent?.name;
+    if (typeof d?.isFork === 'boolean' && d.isFork && typeof parentOwner === 'string' && typeof parentName === 'string') {
+        const parentFull = `${parentOwner}/${parentName}`;
+        meta.parent = { nameWithOwner: parentFull, url: `https://github.com/${parentFull}` };
+    }
+    // 只接受已知档位，未知值一律不带——避免把陌生的 gh 新档位当成可写权限
+    const perm = typeof d?.viewerPermission === 'string' ? d.viewerPermission.toUpperCase() : '';
+    if (perm === 'ADMIN' || perm === 'MAINTAIN' || perm === 'WRITE' || perm === 'TRIAGE' || perm === 'READ') {
+        meta.viewerPermission = perm;
+    }
+    return meta;
+}
 /** 认证状态缓存时长。用户手动 `gh auth login/logout` 后最多 30 秒内面板才会反映，属可接受代价 */
 const AUTH_CACHE_TTL_MS = 30_000;
 /** gh 版本缓存时长。与 authCache 同哲学：gh 升级是分钟级低频事件，30 秒陈旧窗口无实际影响 */
@@ -21,6 +127,14 @@ export class GhExecutor {
     maxOutputChars;
     /** UTF-8 字节口径的硬上限；未配置时按 maxOutputChars × 4 推导（覆盖 CJK 3 字节与 emoji 4 字节） */
     maxOutputBytes;
+    /**
+     * 累计 gh 子进程调用次数（只增不清零，`run()` 每次 +1）。
+     *
+     * 为什么需要：任务原语（github_task）要如实汇报 `cost.ghCalls`，
+     * 而「原语是否真的比手动串步骤省钱」是这个能力存在的唯一判据。
+     * 消费方用「调用前快照 → 调用后求差」的方式取区间计数。
+     */
+    ghCalls = 0;
     /**
      * 列表类查询的默认条数上限。
      * 为什么挂在 executor 而不是给每个工具工厂加 config 参数：executor 是全部
@@ -105,11 +219,51 @@ export class GhExecutor {
             return recent;
         return explicitCwd || process.cwd();
     }
+    /**
+     * 18 个工具的唯一工作区入口：把 execContext 归一成 `{ cwd, sessionId }`。
+     *
+     * 为什么必须走这里而不是各工具写 `execContext?.cwd || process.cwd()`：
+     * 三级解析里第 1 级是「显式 cwd 且磁盘存在即原样返回」，而 `process.cwd()`
+     * 恒满足该条件——于是第 2 级「按 sessionId 反查真实工作区」**永远不会触发**。
+     * 工具层把 `process.cwd()` 当兜底传下去，等于把整个会话亲和机制架空。
+     *
+     * ⚠️ 刻意**不复用** `resolveWorkspaceCwd` 的第 3 级（`findMostRecentWorkspacePath`）：
+     * 那一级是给「完全无上下文的 CLI 场景」用的，会把目录定到**最近活跃的任意仓库**。
+     * 工具调用的默认目录必须可预测——落到一个与本会话无关的仓库意味着读错库、
+     * 更糟的是写到错库（merge / release create / label delete 都会打错地方）。
+     * 实测：抹掉 DSH_SESSION_ID 后 `resolveWorkspaceCwd(undefined, undefined)` 返回的是
+     * 一个与本会话无关的仓库路径，而 `process.cwd()` 是当前进程目录。
+     *
+     * 解析顺序：显式 cwd（原样透传，含不存在的情况，与旧行为一致）→ session 反查 →
+     * process.cwd()。三级都拿不到时才回到进程目录，与 s5 之前的兜底完全一致。
+     */
+    resolveExecScope(execContext) {
+        const sessionId = execContext?.sessionId || execContext?.session?.id || process.env.DSH_SESSION_ID;
+        // 1) 显式 cwd 原样透传：这是唯一事实源，不做存在性替换，也不许被会话反查覆盖
+        if (execContext?.cwd)
+            return { cwd: execContext.cwd, sessionId };
+        // 2) 按会话反查真实工作区（旧实现被 process.cwd() 短路掉的那一级）
+        if (sessionId) {
+            const fromSession = findWorkspacePathBySession(sessionId);
+            if (fromSession)
+                return { cwd: fromSession, sessionId };
+        }
+        // 3) 兜底到进程目录。**不**调用 findMostRecentWorkspacePath()
+        return { cwd: process.cwd(), sessionId };
+    }
     /**
      * 安全执行 gh 命令
      * 采用 execFile 参数数组隔离，彻底杜绝 Shell 字符串拼接注入漏洞
      */
     async run(args, options = {}) {
+        /*
+         * gh 子进程调用计数（只增不清零）。
+         *
+         * 为什么放在 executor 而不是各工具里手数：任务原语（github_task）必须能如实
+         * 汇报 `cost.ghCalls`，而「原语是否真的省钱」是它存在的唯一判据。
+         * 手写计数必然与实际调用漂移——真实调用点只有这里一个。
+         */
+        this.ghCalls++;
         const cwd = this.resolveWorkspaceCwd(options.cwd, options.sessionId);
         const timeout = options.timeoutMs || this.defaultTimeoutMs;
         // 二进制模式（如 gh api 下载图片字节流）：stdout 保持 Buffer，绕过 UTF-8
@@ -162,7 +316,8 @@ export class GhExecutor {
                 const errBuf = Buffer.isBuffer(stderr) ? stderr : (stderr ? Buffer.from(String(stderr)) : null);
                 if (!buf.length) {
                     const errMsg = errBuf ? errBuf.toString('utf8').trim() : '';
-                    return { ok: false, error: errMsg || '二进制输出为空' };
+                    const msg = errMsg || '二进制输出为空';
+                    return { ok: false, error: msg, errorKind: classifyGhError(msg) };
                 }
                 return { ok: true, data: buf, binaryBytes: buf.length, truncated: false };
             }
@@ -172,7 +327,15 @@ export class GhExecutor {
             if (!rawOutput && errText) {
                 rawOutput = errText.trim();
             }
-            const outcome = truncateOutput(rawOutput, this.maxOutputChars, this.maxOutputBytes);
+            const maxChars = options.maxOutputChars ?? this.maxOutputChars;
+            // 字节上限联动推导：若调用方显式放宽了字符上限（如放宽到 1MB），未指定 maxOutputBytes 时
+            // 必须按 4 倍自动放宽，绝不能死板回落到全局实例的 96KB（否则 >96KB 的输出会被静默判定截断）。
+            // 取 Math.max 是为了不压低用户在 Config 里配置的更大 maxOutputBytes。
+            const maxBytes = options.maxOutputBytes ??
+                (options.maxOutputChars
+                    ? Math.max(options.maxOutputChars * 4, this.maxOutputBytes)
+                    : this.maxOutputBytes);
+            const outcome = truncateOutput(rawOutput, maxChars, maxBytes);
             rawOutput = outcome.text;
             const truncated = outcome.truncated;
             // 如果未被截断且命令带有 --json 或包含 api，尝试解析为 JSON
@@ -214,10 +377,24 @@ export class GhExecutor {
                     rawOutput = truncateOutput(outText.trim(), this.maxOutputChars, this.maxOutputBytes).text;
                 }
             }
+            // 权限不足时的处置指引。
+            //
+            // 为什么在 executor 层拼进 error，而不是让 97 个工具调用点各自 `throw new Error(res.error + hint)`：
+            // 全仓有 97 处 `throw new Error(res.error)`，逐一改必然遗漏；而模型只能看到 error
+            // 字符串，不拼进去等于永远看不到指引。在唯一的事实源处拼一次，所有调用点自动获益。
+            //
+            // permissionRemedy 字段仍然独立保留：程序化消费方（未来的 UI、诊断面板）
+            // 可以只取指引而不用从 error 里再解析一遍。
+            const remedy = permissionRemedy(friendlyError, args.join(' '));
+            const finalError = remedy ? `${friendlyError}\n\n${remedy}` : friendlyError;
             return {
                 ok: false,
-                error: friendlyError,
+                error: finalError,
                 rawOutput,
+                // 失败语义分类：上层（概览路由 / UI 重试器）据此决定是重试、回退快照
+                // 还是直接把「仓库关了 Issues」降级成空列表。分类只有这一处事实源。
+                errorKind: classifyGhError(friendlyError),
+                ...(remedy ? { permissionRemedy: remedy } : {}),
             };
         }
     }
@@ -335,18 +512,20 @@ export class GhExecutor {
      * 零网络：status 基于 remote-tracking ref（上次 fetch 的快照），毫秒级本地读取，
      * 符合 global-overview 端点「工作区探测不发网络」的性能红线。
      */
-    async getLocalGitStatus(cwd) {
+    async getLocalGitStatus(cwd, timeoutMs = 3_000) {
         try {
-            // 纯本地毫秒级；3s 超时兜底异常文件系统
+            // 默认 3s：概览面板只是"读不到就不渲染这一行"的兜底语义。
+            // 但安全闸门（ensureCleanWorkspace）必须显式传更长超时——大型仓库 / 网络盘上
+            // `git status` 冷启动超 3s 很常见，用 3s 会把"读不到"误判成"有风险"。
             const { stdout } = await execFileAsync('git', ['status', '-sb', '--porcelain'], {
                 cwd: cwd || undefined,
-                timeout: 3_000,
+                timeout: timeoutMs,
                 windowsHide: true,
             });
             return parseGitStatusOutput(String(stdout), 2000);
         }
         catch {
-            // 非 Git 目录 / git 未安装 / 超时：静默降级为 null（调用方不渲染该行）
+            // 非 Git 目录 / git 未安装 / 超时：静默降级为 null（调用方自行决定语义）
             return null;
         }
     }
@@ -396,7 +575,9 @@ export class GhExecutor {
         }
         try {
             // 1. 先用 porcelain status 获取该文件的状态码
-            let fileStatus = 'M';
+            // 默认值必须为空：旧实现默认 'M'，导致工作区干净的文件被报成「已修改」
+            // （UI 表现为"文件被改了，但 diff 是空的"）。状态只从 porcelain 结果推导。
+            let fileStatus = '';
             try {
                 const { stdout: statusOut } = await execFileAsync('git', ['status', '--porcelain', '--', cleanRel], {
                     cwd: targetCwd || undefined,
@@ -492,7 +673,7 @@ export class GhExecutor {
                 return {
                     ok: true,
                     filePath: cleanRel,
-                    status: fileStatus,
+                    status: fileStatus || 'M',
                     isBinary: true,
                     diff: 'Binary files differ',
                     additions: 0,
@@ -509,7 +690,8 @@ export class GhExecutor {
             return {
                 ok: true,
                 filePath: cleanRel,
-                status: fileStatus,
+                // porcelain 没给状态且没有 diff → 该文件其实是干净的，显式标 'clean' 而不是伪造成 'M'
+                status: fileStatus || (finalDiff ? 'M' : 'clean'),
                 diff: finalDiff || '没有检测到文本差异',
                 additions: diffStats.additions,
                 deletions: diffStats.deletions,
@@ -651,12 +833,141 @@ export class GhExecutor {
             return null;
         }
     }
+    /**
+     * 发版输入：最近 tag + 该 tag 以来的提交（供 `github_task(prepare_release)` 使用）。
+     *
+     * 为什么要在 executor 里开这个口子，而不是让工具自己拼 git 命令：
+     * 命令形态必须集中（本文件顶部就是"git 白名单"纪律），否则每个新工具都会
+     * 自己发明一套 argv，`phase34` 的契约网也就管不到它们了。
+     *
+     * 安全性：两条命令的形态**全部固定**——`describe --tags --abbrev=0` 无参数注入；
+     * log 的修订范围段只拼 `git describe` 自己的输出，且先过 `/^[A-Za-z0-9._\/-]+$/`
+     * 白名单校验，杜绝把任意字符串当 revision 传进 git。
+     */
+    async getReleaseInputs(cwd, fromTagOverride) {
+        const empty = {
+            ok: false,
+            fromTag: null,
+            commits: [],
+            totalCommits: 0,
+        };
+        const runOpts = { cwd: cwd || undefined, timeout: 5_000, windowsHide: true };
+        let fromTag = null;
+        /*
+         * 显式指定的起始 tag 优先，且**必须真的作为 range 起点**。
+         *
+         * 为什么强调：只拿它当「版本号基数」而不改 range，会出现「按 v1.0.0 算版本、
+         * 但统计的是 v1.2.0 以来的提交」——数字与标签对不上，比直接报错更坏。
+         */
+        const override = typeof fromTagOverride === 'string' ? fromTagOverride.trim() : '';
+        if (override) {
+            /*
+             * 两条校验缺一不可：
+             * - 字符白名单挡住 `;` `$()` 这类命令注入；
+             * - **禁止以 `-` 开头**：它会被拼进 `git log <tag>..HEAD` 的第一个位置，
+             *   git 会把 `-p..HEAD` 当成未知选项（实测报错）。虽然成不了真正的注入，
+             *   但「用户输入永远不许以 - 开头」是这条通道的基本纪律。
+             */
+            if (override.startsWith('-') || !/^[A-Za-z0-9._/-]+$/.test(override)) {
+                return { ...empty, error: `非法的 from_tag：${override}（只允许字母/数字/./_/-/，且不能以 - 开头）` };
+            }
+            fromTag = override;
+        }
+        else {
+            try {
+                const tagRes = await execFileAsync('git', ['describe', '--tags', '--abbrev=0'], runOpts);
+                const raw = String(tagRes.stdout || '').trim();
+                // 白名单：describe 的输出来自仓库自身，但仍要挡住 `..`、空白与 shell 元字符
+                if (raw && /^[A-Za-z0-9._/-]+$/.test(raw))
+                    fromTag = raw;
+            }
+            catch {
+                // 没有任何 tag 是正常状态（新仓库），不是错误
+                fromTag = null;
+            }
+        }
+        try {
+            const range = fromTag ? `${fromTag}..HEAD` : 'HEAD';
+            const logRes = await execFileAsync('git', 
+            // %b 带出提交正文：BREAKING CHANGE 常常只写在正文里，只看标题会漏判 major
+            ['log', range, '-n', '300', '--pretty=format:%x1e%h%x1f%s%x1f%an%x1f%ad%x1f%b'], runOpts);
+            const text = String(logRes.stdout || '');
+            const commits = text
+                .split('\x1e')
+                .map((chunk) => chunk.trim())
+                .filter(Boolean)
+                .map((chunk) => {
+                const parts = chunk.split('\x1f');
+                return {
+                    sha: String(parts[0] || ''),
+                    subject: String(parts[1] || ''),
+                    author: String(parts[2] || ''),
+                    date: String(parts[3] || ''),
+                    // 正文只取前 500 字符：够判 BREAKING CHANGE，又不至于把整包撑大
+                    body: String(parts.slice(4).join('\x1f') || '').slice(0, 500),
+                };
+            });
+            return { ok: true, fromTag, commits, totalCommits: commits.length };
+        }
+        catch (err) {
+            return { ...empty, fromTag, error: err?.message || '读取提交记录失败' };
+        }
+    }
+    /**
+     * 工作区干净度闸门（唯一实现）。
+     *
+     * 为什么抽成公共方法：会改变工作区分支/内容的入口有三条——界面切分支（switchGitBranch）、
+     * `github_pr(checkout)`、`github_issue(develop)`。此前只有第一条有脏检查，后两条直穿，
+     * 于是「强阻断」的成文承诺只对界面成立。安全不变量必须只有一处实现。
+     *
+     * 三态语义（fail-closed）：
+     * - `null`（git 读不到）→ 拒绝。读不到状态≠干净，放行等于闸门失效。
+     * - `dirtyCount > 0` → 拒绝，并带前 5 条样例便于用户判断。
+     * - 其余 → 放行。
+     *
+     * 超时为什么单独给 20s：`getLocalGitStatus` 默认 3s 是给概览面板用的（读不到就不渲染那一行），
+     * 但这里是一次安全判决——大型仓库 / 网络盘 / OneDrive 同步目录下 `git status` 冷启动超 3s
+     * 很常见，用 3s 会把"慢"误判成"脏/不可用"，直接把 checkout 挡死。
+     */
+    async ensureCleanWorkspace(cwd) {
+        const targetCwd = this.resolveWorkspaceCwd(cwd);
+        // 先区分"根本不是 Git 仓库"与"是仓库但读不到状态"——两者对用户的可操作性完全不同。
+        if (!hasGitDir(targetCwd)) {
+            return {
+                ok: false,
+                reason: 'unknown',
+                dirtyCount: 0,
+                samples: [],
+                error: `当前目录不是 Git 仓库（${targetCwd}），无法执行需要切换分支的操作。`,
+            };
+        }
+        const gitSt = await this.getLocalGitStatus(targetCwd, 20_000);
+        if (gitSt === null) {
+            return {
+                ok: false,
+                reason: 'unknown',
+                dirtyCount: 0,
+                samples: [],
+                error: '读取工作区 Git 状态失败（git 不可用、超时或权限不足）。为避免覆盖本地改动，已拒绝执行。',
+            };
+        }
+        if (gitSt.dirtyCount > 0) {
+            return {
+                ok: false,
+                reason: 'dirty',
+                dirtyCount: gitSt.dirtyCount,
+                samples: (gitSt.dirtyFiles || []).slice(0, 5).map((f) => `${f.status} ${f.path}`),
+                error: `工作区有 ${gitSt.dirtyCount} 个未提交的文件变更。为防止代码被覆盖，请先提交或保存后再执行。`,
+            };
+        }
+        return { ok: true, dirtyCount: 0, samples: [] };
+    }
     /**
      * 安全切换当前工作区的 Git 分支。
      * 三重安全防御纪律：
      * 1. 目标工作区必须存在有效的 .git 目录；
      * 2. 分支名称严格执行字符白名单校验，防命令行参数注入；
-     * 3. 检查工作区干净度（dirtyCount），若有未提交或未保存的变更直接阻断，杜绝代码被破坏性覆盖。
+     * 3. 工作区干净度交给 ensureCleanWorkspace（唯一实现，与 checkout / develop 共用）。
      */
     async switchGitBranch(cwd, branchName) {
         const targetCwd = this.resolveWorkspaceCwd(cwd);
@@ -669,12 +980,9 @@ export class GhExecutor {
             return { ok: false, error: '非法分支名称，仅允许字母、数字、短横线、下划线与斜杠组合' };
         }
         // 防线二：工作区未提交变更阻断（Dirty File Guard）
-        const gitSt = await this.getLocalGitStatus(targetCwd);
-        if (gitSt && gitSt.dirtyCount > 0) {
-            return {
-                ok: false,
-                error: `工作区有 ${gitSt.dirtyCount} 个未提交的文件变更。为防止代码被覆盖，请先提交或保存后再切换分支。`,
-            };
+        const guard = await this.ensureCleanWorkspace(targetCwd);
+        if (!guard.ok) {
+            return { ok: false, error: guard.error };
         }
         try {
             let args = ['checkout', cleanBranch];
@@ -699,6 +1007,731 @@ export class GhExecutor {
             return { ok: false, error: msg };
         }
     }
+    /**
+     * 推导当前工作区可供用户切换的全部关联 GitHub 仓库列表。
+     *
+     * 数据来源（纯本地+拓扑合成，零新增网络开销）：
+     * 1. 扫描本地 .git/config 的所有 GitHub remote（如 origin, upstream 等）；
+     * 2. 若当前仓库为 Fork 且存在 parent（上游），合并上游仓库（支持本地未配 upstream 的情形）；
+     * 3. 标识当前基准 (isCurrent) 及角色 (fork, upstream, origin, parent)。
+     */
+    getAssociatedRepos(cwd, currentRepo, currentUser) {
+        const items = [];
+        const seen = new Set();
+        const cfg = this.readParsedGitConfig(cwd);
+        if (cfg && Array.isArray(cfg.remotes)) {
+            for (const r of cfg.remotes) {
+                const gh = parseGithubUrl(r.url);
+                if (!gh)
+                    continue;
+                const full = `${gh.owner}/${gh.repo}`;
+                const fullKey = full.toLowerCase();
+                if (seen.has(fullKey))
+                    continue;
+                seen.add(fullKey);
+                const isCurrent = Boolean(currentRepo && currentRepo.nameWithOwner && currentRepo.nameWithOwner.toLowerCase() === fullKey);
+                let role = 'remote';
+                if (r.name === 'upstream') {
+                    role = 'upstream';
+                }
+                else if (currentUser && gh.owner.toLowerCase() === currentUser.toLowerCase()) {
+                    role = 'fork';
+                }
+                else if (r.name === 'origin') {
+                    role = 'origin';
+                }
+                items.push({
+                    nameWithOwner: full,
+                    remoteName: r.name,
+                    url: `https://github.com/${full}`,
+                    isCurrent,
+                    role,
+                });
+            }
+        }
+        // 若当前是在线识别出的 Fork 仓库且存在 parent，但本地尚未配置 upstream remote
+        if (currentRepo?.isFork && currentRepo.parent?.nameWithOwner) {
+            const parentFull = currentRepo.parent.nameWithOwner;
+            const parentKey = parentFull.toLowerCase();
+            if (!seen.has(parentKey)) {
+                seen.add(parentKey);
+                const isCurrent = Boolean(currentRepo.nameWithOwner && currentRepo.nameWithOwner.toLowerCase() === parentKey);
+                items.push({
+                    nameWithOwner: parentFull,
+                    url: currentRepo.parent.url || `https://github.com/${parentFull}`,
+                    isCurrent,
+                    role: 'parent',
+                });
+            }
+        }
+        return items;
+    }
+    /**
+     * 设置当前工作区的默认基准 GitHub 仓库（调用官方 `gh repo set-default` 并在本地 git config 持久化）。
+     *
+     * 为什么调用 gh repo set-default：
+     * 1. 它会在 .git/config 写入 `remote.<name>.gh-resolved = base`，这是官方的持久化事实源；
+     * 2. 执行后，不仅本插件的 Web 驾驶舱，外部系统终端中运行的 gh pr, gh issue, gh run 也将 100% 对齐；
+     * 3. 严格做参数格式校验，仅允许合法的 owner/repo 或合法 remote 别名，杜绝命令注入。
+     */
+    async setDefaultRepo(cwd, targetRepoOrRemote) {
+        const targetCwd = this.resolveWorkspaceCwd(cwd);
+        if (!hasGitDir(targetCwd)) {
+            return { ok: false, error: '当前工作区不是有效的 Git 仓库' };
+        }
+        const clean = (targetRepoOrRemote || '').trim();
+        // 安全白名单校验：只允许字母、数字、点号、短横线、下划线及至多一个斜杠（owner/repo 或 remoteName）
+        if (!clean || clean.startsWith('-') || clean.includes('..') || clean.includes('\\') || !/^[a-zA-Z0-9_.-]+(\/[a-zA-Z0-9_.-]+)?$/.test(clean)) {
+            return { ok: false, error: '非法目标仓库参数，仅允许 owner/repo 或有效 remote 别名' };
+        }
+        const r = await this.run(['repo', 'set-default', clean], {
+            cwd: targetCwd,
+            timeoutMs: 10_000,
+        });
+        if (!r.ok) {
+            return { ok: false, error: r.error || '设置默认基准仓库失败' };
+        }
+        return { ok: true, target: clean };
+    }
+    /**
+     * 获取 Pull Request 完整详情与变更 Diff 数据（用于 PR 在线审阅与代码比对）。
+     *
+     * 架构设计：
+     * 1. 严格参数白名单校验（PR 编号必须为正整数，repo 必须为合法 owner/repo 格式）；
+     * 2. 并行拉取元数据 (gh pr view) 与 Unified Diff (gh pr diff)；
+     * 3. 在内存通过 splitUnifiedDiff 对 Diff 原文按修改文件切片索引，
+     *    前端点击任一文件即可 0ms 呈现代码行级增删对比，绝无二次网络往返。
+     */
+    async getPrDetail(cwd, prNumber, repo) {
+        const targetCwd = this.resolveWorkspaceCwd(cwd);
+        const num = Number(prNumber);
+        if (!num || isNaN(num) || num <= 0) {
+            return { ok: false, error: '缺少有效 PR 编号（必须为正整数）' };
+        }
+        const cleanRepo = this.normalizeRepoFullName(repo);
+        if (cleanRepo === null) {
+            return { ok: false, error: '非法仓库全名参数（仅允许 owner/repo 格式）' };
+        }
+        const viewArgs = [
+            'pr',
+            'view',
+            String(num),
+            '--json',
+            // headRefOid/baseRefOid：分支会移动，SHA 才是可钉住的审查锚点（s7 §2.1）
+            // changedFiles：`--json files` 在 100 条处静默截断，只有这个数字能判定「清单被截了」
+            // headRepositoryOwner：`prDetail.headRepoOwner` 的取值来源（此前恒 undefined）
+            'number,title,state,isDraft,url,createdAt,updatedAt,author,baseRefName,headRefName,headRefOid,baseRefOid,changedFiles,headRepositoryOwner,body,reviewDecision,statusCheckRollup,comments,reviews,files,additions,deletions',
+        ];
+        if (cleanRepo)
+            viewArgs.push('-R', cleanRepo);
+        const diffArgs = ['pr', 'diff', String(num)];
+        if (cleanRepo)
+            diffArgs.push('-R', cleanRepo);
+        /**
+         * 行级审查评论的抓取通道。
+         *
+         * 为什么单独走 API：`gh pr view --json comments` 只返回对话区（issue-level），
+         * 挂在代码行上的 review comment 一条都拿不到。实测 cli/cli#14752 有 10 条
+         * 行级评论而 `--json comments` 为零。
+         */
+        const fetchLineComments = async (fullName) => {
+            if (!fullName)
+                return [];
+            const r = await this.run([`api`, `repos/${fullName}/pulls/${num}/comments?per_page=100`], { cwd: targetCwd, timeoutMs: 12_000 });
+            if (!r.ok || !Array.isArray(r.data))
+                return [];
+            return r.data
+                .filter((c) => c && typeof c.path === 'string')
+                .map((c) => ({
+                id: String(c.id ?? ''),
+                path: String(c.path),
+                line: typeof c.line === 'number' ? c.line : (typeof c.original_line === 'number' ? c.original_line : null),
+                side: c.side ? String(c.side) : undefined,
+                author: { login: String(c.user?.login || 'unknown') },
+                body: String(c.body || ''),
+                createdAt: String(c.created_at || ''),
+            }));
+        };
+        // 本地可推导出仓库全名时就三路并发（UI 通常已传入 repo），
+        // 推导不出则先用空结果占位，待 view 返回后从权威 url 补拉。
+        const repoGuess = cleanRepo || (this.getRepoIdentityFromLocal(targetCwd)?.nameWithOwner || '');
+        const [rView, rDiff, guessedLineComments] = await Promise.all([
+            this.run(viewArgs, { cwd: targetCwd, timeoutMs: 15_000 }),
+            // PR diff 走程序化消费通道（按文件切片，一次只渲染一个文件），
+            // 不进入模型上下文，因此显式放宽 24KB 默认阈值——实测普通 PR 的
+            // diff 已达 39KB，沿用默认会被静默截断，导致后半数文件点开皆空。
+            this.run(diffArgs, {
+                cwd: targetCwd,
+                timeoutMs: 25_000,
+                rawText: true,
+                maxOutputChars: 2_000_000,
+                maxOutputBytes: 8 * 1024 * 1024,
+            }),
+            // 第三路：行级审查评论。本地能推导仓库名时与上面两路并发，不增加串行等待。
+            repoGuess ? fetchLineComments(repoGuess) : Promise.resolve([]),
+        ]);
+        if (!rView.ok || !rView.data) {
+            return { ok: false, error: rView.error || `获取 PR #${num} 详情失败` };
+        }
+        const raw = rView.data;
+        // 本地推不出仓库名（无 repo 参数且非 Git 目录）时，用 view 返回的权威 URL
+        // 补拉一次行级评论。这是少见路径，多一次往返换来评论不丢，值得。
+        let lineComments = guessedLineComments;
+        if (!repoGuess) {
+            const m = /github\.com\/([^/]+)\/([^/]+)\/pull\//i.exec(String(raw.url || ''));
+            if (m)
+                lineComments = await fetchLineComments(`${m[1]}/${m[2]}`);
+        }
+        const fullDiff = rDiff.ok ? (typeof rDiff.data === 'string' ? rDiff.data : rDiff.rawOutput || '') : '';
+        const fileDiffs = splitUnifiedDiff(fullDiff);
+        const files = Array.isArray(raw.files)
+            ? raw.files.map((f) => ({
+                path: String(f.path || ''),
+                additions: Number(f.additions) || 0,
+                deletions: Number(f.deletions) || 0,
+                changeType: String(f.changeType || 'MODIFIED'),
+            }))
+            : [];
+        /*
+         * 三个截断字段各自回答一个不同问题，缺一不可（s7 §2.5）：
+         * - changedFiles   ：仓库里这个 PR 到底改了多少个文件（权威总数）
+         * - filesTruncated ：清单被 gh 的 100 条上限裁掉了吗（cli/cli#12522 静默截断）
+         * - diffIncomplete ：清单里有、但切片里没有对应 diff 的文件（数据缺失，不是「没改动」）
+         * 把三者混成一个布尔值，界面就只能说「可能不全」，用户无法判断该去做什么。
+         */
+        const changedFiles = Number(raw.changedFiles) || files.length;
+        const filesTruncated = files.length < changedFiles;
+        const diffIncomplete = files.some((f) => !fileDiffs[f.path]);
+        const prDetail = {
+            number: Number(raw.number) || num,
+            title: String(raw.title || ''),
+            state: (raw.state || 'OPEN').toUpperCase(),
+            isDraft: Boolean(raw.isDraft),
+            url: String(raw.url || ''),
+            createdAt: String(raw.createdAt || ''),
+            updatedAt: String(raw.updatedAt || ''),
+            author: {
+                login: String(raw.author?.login || 'ghost'),
+                avatarUrl: raw.author?.avatarUrl ? String(raw.author.avatarUrl) : undefined,
+            },
+            headRefName: String(raw.headRefName || ''),
+            baseRefName: String(raw.baseRefName || ''),
+            headRefOid: raw.headRefOid ? String(raw.headRefOid) : undefined,
+            baseRefOid: raw.baseRefOid ? String(raw.baseRefOid) : undefined,
+            headRepoOwner: raw.headRepositoryOwner?.login ? String(raw.headRepositoryOwner.login) : undefined,
+            body: String(raw.body || ''),
+            reviewDecision: raw.reviewDecision ? String(raw.reviewDecision) : undefined,
+            statusCheckRollup: raw.statusCheckRollup,
+            additions: Number(raw.additions) || 0,
+            deletions: Number(raw.deletions) || 0,
+            files,
+            changedFiles,
+            ...(filesTruncated ? { filesTruncated: true } : {}),
+            ...(diffIncomplete ? { diffIncomplete: true } : {}),
+            comments: Array.isArray(raw.comments)
+                ? raw.comments.map((c) => ({
+                    id: String(c.id || ''),
+                    author: {
+                        login: String(c.author?.login || 'unknown'),
+                        avatarUrl: c.author?.avatarUrl ? String(c.author.avatarUrl) : undefined,
+                    },
+                    authorAssociation: c.authorAssociation ? String(c.authorAssociation) : undefined,
+                    body: String(c.body || ''),
+                    createdAt: String(c.createdAt || ''),
+                    url: String(c.url || ''),
+                }))
+                : [],
+            reviews: Array.isArray(raw.reviews)
+                ? raw.reviews.map((rv) => ({
+                    id: String(rv.id || ''),
+                    author: { login: String(rv.author?.login || 'unknown') },
+                    state: String(rv.state || ''),
+                    body: String(rv.body || ''),
+                    submittedAt: String(rv.submittedAt || ''),
+                }))
+                : [],
+            fileDiffs,
+            lineComments,
+            ...(rDiff.truncated ? { diffTruncated: true } : {}),
+        };
+        return { ok: true, data: prDetail };
+    }
+    /**
+     * 提交带行级评注的 PR review（REST 通道）。
+     *
+     * 为什么必须走 REST：`gh pr review` 只有 `--approve/--request-changes/--comment`，
+     * 没有任何行级参数（`gh pr review --help` 里 line/side/path 零命中）。行级评注
+     * 的唯一入口是 `POST /repos/{owner}/{repo}/pulls/{n}/reviews` 的 `comments[]`。
+     *
+     * 为什么一次 review 一个请求（而不是逐条 `POST /pulls/{n}/comments`）：
+     * 通知只发一轮，也避开 secondary rate limit 的「创建内容过快」判定。
+     *
+     * 422 降级：行级评注被拒（典型原因：该行不在 diff 的可评论侧，如纯删除行）
+     * 时，把评注折叠进 review 正文重试一次。内容不能丢，但降级必须显式可见。
+     */
+    async createPrReview(cwd, repo, prNumber, input) {
+        const targetCwd = this.resolveWorkspaceCwd(cwd);
+        const num = Number(prNumber);
+        if (!num || isNaN(num) || num <= 0) {
+            return { ok: false, error: '缺少有效 PR 编号（必须为正整数）' };
+        }
+        // 仓库名优先用显式参数；缺省时从本地 git remote 推导（与 getPrDetail 同一套规则）
+        const cleanRepo = this.normalizeRepoFullName(repo);
+        if (cleanRepo === null) {
+            return { ok: false, error: '非法仓库全名参数（仅允许 owner/repo 格式）' };
+        }
+        const fullName = cleanRepo || this.getRepoIdentityFromLocal(targetCwd)?.nameWithOwner || '';
+        if (!/^[a-zA-Z0-9_.-]+\/[a-zA-Z0-9_.-]+$/.test(fullName)) {
+            return { ok: false, error: '无法确定仓库全名：请传 repo 参数，或在 Git 仓库目录下调用' };
+        }
+        const built = buildPrReviewPayload(input);
+        if (!built.ok || !built.payload) {
+            return { ok: false, error: `评注参数校验未通过：\n- ${(built.errors || ['未知错误']).join('\n- ')}` };
+        }
+        const payload = built.payload;
+        const endpoint = `repos/${fullName}/pulls/${num}/reviews`;
+        const post = (body) => this.run(['api', '--method', 'POST', endpoint, '--input', '-'], {
+            cwd: targetCwd,
+            timeoutMs: 20_000,
+            stdin: JSON.stringify(body),
+        });
+        const first = await post(payload);
+        if (first.ok) {
+            const data = first.data;
+            return {
+                ok: true,
+                data: {
+                    id: data?.id,
+                    htmlUrl: data?.html_url,
+                    state: data?.state,
+                    submittedAt: data?.submitted_at,
+                    // 逐条回传评论地址，供人复核「到底挂到了哪一行」
+                    comments: Array.isArray(data?.comments)
+                        ? data.comments.map((c) => ({
+                            path: String(c?.path || ''),
+                            line: typeof c?.line === 'number' ? c.line : undefined,
+                            htmlUrl: c?.html_url ? String(c.html_url) : undefined,
+                        }))
+                        : [],
+                },
+            };
+        }
+        // 只在「行级评注被拒」时降级；403/404/网络错误原样抛出（降级也没用）
+        const hasComments = Array.isArray(payload.comments) && payload.comments.length > 0;
+        if (hasComments && isLineCommentRejected(first.error || '')) {
+            const folded = foldCommentsIntoBody(payload.comments, payload.body);
+            const retry = await post({ ...payload, body: folded, comments: undefined });
+            // 把 GitHub 的原始拒绝原因带进说明里：否则用户只看到「已折叠进正文」，
+            // 却不知道是「行不在 diff 可评论侧」还是「path 根本不存在」——两者处置完全不同。
+            const why = String(first.error || '').replace(/\s+/g, ' ').trim().slice(0, 200);
+            if (retry.ok) {
+                const data = retry.data;
+                return {
+                    ok: true,
+                    degraded: true,
+                    degradedReason: `行级评注被 GitHub 拒绝（${why}），已折叠进 review 正文提交，内容未丢失。`,
+                    data: { id: data?.id, htmlUrl: data?.html_url, state: data?.state, submittedAt: data?.submitted_at, comments: [] },
+                };
+            }
+            return {
+                ok: false,
+                degraded: true,
+                degradedReason: `行级评注被拒（${why}）后降级重试仍失败。`,
+                error: retry.error || first.error,
+            };
+        }
+        return { ok: false, error: first.error };
+    }
+    /**
+     * 获取 Issue 完整详情（供 IssueDetailModal 在线查看消费）。
+     *
+     * 架构设计：
+     * 1. 严格参数白名单（编号必须为正整数，repo 必须为 owner/repo 形态）——与
+     *    getPrDetail 同一套规则，杜绝任何形式的命令/路径注入；
+     * 2. 单次 `gh issue view --json` 往返即可拿到正文、评论时间线、里程碑与关联 PR，
+     *    不拆成多路并发（Issue 没有 diff 这类重载荷，多开进程反而增加失败面）；
+     * 3. 老版本 gh 遇未知字段会整体失败，因此保留 BASE 字段集降级链。
+     */
+    async getIssueDetail(cwd, issueNumber, repo) {
+        const targetCwd = this.resolveWorkspaceCwd(cwd);
+        const num = Number(issueNumber);
+        if (!num || isNaN(num) || num <= 0 || !Number.isInteger(num)) {
+            return { ok: false, error: '缺少有效 Issue 编号（必须为正整数）' };
+        }
+        const cleanRepo = this.normalizeRepoFullName(repo);
+        if (cleanRepo === null) {
+            return { ok: false, error: '非法仓库全名参数（仅允许 owner/repo 格式）' };
+        }
+        const buildArgs = (fields) => {
+            const args = ['issue', 'view', String(num), '--json', fields];
+            if (cleanRepo)
+                args.push('-R', cleanRepo);
+            return args;
+        };
+        /**
+         * 输出阈值必须显式放宽。
+         *
+         * 为什么：executor 默认 maxOutputChars=24000，实测含 149 条评论的 Issue
+         * JSON 达 117KB；一旦被截断，run() 会跳过 JSON.parse，data 恒为 undefined，
+         * 于是弹窗只能显示「元数据全空 + 零评论」的假详情——比报错更糟。
+         * 放宽到 2M/8MB 与 getPrDetail 的 diff 通道同口径。
+         */
+        const execOpts = {
+            cwd: targetCwd,
+            timeoutMs: 20_000,
+            maxOutputChars: 2_000_000,
+            maxOutputBytes: 8 * 1024 * 1024,
+        };
+        let fieldsDegraded = false;
+        let r = await this.run(buildArgs(ISSUE_DETAIL_FULL_FIELDS), execOpts);
+        // 老版本 gh 会以 `Unknown JSON field: "closedAt"` 整体拒绝：
+        // 这不是网络问题，也不该让整个功能不可用——退回长期稳定字段集重试一次。
+        if (!r.ok && /Unknown JSON field/i.test(String(r.error || ''))) {
+            fieldsDegraded = true;
+            r = await this.run(buildArgs(ISSUE_DETAIL_BASE_FIELDS), execOpts);
+        }
+        if (!r.ok) {
+            return { ok: false, error: r.error || `获取 Issue #${num} 详情失败` };
+        }
+        // 截断 / 解析失败都必须显式失败：静默返回空评论会被误读成「没有讨论」。
+        if (r.truncated || !r.data || typeof r.data !== 'object') {
+            return {
+                ok: false,
+                error: `Issue #${num} 的讨论内容过长，已超出插件单次读取上限。请在浏览器中查看完整讨论（${cleanRepo ? `https://github.com/${cleanRepo}/issues/${num}` : '仓库 Issues 页面'}）。`,
+            };
+        }
+        const raw = r.data;
+        const comments = Array.isArray(raw.comments)
+            ? raw.comments.map((c) => ({
+                id: String(c.id || ''),
+                author: {
+                    login: String(c.author?.login || 'ghost'),
+                    avatarUrl: c.author?.avatarUrl ? String(c.author.avatarUrl) : undefined,
+                },
+                authorAssociation: c.authorAssociation ? String(c.authorAssociation) : undefined,
+                body: String(c.body || ''),
+                createdAt: String(c.createdAt || ''),
+                url: String(c.url || ''),
+                ...(c.isMinimized === true ? { isMinimized: true } : {}),
+                ...(c.minimizedReason ? { minimizedReason: String(c.minimizedReason) } : {}),
+                ...(c.includesCreatedEdit === true ? { includesCreatedEdit: true } : {}),
+            }))
+            : [];
+        const body = String(raw.body || '');
+        // 图片清单：正文 + 全部评论合并去重，与 github_issue(view_images) 同源
+        const imageSources = [body];
+        for (const c of comments)
+            imageSources.push(c.body);
+        const images = Array.from(new Set(imageSources.flatMap((b) => extractImageUrls(b))));
+        const linkedPrs = Array.isArray(raw.closedByPullRequestsReferences)
+            ? raw.closedByPullRequestsReferences
+                .filter((p) => p && Number(p.number) > 0)
+                .map((p) => {
+                const repoName = p.repository?.name && p.repository?.owner?.login
+                    ? `${p.repository.owner.login}/${p.repository.name}`
+                    : undefined;
+                return {
+                    number: Number(p.number),
+                    url: String(p.url || ''),
+                    ...(repoName ? { repository: repoName } : {}),
+                };
+            })
+            : [];
+        const detail = {
+            number: Number(raw.number) || num,
+            title: String(raw.title || ''),
+            state: String(raw.state || 'OPEN').toUpperCase() === 'CLOSED' ? 'CLOSED' : 'OPEN',
+            stateReason: raw.stateReason ? String(raw.stateReason) : undefined,
+            url: String(raw.url || ''),
+            createdAt: String(raw.createdAt || ''),
+            updatedAt: String(raw.updatedAt || ''),
+            closedAt: raw.closedAt ? String(raw.closedAt) : undefined,
+            author: {
+                login: String(raw.author?.login || 'ghost'),
+                avatarUrl: raw.author?.avatarUrl ? String(raw.author.avatarUrl) : undefined,
+            },
+            body,
+            labels: Array.isArray(raw.labels)
+                ? raw.labels.map((l) => ({
+                    name: String(l.name || ''),
+                    ...(l.color ? { color: String(l.color) } : {}),
+                    ...(l.description ? { description: String(l.description) } : {}),
+                }))
+                : [],
+            assignees: Array.isArray(raw.assignees)
+                ? raw.assignees
+                    .map((a) => ({ login: String(a.login || '') }))
+                    .filter((a) => a.login)
+                : [],
+            ...(raw.milestone && raw.milestone.title
+                ? {
+                    milestone: {
+                        ...(typeof raw.milestone.number === 'number' ? { number: raw.milestone.number } : {}),
+                        title: String(raw.milestone.title),
+                        ...(raw.milestone.dueOn ? { dueOn: String(raw.milestone.dueOn) } : {}),
+                    },
+                }
+                : {}),
+            ...(raw.isPinned === true ? { isPinned: true } : {}),
+            ...(raw.issueType?.name ? { issueType: String(raw.issueType.name) } : {}),
+            comments,
+            linkedPrs,
+            ...(raw.subIssuesSummary && typeof raw.subIssuesSummary.total === 'number'
+                ? {
+                    subIssues: {
+                        completed: Number(raw.subIssuesSummary.completed) || 0,
+                        total: Number(raw.subIssuesSummary.total) || 0,
+                    },
+                }
+                : {}),
+            images,
+            ...(fieldsDegraded ? { fieldsDegraded: true } : {}),
+        };
+        return { ok: true, data: detail };
+    }
+    /**
+     * 详情类接口的仓库参数归一化（PR / Issue / Run 共用）。
+     *
+     * 返回 `''` = 未传（由本地 remote 决定）；返回 `null` = 非法。
+     *
+     * 为什么要收编三处各自的校验：历史实现各写一份正则，只有 `setDefaultRepo` 额外
+     * 拒绝 `-` 开头与 `..`，其余靠「恒以 `-R <value>` 成对传入」兜底（复核报告 C-13）。
+     * 「成对传入所以安全」是当前调用形状的安全，不是接口的安全——多一处调用方就多
+     * 一次赌。统一到这里后，`-` 开头/`..`/反斜杠在任何详情入口都进不来。
+     */
+    normalizeRepoFullName(repo) {
+        const clean = typeof repo === 'string' ? repo.trim() : '';
+        if (!clean)
+            return '';
+        if (clean.startsWith('-') || clean.includes('..') || clean.includes('\\'))
+            return null;
+        if (!/^[a-zA-Z0-9_.-]+\/[a-zA-Z0-9_.-]+$/.test(clean))
+            return null;
+        return clean;
+    }
+    /**
+     * 获取单次 Actions Run 的完整详情（run + jobs + steps）。
+     *
+     * 架构设计：
+     * 1. **run_id 只认纯数字**。它会被当作 `gh run view` 的位置参数拼进 argv，
+     *    不做白名单就等于把「用参数值注入 flag」这条已知缺陷（复核报告 C-01）
+     *    复制到新通道——`--web`、`--log` 都能冒充编号。
+     * 2. 单次往返拿全：`jobs` 里已经包含 steps 树，没有需要并行拉取的第二路。
+     * 3. **日志不在这里拉**。实测单次失败日志 4–40 秒（本机代理下还直接连接重置），
+     *    挂在详情上等于让弹窗首屏去赌网络；日志走 getRunLogExcerpts() 按需拉。
+     */
+    async getRunDetail(cwd, runId, repo) {
+        const targetCwd = this.resolveWorkspaceCwd(cwd);
+        const id = String(runId ?? '').trim();
+        if (!/^\d+$/.test(id) || Number(id) <= 0) {
+            return { ok: false, error: '缺少有效 Run ID（必须为正整数）' };
+        }
+        const cleanRepo = this.normalizeRepoFullName(repo);
+        if (cleanRepo === null) {
+            return { ok: false, error: '非法仓库全名参数（仅允许 owner/repo 格式）' };
+        }
+        const buildArgs = (fields) => {
+            const args = ['run', 'view', id, '--json', fields];
+            if (cleanRepo)
+                args.push('-R', cleanRepo);
+            return args;
+        };
+        /**
+         * 输出阈值必须显式放宽。
+         *
+         * 为什么：矩阵构建的 jobs 数组动辄上百个 job、每个十几步，JSON 轻松过 100KB；
+         * 沿用默认 24KB 会跳过 JSON.parse，data 恒为 undefined，于是弹窗渲染出
+         * 「元数据全空 + 零 job」的假详情——比报错更糟（同 getIssueDetail 的教训）。
+         */
+        const execOpts = {
+            cwd: targetCwd,
+            timeoutMs: 20_000,
+            maxOutputChars: 2_000_000,
+            maxOutputBytes: 8 * 1024 * 1024,
+        };
+        let fieldsDegraded = false;
+        let r = await this.run(buildArgs(RUN_DETAIL_FULL_FIELDS), execOpts);
+        if (!r.ok && /Unknown JSON field/i.test(String(r.error || ''))) {
+            fieldsDegraded = true;
+            r = await this.run(buildArgs(RUN_DETAIL_BASE_FIELDS), execOpts);
+        }
+        if (!r.ok) {
+            return { ok: false, error: r.error || `获取 Run #${id} 详情失败` };
+        }
+        // 截断 / 解析失败必须显式失败：渲染空 jobs 会被读成「这次运行没有 job」
+        if (r.truncated || !r.data || typeof r.data !== 'object') {
+            const link = cleanRepo ? `https://github.com/${cleanRepo}/actions/runs/${id}` : '仓库的 Actions 页面';
+            return {
+                ok: false,
+                error: `Run #${id} 的 job 清单过长，已超出插件单次读取上限。请在浏览器中查看完整运行（${link}）。`,
+            };
+        }
+        const raw = r.data;
+        const jobs = Array.isArray(raw.jobs)
+            ? raw.jobs
+                .filter((j) => j && (j.databaseId || j.name))
+                .map((j) => {
+                const steps = Array.isArray(j.steps)
+                    ? j.steps
+                        .filter((s) => s && typeof s === 'object')
+                        .map((s) => ({
+                        number: Number(s.number) || 0,
+                        name: String(s.name || ''),
+                        status: String(s.status || ''),
+                        ...(s.conclusion ? { conclusion: String(s.conclusion) } : {}),
+                        ...(s.startedAt ? { startedAt: String(s.startedAt) } : {}),
+                        ...(s.completedAt ? { completedAt: String(s.completedAt) } : {}),
+                    }))
+                    : [];
+                return {
+                    databaseId: Number(j.databaseId) || 0,
+                    name: String(j.name || '未命名 job'),
+                    status: String(j.status || ''),
+                    ...(j.conclusion ? { conclusion: String(j.conclusion) } : {}),
+                    ...(j.startedAt ? { startedAt: String(j.startedAt) } : {}),
+                    ...(j.completedAt ? { completedAt: String(j.completedAt) } : {}),
+                    ...(j.url ? { url: String(j.url) } : {}),
+                    steps,
+                };
+            })
+            : [];
+        // 失败口径只算一次，UI 直接消费（避免前端再推导出第二套口径）
+        const failedJobs = jobs.filter((j) => j.conclusion === 'failure').length;
+        const failedSteps = jobs.reduce((sum, j) => sum + j.steps.filter((s) => s.conclusion === 'failure').length, 0);
+        const detail = {
+            runId: Number(raw.databaseId) || Number(id),
+            ...(typeof raw.attempt === 'number' && raw.attempt > 0 ? { attempt: raw.attempt } : {}),
+            name: String(raw.name || raw.workflowName || `Run ${id}`),
+            ...(raw.displayTitle ? { displayTitle: String(raw.displayTitle) } : {}),
+            status: String(raw.status || ''),
+            ...(raw.conclusion ? { conclusion: String(raw.conclusion) } : {}),
+            ...(raw.event ? { event: String(raw.event) } : {}),
+            ...(raw.headBranch ? { headBranch: String(raw.headBranch) } : {}),
+            ...(raw.headSha ? { headSha: String(raw.headSha) } : {}),
+            url: String(raw.url || ''),
+            createdAt: String(raw.createdAt || ''),
+            ...(raw.startedAt ? { startedAt: String(raw.startedAt) } : {}),
+            updatedAt: String(raw.updatedAt || ''),
+            ...(raw.workflowName ? { workflowName: String(raw.workflowName) } : {}),
+            jobs,
+            failedJobs,
+            failedSteps,
+            ...(fieldsDegraded ? { fieldsDegraded: true } : {}),
+        };
+        return { ok: true, data: detail };
+    }
+    /**
+     * 按需拉取失败日志并压成纯文本摘要（供 Run 详情弹窗消费）。
+     *
+     * 与 github_run(log_failed) 的关系：同一份 `--log-failed` 原始输出、同一套锚点
+     * 萃取与尾部回退，只是排版不同（弹窗要的是 `<pre>` 纯文本，不是 Markdown）。
+     *
+     * 为什么逐 job 拉而不是整 run 一次拉：`gh run view --log-failed` 会把**整次运行**
+     * 的日志包都下载下来再过滤，矩阵构建下等于为了一个失败 job 拖几十 MB；`-j <jobId>`
+     * 是 gh 支持的定向形态（见 `gh run view --help`），失败 job 通常只有 1–3 个。
+     *
+     * 为什么单个 job 失败仍返回 ok:true：部分成功比整体失败有用——已拿到的块照常展示，
+     * 失败的那个进 errors[] 并在界面上显式可重试。只有参数非法才是 ok:false。
+     */
+    async getRunLogExcerpts(cwd, runId, jobIds, repo, 
+    /**
+     * 本批日志的总预算（毫秒，默认 `RUN_LOG_TOTAL_BUDGET_MS`）。
+     *
+     * 为什么需要：单 job 超时 60s × 最多 3 个串行 = 最坏 180s。这个调用挂在 HTTP
+     * 路由上，而宿主 WebServer 是全 GUI 共享的——一次点击占住三分钟不可接受。
+     * 超预算的 job 进 `errors[]`（显式、可单独重试），而不是让连接一直挂着。
+     * 允许外部传入只为可测：传 0 能验证「超预算」分支而不必真的等待。
+     */
+    opts = {}) {
+        const targetCwd = this.resolveWorkspaceCwd(cwd);
+        const id = String(runId ?? '').trim();
+        if (!/^\d+$/.test(id) || Number(id) <= 0) {
+            return { ok: false, error: '缺少有效 Run ID（必须为正整数）' };
+        }
+        const cleanRepo = this.normalizeRepoFullName(repo);
+        if (cleanRepo === null) {
+            return { ok: false, error: '非法仓库全名参数（仅允许 owner/repo 格式）' };
+        }
+        const wanted = Array.from(new Set((Array.isArray(jobIds) ? jobIds : [])
+            .map((v) => String(v ?? '').trim())
+            .filter((v) => /^\d+$/.test(v) && Number(v) > 0)));
+        if (wanted.length === 0) {
+            return { ok: false, error: '缺少有效 job_id（必须为正整数，最多 3 个）' };
+        }
+        // 超上限必须显式拒绝：静默 slice 会让调用方以为 5 个 job 的日志都拉了，
+        // 与仓库自己立的「截断必须可见」纪律（filesTruncated / totalUnknown）相悖。
+        if (wanted.length > RUN_LOG_MAX_JOBS) {
+            return {
+                ok: false,
+                error: `一次最多拉取 ${RUN_LOG_MAX_JOBS} 个 job 的失败日志（本次请求 ${wanted.length} 个）。请分批重试，或直接在 GitHub 查看完整日志。`,
+            };
+        }
+        // 名字从详情树里取（job id → 名称）。取不到不影响拉日志，但**必须显式标注**：
+        // 名字退化成 `job #111` 是可见的降级，不能让它悄悄发生（本仓的降级纪律）。
+        const detail = await this.getRunDetail(targetCwd, id, cleanRepo || undefined).catch(() => null);
+        const nameById = new Map();
+        for (const job of detail && detail.ok && detail.data ? detail.data.jobs : []) {
+            if (job.databaseId > 0)
+                nameById.set(job.databaseId, job.name);
+        }
+        const namesUnavailable = wanted.some((jobId) => !nameById.has(Number(jobId)));
+        const jobs = [];
+        const errors = [];
+        // 总预算：3 个 job 各 60s 串行会把一条 HTTP 请求拖到 180s（见方法注释）
+        const budget = Number.isFinite(opts.totalBudgetMs)
+            ? Math.max(0, Math.floor(opts.totalBudgetMs))
+            : RUN_LOG_TOTAL_BUDGET_MS;
+        const deadline = Date.now() + budget;
+        // 串行而非并发：每次都是一次整包下载，并发只会同时挤爆代理与 gh 缓存目录
+        for (const jobId of wanted) {
+            const jobName = nameById.get(Number(jobId)) || `job #${jobId}`;
+            // 定向日志通道：`-j <jobId> --log-failed` 只下这个 job 的失败步骤日志
+            const logArgs = ['run', 'view', id, '-j', jobId, '--log-failed'];
+            if (cleanRepo)
+                logArgs.push('-R', cleanRepo);
+            // 预算在**每次**调用前重算：前一个 job 慢，后面的就该直接判超预算而不是再赌一次
+            const remaining = deadline - Date.now();
+            if (remaining <= 0) {
+                errors.push({
+                    jobName,
+                    error: `超出本批日志总预算（${Math.round(budget / 1000)}s），该 job 未拉取。请单独重试。`,
+                });
+                continue;
+            }
+            const res = await this.run(logArgs, {
+                cwd: targetCwd,
+                // 单个 job 最多 60s，但绝不越过本批总预算
+                timeoutMs: Math.min(60_000, remaining),
+                rawText: true,
+                maxOutputChars: 2_000_000,
+                maxOutputBytes: 8 * 1024 * 1024,
+            });
+            if (!res.ok) {
+                const friendly = interpretRunLogError(String(res.error || ''), id);
+                if (friendly) {
+                    // 确定性结论（该 job 没有失败步骤 / 缓存目录无权限）不是故障，进正文而非 errors
+                    jobs.push({ jobId: Number(jobId), jobName, excerpt: friendly, truncated: false });
+                }
+                else {
+                    errors.push({ jobName, error: String(res.error || '日志拉取失败').trim().slice(0, 400) });
+                }
+                continue;
+            }
+            const built = buildPlainFailureExcerpt(res.rawOutput || '', {
+                budget: RUN_LOG_BUDGET_CHARS,
+                truncated: Boolean(res.truncated),
+            });
+            jobs.push({ jobId: Number(jobId), jobName, excerpt: built.text, truncated: built.truncated });
+        }
+        const data = {
+            runId: Number(id),
+            jobs,
+            ...(errors.length > 0 ? { errors } : {}),
+            ...(namesUnavailable ? { namesUnavailable: true } : {}),
+            fetchedAt: new Date().toISOString(),
+        };
+        return { ok: true, data };
+    }
     /** 生成当前操作系统平台的推荐安装引导与命令 */
     getPlatformInstallGuide() {
         return getPlatformInstallGuide();
@@ -828,41 +1861,208 @@ export class GhExecutor {
         };
     }
     /**
-     * 仅从本地 .git/config 解析仓库身份，绝不发起网络请求。
+     * 从 `refs/remotes/<remote>/HEAD` 符号引用中读取仓库默认分支。
      *
-     * 为什么需要它：全局驾驶舱要为每个工作区认识别仓库，而 getRepoMetadata 会调用
-     * `gh repo view` 走网络。实测 5 个工作区时该端点冷启动 20.5 秒，其中绝大部分耗在这 5 次
-     * 网络往返上——而有界并发根本救不了它，因为瓶颈是网络延迟而不是进程排队。
-     * 工作区矩阵只需要「这个目录属于哪个仓库」这一身份信息，本地 .git/config 已经完整具备，
-     * 描述/star 数等富字段是当前仓库详情才需要的。这一步把每个工作区从 1 次网络往返降为 0。
+     * 为什么只认这一个来源（其余全部实测排除）：
+     *   - `packed-refs` 只存具体 sha，不含 symbolic ref —— 读不到；
+     *   - 当前 HEAD 指向的是**用户 checkout 的分支**，不是仓库默认分支，语义错误；
+     *   - 猜 main/master —— 无依据，宁可回落固定值也不猜。
+     *
+     * @returns 分支名；文件不存在（未 fetch 过）或内容不是符号引用时返回 null，
+     *          由调用方回落到既有默认值（保持原有行为，不引入新错误）
      */
-    getRepoIdentityFromLocal(cwd) {
+    readDefaultBranchFromRef(remoteName, cwd) {
+        try {
+            const info = this.resolveGitDirInfo(cwd);
+            if (!info)
+                return null;
+            // refs 存放在共享目录（worktree 与主仓库共用），已实测
+            const headRefPath = path.join(info.commonDir, 'refs', 'remotes', remoteName, 'HEAD');
+            if (!fs.existsSync(headRefPath))
+                return null;
+            const raw = fs.readFileSync(headRefPath, 'utf8');
+            // 内容形如 `ref: refs/remotes/origin/main`
+            const m = /^\s*ref:\s*refs\/remotes\/[^/]+\/(.+?)\s*$/m.exec(raw);
+            return m ? m[1] : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * 解析工作区真实的 git 目录的**两个**路径：局部目录与共享仓库目录。
+     *
+     * 为什么必须分开：worktree 的 `HEAD` 在局部目录（`.git/worktrees/<name>/HEAD`），
+     * 而 `config` 在共享目录（`commondir` 指向处）。只解析其中一个必然读错：
+     *   - 只读局部 → 找不到 config（remote 配置在共享目录）
+     *   - 只读共享 → 拿到**主工作树**的分支名，进而按错误分支查 `branch.*.remote`
+     *
+     * 实测：主工作树 HEAD 是 `ref: refs/heads/master`，worktree 的是 `ref: refs/heads/feat`。
+     *
+     * 常规仓库两者指向同一目录。
+     *
+     * @returns 两个绝对路径；非 Git 目录/指针不可解析时返回 null（绝不抛错）
+     */
+    resolveGitDirInfo(cwd) {
         const targetCwd = cwd || this.resolveWorkspaceCwd();
         try {
-            const gitConfigPath = path.join(targetCwd, '.git', 'config');
-            if (!fs.existsSync(gitConfigPath))
+            const dotGit = path.join(targetCwd, '.git');
+            if (!fs.existsSync(dotGit))
                 return null;
-            const configText = fs.readFileSync(gitConfigPath, 'utf8');
-            const match = configText.match(/github\.com[:/]([a-zA-Z0-9_.-]+)\/([a-zA-Z0-9_.-]+?)(?:\.git)?(?:\s|\r|\n|$)/i);
-            if (!match)
+            const st = fs.statSync(dotGit);
+            if (st.isDirectory())
+                return { localDir: dotGit, commonDir: dotGit };
+            if (!st.isFile())
                 return null;
-            const owner = match[1];
-            const repoName = match[2];
-            const nameWithOwner = `${owner}/${repoName}`;
-            return {
-                nameWithOwner,
-                name: repoName,
-                owner,
-                defaultBranch: 'main',
-                description: '',
-                isPrivate: false,
-                url: `https://github.com/${nameWithOwner}`,
-            };
+            // worktree/submodule：.git 是文本文件，内容形如 `gitdir: C:/repo/.git/worktrees/wt`
+            const pointer = fs.readFileSync(dotGit, 'utf8');
+            const m = /^\s*gitdir:\s*(.+?)\s*$/m.exec(pointer);
+            if (!m)
+                return null;
+            const gitDirRaw = m[1].replace(/[\\/]+$/, '');
+            const localDir = path.isAbsolute(gitDirRaw) ? path.normalize(gitDirRaw) : path.resolve(targetCwd, gitDirRaw);
+            if (!fs.existsSync(localDir))
+                return null;
+            // worktree：<localDir>/commondir 记录共享仓库目录（相对 localDir）
+            const commonDirFile = path.join(localDir, 'commondir');
+            if (fs.existsSync(commonDirFile)) {
+                try {
+                    const rel = fs.readFileSync(commonDirFile, 'utf8').trim();
+                    if (rel) {
+                        const common = path.resolve(localDir, rel);
+                        if (fs.existsSync(path.join(common, 'config')))
+                            return { localDir, commonDir: common };
+                    }
+                }
+                catch {
+                    // commondir 读失败 → 退回 localDir（至少还能读到局部配置）
+                }
+            }
+            return { localDir, commonDir: localDir };
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * 解析工作区真实的 git 目录（共享仓库目录）。
+     * 薄封装自 resolveGitDirInfo：读 `config` 的场景（远程指纹）只需要共享目录。
+     */
+    resolveGitDirPath(cwd) {
+        return this.resolveGitDirInfo(cwd)?.commonDir ?? null;
+    }
+    /**
+     * remote 配置指纹：全部 remote url 去重、排序、拼接后取 SHA-256 前 12 位。
+     *
+     * 为什么不用身份解析做缓存失效判定：身份解析要回答「变成了什么」，
+     * 一旦解析器对某种 config 布局有偏差（如双 remote 时取错 remote 段），
+     * 比对就永远失配——缓存再也不命中，每次请求都重拉全部 gh 子进程。
+     * 指纹只回答「变了没有」，不依赖任何语义理解，因此对该类偏差免疫。
+     *
+     * 反例（实测）：`git remote rename origin upstream` 后 `git remote add origin <fork>`，
+     * config 里 upstream 段排在 origin 段前，取「第一个 github.com 匹配」会拿到上游，
+     * 而 git 权威解析（branch.<name>.remote → origin）拿到的是 fork。
+     *
+     * @returns 12 位十六进制指纹；仅当「非 Git 目录 / config 不可读」时返回 null
+     *          （调用方据此保守判定为「未变更」，绝不因探测失败误清空缓存）。
+     *          注意：**config 可读但没有任何 remote 时返回的是空集合的哈希，不是 null**——
+     *          「仓库没有远程」是一个确定事实，它与「读不到配置」必须区分开：
+     *          否则用户删光 remote 后指纹恒为 null，旧快照再也无法失效。
+     */
+    getRemoteFingerprint(cwd) {
+        try {
+            const gitDir = this.resolveGitDirPath(cwd);
+            if (!gitDir)
+                return null;
+            const configPath = path.join(gitDir, 'config');
+            if (!fs.existsSync(configPath))
+                return null;
+            const urls = parseRemoteUrls(fs.readFileSync(configPath, 'utf8'));
+            // 排序后拼接：remote 数量、书写顺序、命名方式都不影响指纹——
+            // 只有「url 集合本身」变化才会改变指纹，这正是「配置变没变」的定义。
+            // 空集合同样参与哈希（得到空串的 SHA-256 前缀），语义是「已读、无 remote」，
+            // 与读取失败的 null 是两回事。
+            const normalized = [...urls].sort().join('\n');
+            return crypto.createHash('sha256').update(normalized, 'utf8').digest('hex').slice(0, 12);
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * 读取并解析工作区的 git 远程视图（`.git/config` + `HEAD`）。
+     * 内部方法：把「两个路径各读哪个文件」的细节收敛在一处，
+     * 避免各调用点自己拼路径读错 worktree 的文件。
+     */
+    readParsedGitConfig(cwd) {
+        const info = this.resolveGitDirInfo(cwd);
+        if (!info)
+            return null;
+        try {
+            const configPath = path.join(info.commonDir, 'config');
+            if (!fs.existsSync(configPath))
+                return null;
+            const configText = fs.readFileSync(configPath, 'utf8');
+            // HEAD 必须从 localDir 读：worktree 下 commonDir/HEAD 是主工作树的分支名
+            const headPath = path.join(info.localDir, 'HEAD');
+            const headText = fs.existsSync(headPath) ? fs.readFileSync(headPath, 'utf8') : null;
+            return parseGitConfig(configText, headText);
         }
         catch {
             return null;
         }
     }
+    /**
+     * 仅从本地 `.git/config` 解析仓库身份，绝不发起网络请求。
+     *
+     * 为什么需要它：全局驾驶舱要为每个工作区认识别仓库，而 getRepoMetadata 会调用
+     * `gh repo view` 走网络。实测 5 个工作区时该端点冷启动 20.5 秒，其中绝大部分耗在这 5 次
+     * 网络往返上——而有界并发根本救不了它，因为瓶颈是网络延迟而不是进程排队。
+     * 工作区矩阵只需要「这个目录属于哪个仓库」这一身份信息，本地 .git/config 已经完整具备，
+     * 描述/star 数等富字段是当前仓库详情才需要的。这一步把每个工作区从 1 次网络往返降为 0。
+     *
+     * 解析口径与 git 一致（三级回落），不再「取 config 里第一个 github.com 匹配」——
+     * 后者在 `git remote rename origin upstream` + `add origin <fork>` 的布局下会取到上游，
+     * 而 git 认的是 origin（实测）。
+     */
+    getRepoIdentityFromLocal(cwd) {
+        const cfg = this.readParsedGitConfig(cwd);
+        if (!cfg)
+            return null;
+        const layout = classifyRepoLayout(cfg);
+        /**
+         * 按布局分类选目标 remote —— 与 `.git/config` 书写顺序无关。
+         *
+         * github-only  ：完全按 git 规则（branch.<当前分支>.remote → origin → 首个）
+         * github-mixed ：git 选中的不是 GitHub → 在 GitHub remote 中按
+         *                origin 优先 → 名字字典序（pickGithubRemote）
+         * 其余          ：无 GitHub remote，返回 null，不猜测
+         */
+        let target = null;
+        if (layout === 'github-only') {
+            target = resolveRemoteTarget(cfg);
+        }
+        else if (layout === 'github-mixed') {
+            target = pickGithubRemote(cfg);
+        }
+        if (!target)
+            return null;
+        const gh = parseGithubUrl(target.url);
+        if (!gh)
+            return null;
+        const nameWithOwner = `${gh.owner}/${gh.repo}`;
+        return {
+            nameWithOwner,
+            name: gh.repo,
+            owner: gh.owner,
+            // 默认分支：从该 remote 的 HEAD 符号引用推断，读不到才回落 'main'
+            defaultBranch: this.readDefaultBranchFromRef(target.name, cwd) || 'main',
+            description: '',
+            isPrivate: false,
+            url: `https://github.com/${nameWithOwner}`,
+            layout,
+        };
+    }
     /**
      * 获取当前目录（工作区）关联的远程仓库元数据
      * 采用 gh repo view + 本地 git remote 双保险机制，彻底杜绝已配置远程却误判未关联的问题
@@ -875,61 +2075,32 @@ export class GhExecutor {
             return null;
         }
         // 1. 优先尝试由 gh 直接根据当前上下文识别
-        const res = await this.run(['repo', 'view', '--json', 'nameWithOwner,name,owner,defaultBranchRef,description,isPrivate,url,stargazerCount,forkCount'], { cwd: targetCwd, timeoutMs: 10_000 });
+        const res = await this.run(['repo', 'view', '--json', REPO_VIEW_FIELDS], { cwd: targetCwd, timeoutMs: 10_000 });
         if (res.ok && res.data && res.data.nameWithOwner) {
-            const d = res.data;
-            return {
-                nameWithOwner: d.nameWithOwner || '',
-                name: d.name || '',
-                owner: d.owner?.login || '',
-                defaultBranch: d.defaultBranchRef?.name || 'main',
-                description: d.description || '',
-                isPrivate: Boolean(d.isPrivate),
-                url: d.url || `https://github.com/${d.nameWithOwner}`,
-                stargazerCount: typeof d.stargazerCount === 'number' ? d.stargazerCount : 0,
-                forkCount: typeof d.forkCount === 'number' ? d.forkCount : 0,
-            };
+            return mapRepoMetadata(res.data);
         }
-        // 2. 原生文件解析：直接读取本地 .git/config 文件（0 子进程开销、免疫沙箱 EPERM）
-        try {
-            const gitConfigPath = path.join(targetCwd, '.git', 'config');
-            if (fs.existsSync(gitConfigPath)) {
-                const configText = fs.readFileSync(gitConfigPath, 'utf8');
-                const match = configText.match(/github\.com[:/]([a-zA-Z0-9_.-]+)\/([a-zA-Z0-9_.-]+?)(?:\.git)?(?:\s|\r|\n|$)/i);
-                if (match) {
-                    const owner = match[1];
-                    const repoName = match[2];
-                    const nameWithOwner = `${owner}/${repoName}`;
-                    // 使用精确的 owner/repo 向 gh 获取元数据（显式传参，不依赖无上下文的探测）
-                    const directRes = await this.run(['repo', 'view', nameWithOwner, '--json', 'nameWithOwner,name,owner,defaultBranchRef,description,isPrivate,url,stargazerCount,forkCount'], { cwd: targetCwd, timeoutMs: 10_000 });
-                    if (directRes.ok && directRes.data && directRes.data.nameWithOwner) {
-                        const d = directRes.data;
-                        return {
-                            nameWithOwner: d.nameWithOwner || nameWithOwner,
-                            name: d.name || repoName,
-                            owner: d.owner?.login || owner,
-                            defaultBranch: d.defaultBranchRef?.name || 'main',
-                            description: d.description || '',
-                            isPrivate: Boolean(d.isPrivate),
-                            url: d.url || `https://github.com/${nameWithOwner}`,
-                            stargazerCount: typeof d.stargazerCount === 'number' ? d.stargazerCount : 0,
-                            forkCount: typeof d.forkCount === 'number' ? d.forkCount : 0,
-                        };
-                    }
-                    // 若离线或网络受限，由本地 git remote 配置兜底返回
-                    return {
-                        nameWithOwner,
-                        name: repoName,
-                        owner,
-                        defaultBranch: 'main',
-                        description: '已成功关联本地 Git 远程仓库',
-                        isPrivate: false,
-                        url: `https://github.com/${nameWithOwner}`,
-                    };
-                }
+        // 2. 原生文件解析：走与 getRepoIdentityFromLocal 完全相同的解析器
+        //    （0 子进程开销、免疫沙箱 EPERM）。
+        //    为什么不再自己写一份正则：两处各维护一份必然漂移，且旧正则
+        //    「取第一个 github.com 匹配」在多 remote 布局下会取到上游仓库。
+        const local = this.getRepoIdentityFromLocal(targetCwd);
+        if (local) {
+            const { nameWithOwner } = local;
+            // 使用精确的 owner/repo 向 gh 获取元数据（显式传参，不依赖无上下文的探测）
+            const directRes = await this.run(['repo', 'view', nameWithOwner, '--json', REPO_VIEW_FIELDS], {
+                cwd: targetCwd,
+                timeoutMs: 10_000,
+            });
+            if (directRes.ok && directRes.data && directRes.data.nameWithOwner) {
+                return mapRepoMetadata(directRes.data, nameWithOwner);
             }
+            // 若离线或网络受限，由本地 git remote 配置兜底返回。
+            // 注意：此处不带 isFork / parent / viewerPermission —— 离线无从得知，绝不猜测。
+            return {
+                ...local,
+                description: '已成功关联本地 Git 远程仓库',
+            };
         }
-        catch { }
         return null;
     }
 }