@dependfix/engine 0.1.3 → 0.3.0

package/dist/index.mjs

@@ -1,12 +1,14 @@
 import { Octokit } from "@octokit/rest";
 import { RequestError } from "@octokit/request-error";
 import { AppError, collectCodeScanningSuggestions, createEmptyRunSummary, createLogger, filterAlerts, generateJsonReport, generateMarkdownReport, isAlertFixedByActions, isValidRepoIdentifier, limitAlerts, mapCodeScanningSeverity, normalizeAuditSeverity, prioritizeAlerts, toErrorMessage, writeReport } from "@dependfix/core";
-import { execFileSync, execSync, spawn } from "node:child_process";
-import { createHash } from "node:crypto";
 import { copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { execFileSync, execSync, spawn, spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
 import { basename, dirname, join, relative, resolve, sep } from "node:path";
 import YAML, { parse } from "yaml";
 import PQueue from "p-queue";
+import { createServer, request } from "node:http";
+import { connect } from "node:net";
 import { z } from "zod";
 import { createInterface } from "node:readline";
 
@@ -119,10 +121,316 @@ function sleep(ms) {
 	return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+//#endregion
+//#region src/github/errors.ts
+/**
+* 将 Octokit 请求错误映射为 `AppError`。
+*
+* @param error   - 原始错误（`RequestError` 或网络异常）
+* @param context - 调用上下文描述（如 `'fetch repo info for foo/bar'`），会附加到错误消息中
+*/
+function mapGitHubError(error, context) {
+	if (error instanceof RequestError) {
+		const code = resolveErrorCode(error);
+		const details = collectErrorDetails(error);
+		return new AppError(code, `${context}: ${error.message}`, {
+			cause: error,
+			details
+		});
+	}
+	if (error instanceof Error) return new AppError("NETWORK_ERROR", `${context}: ${error.message}`, { cause: error });
+	return new AppError("NETWORK_ERROR", `${context}: unknown error`, { details: { raw: toErrorMessage(error) } });
+}
+function resolveErrorCode(error) {
+	switch (error.status) {
+		case 401: return "AUTHENTICATION_FAILED";
+		case 403: {
+			const remaining = error.response?.headers["x-ratelimit-remaining"];
+			if (remaining !== void 0 && remaining === "0") return "RATE_LIMITED";
+			return "PERMISSION_DENIED";
+		}
+		case 404: return "REPO_NOT_FOUND";
+		default: return "GITHUB_API_ERROR";
+	}
+}
+function collectErrorDetails(error) {
+	const details = {
+		status: error.status,
+		requestUrl: error.request?.url,
+		requestMethod: error.request?.method
+	};
+	const resetAt = error.response?.headers["x-ratelimit-reset"];
+	if (resetAt) details.rateLimitReset = resetAt;
+	return details;
+}
+
+//#endregion
+//#region src/github/code-quality-fetcher.ts
+/** cursor 分页最大页数保护（恶意 Link header 重复同 cursor 或 API 异常时终止循环） */
+const MAX_CURSOR_PAGES = 1e3;
+/**
+* 拉取指定仓库的 Code Quality findings 并映射为标准化模型。
+*
+* - 自动分页（cursor-based：before/after 走 `Link` header，与 GitHub 通用分页一致）
+* - 仅处理 `state=open` 的 finding（可通过 `params.state` 覆盖）
+* - severity：`rule.severity`（error/warning/note）经 `mapCodeQualitySeverity` 映射
+* - Code Quality findings **不可自动修复**（`fixable: false`、`fixStrategy: null`），
+*   首版统一归 C 类（`alertClass: 'report-only'`），不实现模板化修复
+* - 异常通过 `mapGitHubError` 转为 `AppError`
+* - 空仓库返回 `[]`，不抛异常
+*
+* @param client - 已认证的 Octokit 实例（来自 `createGitHubClient`）
+* @param params - 仓库标识与过滤参数
+* @returns 标准化告警列表
+*/
+async function fetchCodeQualityFindings(client, params) {
+	const { owner, repo, state = "open", perPage = 100 } = params;
+	try {
+		const findings = [];
+		let cursor;
+		let pages = 0;
+		const seenCursors = /* @__PURE__ */ new Set();
+		for (;;) {
+			pages += 1;
+			if (pages > MAX_CURSOR_PAGES) break;
+			if (cursor && seenCursors.has(cursor)) break;
+			if (cursor) seenCursors.add(cursor);
+			const response = await client.request("GET /repos/{owner}/{repo}/code-quality/findings", {
+				owner,
+				repo,
+				state,
+				per_page: perPage,
+				...cursor ? { after: cursor } : {}
+			});
+			findings.push(...response.data);
+			cursor = parseNextCursor(response.headers.link);
+			if (!cursor) break;
+		}
+		return findings.map((f) => normalizeFinding(f, owner, repo));
+	} catch (error) {
+		const context = `fetch code quality findings for ${owner}/${repo}`;
+		throw mapGitHubError(error, context);
+	}
+}
+/**
+* 将单条 Code Quality finding 转换为标准化模型。
+*
+* 映射逻辑：
+* - severity：`rule.severity`（error/warning/note）经 `mapCodeQualitySeverity` 映射；
+*   缺失 → `'unknown'`（不静默丢弃）
+* - packageName 取规则人类可读名（`rule.title`，如 "Useless null check"），
+*   报告 Package 列对 code-quality 展示规则名
+* - ruleId 取 `rule.id`（如 `java/useless-null-check`），报告 Rule/Advisory 列展示
+* - manifestPath 取告警文件路径（`location.path`）
+* - htmlUrl：将 API URL（`https://api.github.com/...`）转换为 web URL
+*   （`https://github.com/owner/repo/code-quality/findings/N`）
+* - fixable 恒为 `false`（Code Quality findings 不可自动修复）
+* - alertClass 恒为 `'report-only'`（C 类默认，未列入 A/B）
+*/
+function normalizeFinding(finding, owner, repo) {
+	const ruleId = finding.rule?.id ?? "";
+	const severity = mapCodeQualitySeverity(finding.rule?.severity);
+	const description = finding.rule?.description ?? "";
+	return {
+		id: finding.number,
+		source: "code-quality",
+		repository: `${owner}/${repo}`,
+		defaultBranch: "",
+		severity,
+		packageEcosystem: "code-quality",
+		packageName: finding.rule?.title ?? (ruleId || "unknown"),
+		manifestPath: finding.location?.path ?? "",
+		ruleId,
+		summary: finding.message?.text ?? description,
+		htmlUrl: toWebUrl(finding.url, owner, repo, finding.number),
+		fixable: false,
+		fixStrategy: null,
+		recommendedVersion: "",
+		alertClass: "report-only",
+		startLine: finding.location?.start_line ?? void 0,
+		endLine: finding.location?.end_line ?? void 0,
+		suggestion: description || "人工审查该 Code Quality finding"
+	};
+}
+/**
+* 映射 Code Quality severity：
+* - `error` → `high`（语义对齐 code-scanning 映射：error 表示需立即关注）
+* - `warning` → `medium`
+* - `note` → `low`
+* - 缺失或非法值 → `'unknown'`（不静默丢弃）
+*
+* 与 code-scanning 共用 `error/warning/note` 值域（GitHub CodeQL 规则同源），
+* 映射口径与 `mapCodeScanningSeverity` 对齐（避免新源不一致）。
+*/
+function mapCodeQualitySeverity(severity) {
+	switch (severity) {
+		case "error": return "high";
+		case "warning": return "medium";
+		case "note": return "low";
+		default: return "unknown";
+	}
+}
+/**
+* 将 GitHub API URL（`https://api.github.com/repos/{owner}/{repo}/code-quality/findings/{n}`）
+* 转换为 web URL（`https://github.com/{owner}/{repo}/code-quality/findings/{n}`）。
+*
+* GitHub web URL 形态固定（不含 `/repos/` 段），直接基于 owner/repo/number 构造
+* 比正则替换更稳健（避免 API 路径形态变化导致错误）。
+*/
+function toWebUrl(apiUrl, owner, repo, number) {
+	return `https://github.com/${owner}/${repo}/code-quality/findings/${number}`;
+}
+/**
+* 解析 GitHub Link header 提取 `rel="next"` 的 cursor（after=...）。
+* 返回 cursor 字符串；无 next → 返回 undefined（终止分页）。
+*
+* GitHub Code Quality API 用 cursor-based 分页（before/after）而非 page-based，
+* 与 listAlertsForRepo 的 page=1&page=2 不同；Link header 格式相同。
+*/
+function parseNextCursor(linkHeader) {
+	if (!linkHeader) return;
+	const nextMatch = /<([^>]+)>;\s*rel="next"/.exec(linkHeader);
+	if (!nextMatch) return;
+	const nextUrl = nextMatch[1];
+	try {
+		return new URL(nextUrl).searchParams.get("after") ?? void 0;
+	} catch {
+		return;
+	}
+}
+
+//#endregion
+//#region src/code-scanning/rule-config.ts
+/** 默认规则配置（编译后；与既有常量表等价，单点声明保持向后兼容） */
+const DEFAULT_RULES_CONFIG = {
+	autoFixable: /* @__PURE__ */ new Set(["eol-last"]),
+	suggested: /* @__PURE__ */ new Map([
+		["no-unused-vars", "删除未使用的变量/导入；注意导出引用与副作用（import 副作用场景），确认后手动删除"],
+		["js/sql-injection", "使用参数化查询（PreparedStatement / query builder），禁止字符串拼接 SQL"],
+		["js/xss", "输出前 HTML 转义；innerHTML / document.write 场景用 DOMPurify 等清洗库"],
+		["js/path-injection", "校验用户输入路径在预期目录内（path.resolve + 前缀校验），禁止直接拼接文件路径"],
+		["js/command-line-injection", "避免 shell 字符串拼接，使用参数数组（child_process.spawn(args)）"],
+		["js/insecure-randomness", "安全随机数使用 crypto.randomBytes / Web Crypto，禁止 Math.random"],
+		["js/weak-cryptographic-algorithm", "升级为强算法（AES-256-GCM / Argon2 / SHA-256+），安全场景禁用 MD5/SHA-1"],
+		["js/missing-rate-limiting", "为认证/敏感接口添加限流（如 express-rate-limit）"],
+		["js/clear-text-storage-of-sensitive-data", "敏感数据加密存储（AES-256-GCM），禁止明文落盘"],
+		["js/clear-text-transmission-of-sensitive-data", "启用 TLS（HTTPS/WSS），禁止明文传输敏感数据"],
+		["js/hardcoded-credentials", "凭证移入环境变量/密钥管理服务（GitHub Secrets / Vault），禁止硬编码"],
+		["py/sql-injection", "使用参数化查询（sqlite3 占位符 / SQLAlchemy 参数绑定），禁止字符串拼接 SQL"],
+		["py/path-injection", "校验并规范化用户输入路径（os.path.realpath + 目录前缀校验）"],
+		["py/command-line-injection", "使用参数数组（subprocess.run(args)），禁止 shell=True 字符串拼接"],
+		["py/insecure-default-file-permissions", "创建文件时显式设置权限（os.open mode / umask）"],
+		["java/sql-injection", "使用 PreparedStatement 参数绑定，禁止字符串拼接 SQL"],
+		["java/path-injection", "校验用户输入路径（Path.normalize() + startsWith 检查），禁止直接拼接"],
+		["java/command-line-injection", "使用 ProcessBuilder 参数列表，禁止 shell 字符串拼接"]
+	])
+};
+/**
+* 解析 JSON 配置输入为编译后配置。
+*
+* 校验规则（全部失败均降级返回 null，由调用方走默认）：
+* - 顶层必须是对象，含 `rules` 数组
+* - 每个 entry 必须含非空 `id`（trim 后）、合法 `class`
+* - 同 id 在多个 class 中出现 → 拒绝（disjointness 不变量）
+* - suggested 必须含 `suggestion` 字段且非空
+*
+* @returns 解析成功 → 编译后配置；失败 → null（调用方降级）
+*/
+function parseRulesConfig(input) {
+	if (!input || typeof input !== "object") return null;
+	const file = input;
+	if (!Array.isArray(file.rules)) return null;
+	const autoFixable = /* @__PURE__ */ new Set();
+	const suggested = /* @__PURE__ */ new Map();
+	const seenIds = /* @__PURE__ */ new Set();
+	for (const raw of file.rules) {
+		if (!raw || typeof raw !== "object") return null;
+		const id = typeof raw.id === "string" ? raw.id.trim() : "";
+		if (!id) return null;
+		if (seenIds.has(id)) return null;
+		seenIds.add(id);
+		const cls = raw.class;
+		if (cls !== "auto-fixable" && cls !== "suggested" && cls !== "report-only") return null;
+		if (cls === "auto-fixable") autoFixable.add(id);
+		else if (cls === "suggested") {
+			const suggestion = typeof raw.suggestion === "string" ? raw.suggestion.trim() : "";
+			if (!suggestion) return null;
+			suggested.set(id, suggestion);
+		}
+	}
+	return {
+		autoFixable,
+		suggested
+	};
+}
+/**
+* 从 JSON 文件路径加载并编译。读取失败 / 解析失败 / 校验失败 → 返回 null（调用方降级）。
+*/
+function loadRulesConfigFromFile(configPath) {
+	let content;
+	try {
+		content = readFileSync(configPath, "utf-8");
+	} catch (error) {
+		process.stderr.write(`[rule-config] cannot read ${configPath}: ${error instanceof Error ? error.message : String(error)}\n`);
+		return null;
+	}
+	let parsed;
+	try {
+		parsed = JSON.parse(content);
+	} catch (error) {
+		process.stderr.write(`[rule-config] invalid JSON in ${configPath}: ${error instanceof Error ? error.message : String(error)}\n`);
+		return null;
+	}
+	const compiled = parseRulesConfig(parsed);
+	if (!compiled) process.stderr.write(`[rule-config] invalid config schema in ${configPath}, falling back to defaults\n`);
+	return compiled;
+}
+/** 环境变量名：Code Scanning 规则分类配置文件路径 */
+const RULE_CONFIG_ENV = "CODE_SCANNING_RULES_CONFIG_PATH";
+/**
+* 从 env 读取 `RULE_CONFIG_ENV` 并尝试加载。
+*
+* - env 未设或空 → 返回 null（调用方继续走默认）
+* - 路径不存在 → 返回 null
+* - 加载失败 → 返回 null（错误已写入 stderr）
+*/
+function loadRulesConfigFromEnv(env) {
+	const path = env[RULE_CONFIG_ENV]?.trim();
+	if (!path) return null;
+	if (!existsSync(path)) {
+		process.stderr.write(`[rule-config] ${RULE_CONFIG_ENV} points to non-existent path: ${path}\n`);
+		return null;
+	}
+	return loadRulesConfigFromFile(path);
+}
+let activeConfig = DEFAULT_RULES_CONFIG;
+/** 获取当前生效的配置（classifyRule / suggestionFor 内部使用） */
+function getActiveRulesConfig() {
+	return activeConfig;
+}
+/**
+* 替换为自定义配置。
+*
+* **使用协议**：运行时模块初始化时（如 AppContext 装配）调用一次；
+* 测试可临时覆盖后通过 `resetActiveRulesConfig` 恢复。频繁切换会破坏
+* `code-scanning-fetcher` 的可预测行为（同一规则在不同 fetch 中分类不同）。
+*/
+function setActiveRulesConfig(config) {
+	activeConfig = config;
+}
+/** 重置为默认配置（测试 cleanup + 运行时 fallback） */
+function resetActiveRulesConfig() {
+	activeConfig = DEFAULT_RULES_CONFIG;
+}
+
 //#endregion
 //#region src/code-scanning/rule-classifier.ts
 /**
-* A 类自动修复白名单：仅收录"删除/改动后不影响程序行为"且**已有修复模板**的规则。
+* A 类自动修复白名单默认集合（默认值常量；测试 disjointness 不变量用）。
+*
+* **与 active config 的关系**：本导出为默认常量（向后兼容历史测试与外部引用），
+* 运行时 classifyRule 实际从 `getActiveRulesConfig().autoFixable` 读取。
+* 若配置已被 setActiveRulesConfig 替换，本常量与运行时分类可能不一致（设计意图）。
 *
 * 选择标准（实现时评审确认）：
 * - 可模板化：修复动作可机械描述（删行 / 对齐 / 移除空白）
@@ -137,9 +445,9 @@ function sleep(ms) {
 * 纯格式规则（eol-last 等）实际出现频率低；此处先建立机制，
 * 规则命中与否不影响分层正确性。
 */
-const AUTO_FIXABLE_RULES = /* @__PURE__ */ new Set(["eol-last"]);
+const AUTO_FIXABLE_RULES = DEFAULT_RULES_CONFIG.autoFixable;
 /**
-* B 类建议修复列表：高风险 / 需人工判断的规则。
+* B 类建议规则默认列表（默认值常量；测试 disjointness 不变量用）。
 *
 * 收录原则：
 * - 安全敏感（注入 / XSS / 路径穿越 / 密码学等），修复需结合业务语义
@@ -152,109 +460,30 @@ const AUTO_FIXABLE_RULES = /* @__PURE__ */ new Set(["eol-last"]);
 * 其余语言（go/ruby/csharp/cpp 等）与未收录变体（如 js/reflected-xss）落 C 类兜底；
 * 真实仓库 API 样本核对（rule id 格式与变体分布）登记为演进项。
 */
-const SUGGESTED_RULES = /* @__PURE__ */ new Set([
-	"no-unused-vars",
-	"js/sql-injection",
-	"js/xss",
-	"js/path-injection",
-	"js/command-line-injection",
-	"js/insecure-randomness",
-	"js/weak-cryptographic-algorithm",
-	"js/missing-rate-limiting",
-	"js/clear-text-storage-of-sensitive-data",
-	"js/clear-text-transmission-of-sensitive-data",
-	"js/hardcoded-credentials",
-	"py/sql-injection",
-	"py/path-injection",
-	"py/command-line-injection",
-	"py/insecure-default-file-permissions",
-	"java/sql-injection",
-	"java/path-injection",
-	"java/command-line-injection"
-]);
+const SUGGESTED_RULES = new Set(DEFAULT_RULES_CONFIG.suggested.keys());
 /**
 * 规则分类：
 * - A 类白名单 → `'auto-fixable'`
 * - B 类建议列表 → `'suggested'`
 * - 其余（含空字符串）→ `'report-only'`（C 类，默认，不静默丢弃）
+*
+* 读取自当前生效配置（`getActiveRulesConfig()`）；首次调用前需通过
+* `setActiveRulesConfig` 替换或保持默认。
 */
 function classifyRule(ruleId) {
 	const id = ruleId?.trim() ?? "";
-	if (AUTO_FIXABLE_RULES.has(id)) return "auto-fixable";
-	if (SUGGESTED_RULES.has(id)) return "suggested";
+	const config = getActiveRulesConfig();
+	if (config.autoFixable.has(id)) return "auto-fixable";
+	if (config.suggested.has(id)) return "suggested";
 	return "report-only";
 }
 /**
 * B 类建议规则的人工修复方向（报告/PR body 建议区块展示）。
-* 收录 SUGGESTED_RULES 的修复指引；未收录规则返回通用建议（C 类兜底，不静默）。
-*/
-const SUGGESTION_MAP = /* @__PURE__ */ new Map([
-	["no-unused-vars", "删除未使用的变量/导入；注意导出引用与副作用（import 副作用场景），确认后手动删除"],
-	["js/sql-injection", "使用参数化查询（PreparedStatement / query builder），禁止字符串拼接 SQL"],
-	["js/xss", "输出前 HTML 转义；innerHTML / document.write 场景用 DOMPurify 等清洗库"],
-	["js/path-injection", "校验用户输入路径在预期目录内（path.resolve + 前缀校验），禁止直接拼接文件路径"],
-	["js/command-line-injection", "避免 shell 字符串拼接，使用参数数组（child_process.spawn(args)）"],
-	["js/insecure-randomness", "安全随机数使用 crypto.randomBytes / Web Crypto，禁止 Math.random"],
-	["js/weak-cryptographic-algorithm", "升级为强算法（AES-256-GCM / Argon2 / SHA-256+），安全场景禁用 MD5/SHA-1"],
-	["js/missing-rate-limiting", "为认证/敏感接口添加限流（如 express-rate-limit）"],
-	["js/clear-text-storage-of-sensitive-data", "敏感数据加密存储（AES-256-GCM），禁止明文落盘"],
-	["js/clear-text-transmission-of-sensitive-data", "启用 TLS（HTTPS/WSS），禁止明文传输敏感数据"],
-	["js/hardcoded-credentials", "凭证移入环境变量/密钥管理服务（GitHub Secrets / Vault），禁止硬编码"],
-	["py/sql-injection", "使用参数化查询（sqlite3 占位符 / SQLAlchemy 参数绑定），禁止字符串拼接 SQL"],
-	["py/path-injection", "校验并规范化用户输入路径（os.path.realpath + 目录前缀校验）"],
-	["py/command-line-injection", "使用参数数组（subprocess.run(args)），禁止 shell=True 字符串拼接"],
-	["py/insecure-default-file-permissions", "创建文件时显式设置权限（os.open mode / umask）"],
-	["java/sql-injection", "使用 PreparedStatement 参数绑定，禁止字符串拼接 SQL"],
-	["java/path-injection", "校验用户输入路径（Path.normalize() + startsWith 检查），禁止直接拼接"],
-	["java/command-line-injection", "使用 ProcessBuilder 参数列表，禁止 shell 字符串拼接"]
-]);
-/** 生成修复建议方向文本；未知规则返回通用建议（C 类兜底）。 */
+* 读取自当前生效配置（`getActiveRulesConfig().suggested`）；未收录规则返回通用建议（C 类兜底，不静默）。
+*/
 function suggestionFor(ruleId) {
 	const id = ruleId?.trim() ?? "";
-	return SUGGESTION_MAP.get(id) ?? "人工审查该 Code Scanning 告警：结合业务语义评估修复方案（参考 CodeQL 规则文档）";
-}
-
-//#endregion
-//#region src/github/errors.ts
-/**
-* 将 Octokit 请求错误映射为 `AppError`。
-*
-* @param error   - 原始错误（`RequestError` 或网络异常）
-* @param context - 调用上下文描述（如 `'fetch repo info for foo/bar'`），会附加到错误消息中
-*/
-function mapGitHubError(error, context) {
-	if (error instanceof RequestError) {
-		const code = resolveErrorCode(error);
-		const details = collectErrorDetails(error);
-		return new AppError(code, `${context}: ${error.message}`, {
-			cause: error,
-			details
-		});
-	}
-	if (error instanceof Error) return new AppError("NETWORK_ERROR", `${context}: ${error.message}`, { cause: error });
-	return new AppError("NETWORK_ERROR", `${context}: unknown error`, { details: { raw: toErrorMessage(error) } });
-}
-function resolveErrorCode(error) {
-	switch (error.status) {
-		case 401: return "AUTHENTICATION_FAILED";
-		case 403: {
-			const remaining = error.response?.headers["x-ratelimit-remaining"];
-			if (remaining !== void 0 && remaining === "0") return "RATE_LIMITED";
-			return "PERMISSION_DENIED";
-		}
-		case 404: return "REPO_NOT_FOUND";
-		default: return "GITHUB_API_ERROR";
-	}
-}
-function collectErrorDetails(error) {
-	const details = {
-		status: error.status,
-		requestUrl: error.request?.url,
-		requestMethod: error.request?.method
-	};
-	const resetAt = error.response?.headers["x-ratelimit-reset"];
-	if (resetAt) details.rateLimitReset = resetAt;
-	return details;
+	return getActiveRulesConfig().suggested.get(id) ?? "人工审查该 Code Scanning 告警：结合业务语义评估修复方案（参考 CodeQL 规则文档）";
 }
 
 //#endregion
@@ -729,6 +958,12 @@ function generatePRBody(result, supersededNumbers) {
 		`| Verifications failed | ${summary.verificationsFailed} |`,
 		""
 	];
+	const supplyChainWarnings = result.supplyChainWarnings ?? [];
+	if (supplyChainWarnings.length > 0) {
+		lines.push("### ⚠️ Supply Chain Warnings", "", "> 以下升级的包带 lifecycle scripts 且已被仓库 `allowBuilds` 批准——安装时脚本将真实执行。合入本 PR 前请人工确认。", "", "| Package | Version | Scripts | Repository |", "|---------|---------|---------|------------|");
+		for (const w of supplyChainWarnings) lines.push(`| \`${escapeTableCell(w.packageName)}\` | \`${escapeTableCell(w.version)}\` | ${w.scriptTypes.map((t) => `\`${escapeTableCell(t)}\``).join(", ")} | ${escapeTableCell(w.repository)} |`);
+		lines.push("");
+	}
 	const upgrades = aggregateUpgradeActions(actions, (a) => a.success);
 	if (upgrades.length > 0) {
 		const multiRepo = new Set(upgrades.map((u) => u.repository)).size > 1;
@@ -1166,6 +1401,79 @@ async function probeDependabotConfig(client, owner, repo) {
 	}
 }
 
+//#endregion
+//#region src/github/token-scope.ts
+const CLASSIC_REPO_SCOPE_WARNING = {
+	code: "CLASSIC_REPO_SCOPE",
+	message: "检测到 classic PAT 且包含 repo（全量仓库）权限——该 token 一旦被恶意依赖脚本窃取，即可接管所有可见仓库。建议改用 fine-grained PAT（最小权限：contents/pull-requests 写 + security-events 读，仅目标仓库），详见 quick-start 安全注意事项。"
+};
+const MISSING_SECURITY_EVENTS_WARNING = {
+	code: "MISSING_SECURITY_EVENTS",
+	message: "已开启 Code Scanning 告警源，但 token 缺少 security-events 读取权限——Code Scanning 告警将拉取失败。请为 token 授予 security-events 读取权限（classic PAT 对应 security_events scope，内置 GITHUB_TOKEN 默认具备）。"
+};
+/**
+* 解析 GitHub token 权限面并输出警告（纯函数，可单测）。
+*
+* @param scopeHeader `GET /user` 响应的 `x-oauth-scopes` 头（classic PAT 才有值）
+* @param acceptedHeader `GET /user` 响应的 `x-accepted-github-permissions` 头（fine-grained / 内置 token 才有值）
+* @param options.codeScanningEnabled 是否开启 Code Scanning 源（开启时校验 security-events 权限）
+*/
+function analyzeTokenScope(scopeHeader, acceptedHeader, options = {}) {
+	const scopes = parseHeaderList(scopeHeader);
+	const acceptedPermissions = parseHeaderList(acceptedHeader);
+	if (scopes) {
+		const warnings = [];
+		if (scopes.includes("repo")) warnings.push(CLASSIC_REPO_SCOPE_WARNING);
+		if (options.codeScanningEnabled && !scopes.includes("security_events") && !scopes.includes("repo")) warnings.push(MISSING_SECURITY_EVENTS_WARNING);
+		return {
+			scopes,
+			warnings
+		};
+	}
+	if (acceptedPermissions) {
+		const warnings = [];
+		if (options.codeScanningEnabled && !hasPermission(acceptedPermissions, "security-events", "read")) warnings.push(MISSING_SECURITY_EVENTS_WARNING);
+		return {
+			acceptedPermissions,
+			warnings
+		};
+	}
+	return { warnings: [] };
+}
+/** 校验 accepted permissions 是否包含指定 resource 的指定 access 级别。 */
+function hasPermission(permissions, resource, access) {
+	return permissions.some((p) => {
+		const [res, acc] = p.split(":").map((s) => s.trim().toLowerCase());
+		return res === resource && acc === access;
+	});
+}
+/** 解析逗号分隔的响应头（去空白去空项）；头缺失或为空返回 undefined。 */
+function parseHeaderList(header) {
+	if (!header) return;
+	const items = header.split(",").map((s) => s.trim()).filter(Boolean);
+	return items.length > 0 ? items : void 0;
+}
+/**
+* 探测 token 权限面（网络调用，best-effort）。
+* 任何失败（鉴权 401 / 网络错误 / 超时）均静默返回 `ok: false`，不抛错。
+*/
+async function checkTokenPermissions(client, options = {}) {
+	try {
+		const response = await client.request("GET /user", { request: { signal: AbortSignal.timeout(5e3) } });
+		const analysis = analyzeTokenScope(response.headers["x-oauth-scopes"], response.headers["x-accepted-github-permissions"], options);
+		return {
+			ok: true,
+			login: response.data.login,
+			...analysis
+		};
+	} catch {
+		return {
+			ok: false,
+			warnings: []
+		};
+	}
+}
+
 //#endregion
 //#region src/code-scanning/templates.ts
 const TEMPLATES = new Map([{
@@ -1330,6 +1638,27 @@ function getStderr(err) {
 	if (err instanceof Error) return err.message;
 	return typeof err === "object" && err !== null ? JSON.stringify(err) : String(err);
 }
+/**
+* `pnpm install` stderr 中的已知失败特征 → 可读提示。
+* 当前覆盖：minimumReleaseAge 冷却期约束（目标仓库显式配置该策略时 strict 模式生效，
+* 解析报 ERR_PNPM_NO_MATURE_MATCHING_VERSION、frozen 校验报 ERR_PNPM_MINIMUM_RELEASE_AGE_VIOLATION）。
+* 未识别时返回 null，调用方保留原始 stderr。
+*/
+const INSTALL_FAILURE_HINTS = [[/ERR_PNPM_NO_MATURE_MATCHING_VERSION|ERR_PNPM_MINIMUM_RELEASE_AGE_VIOLATION|minimumReleaseAge/i, "target repo has a minimumReleaseAge policy; the upgrade target version is too fresh (cooldown not elapsed). Retry after the cooldown period, or relax the policy"]];
+/** 识别 `pnpm install` 失败原因，未识别返回 null。 */
+function classifyInstallFailure(stderr) {
+	for (const [pattern, hint] of INSTALL_FAILURE_HINTS) if (pattern.test(stderr)) return hint;
+	return null;
+}
+/**
+* 格式化 `pnpm install` 失败错误信息：识别到已知原因时附加可读提示。
+* 供升级链路各 catch 块统一使用（upgradeDependency / overrideTransitiveDependency /
+* applyVersionedOverrides），避免三处重复匹配逻辑。
+*/
+function formatInstallFailure(stderr) {
+	const hint = classifyInstallFailure(stderr);
+	return hint ? `pnpm install failed: ${hint}: ${stderr}` : `pnpm install failed: ${stderr}`;
+}
 
 //#endregion
 //#region src/fixers/dependency/index.ts
@@ -1391,7 +1720,7 @@ async function upgradeDependency(params) {
 			toVersion,
 			isMajor,
 			success: false,
-			error: `pnpm install failed: ${getStderr(installErr)}`
+			error: formatInstallFailure(getStderr(installErr))
 		};
 	}
 	cleanupBackups({
@@ -1478,13 +1807,14 @@ async function overrideTransitiveDependency(params) {
 			lockBackup,
 			workspaceBackup
 		});
+		const stderr = getStderr(installErr);
 		return {
 			packageName,
 			fromVersion,
 			toVersion,
 			isMajor,
 			success: false,
-			error: `pnpm install failed: ${getStderr(installErr)}`
+			error: formatInstallFailure(stderr)
 		};
 	}
 	if (verifyOverrideTookEffect) {
@@ -1638,7 +1968,7 @@ async function applyVersionedOverrides(params) {
 			toVersion: entries.map((entry) => entry[1]).join(", "),
 			isMajor: false,
 			success: false,
-			error: `pnpm install failed: ${stderr}`
+			error: formatInstallFailure(stderr)
 		};
 	}
 	cleanupBackups({
@@ -1921,6 +2251,7 @@ const FAILURE_PATTERNS = [
 	["CREDENTIAL_ERROR", /E401|ERR_PNPM_FETCH_401|ERR_PNPM_FETCH_403|authentication failed|Authorization/i],
 	["CORRUPTED_LOCKFILE", /\b(broken|corrupted|Cannot read).*lockfile|ERR_PNPM_BROKEN_LOCKFILE/i],
 	["LOCKFILE_VERSION_MISMATCH", /lockfileVersion.*incompatible|unsupported lockfile version|lockfile had been generated with/i],
+	["MINIMUM_RELEASE_AGE", /ERR_PNPM_NO_MATURE_MATCHING_VERSION|ERR_PNPM_MINIMUM_RELEASE_AGE_VIOLATION|minimumReleaseAge/i],
 	["RESOLVE_ERROR", /ERR_PNPM_NO_MATCHING_VERSION|resolution|resolve.*failed|ERR_PNPM_PEER_DEP_ISSUES/i]
 ];
 /**
@@ -1966,6 +2297,7 @@ function getStrategyChain(category) {
 			"FIX_ENTRIES",
 			"REINSTALL"
 		];
+		case "MINIMUM_RELEASE_AGE": return ["REGENERATE", "REINSTALL"];
 		case "UNKNOWN": return ["REGENERATE", "REINSTALL"];
 		case "CREDENTIAL_ERROR": return [];
 	}
@@ -2205,7 +2537,7 @@ function repairLockfile(params) {
 	return {
 		success: false,
 		failureCategory: category,
-		failureDetail: truncate$1(lastError, 500),
+		failureDetail: `${category === "MINIMUM_RELEASE_AGE" ? "target repo has a minimumReleaseAge policy; locked versions are too fresh. Retry after the cooldown period, or relax the policy: " : ""}${truncate$1(lastError, 500)}`,
 		attemptHistory: attempts
 	};
 }
@@ -2452,6 +2784,7 @@ const DEFAULT_RUNTIME_CONFIG = {
 	severityThreshold: "high",
 	alertSource: "github-dependabot",
 	codeScanningEnabled: false,
+	codeQualityEnabled: false,
 	allowMajorUpgrade: false,
 	maxAlertsPerRepository: 20,
 	maxConcurrency: 1,
@@ -2577,6 +2910,7 @@ function readEnvConfig(env = process.env) {
 		alertsToken: readEnv(env, "ALERTS_TOKEN")?.trim() || void 0,
 		alertSource: readAlertSource(readEnv(env, "ALERTS_SOURCE"), `${ENV_PREFIX}ALERTS_SOURCE`),
 		codeScanningEnabled: normalizeBoolean(readEnv(env, "CODE_SCANNING"), `${ENV_PREFIX}CODE_SCANNING`),
+		codeQualityEnabled: normalizeBoolean(readEnv(env, "CODE_QUALITY"), `${ENV_PREFIX}CODE_QUALITY`),
 		maxAlertsPerRepository: normalizeInteger(readEnv(env, "MAX_ALERTS_PER_REPOSITORY"), `${ENV_PREFIX}MAX_ALERTS_PER_REPOSITORY`),
 		maxConcurrency: normalizeInteger(readEnv(env, "MAX_CONCURRENCY"), `${ENV_PREFIX}MAX_CONCURRENCY`),
 		maxRetries: normalizeNonNegativeInteger(readEnv(env, "MAX_RETRIES"), `${ENV_PREFIX}MAX_RETRIES`),
@@ -2639,6 +2973,7 @@ function validateRuntimeConfig(config) {
 	for (const repo of config.repositories) if (!isValidRepoIdentifier(repo)) throw new AppError("CONFIG_VALIDATION_ERROR", `Invalid repository identifier: "${repo}". Expected format: owner/repo`);
 	if (isAuditSource && config.repositories.length > 1) throw new AppError("CONFIG_VALIDATION_ERROR", "pnpm-audit alert source supports at most one repository (it scans the current workspace lockfile).");
 	if (isAuditSource && config.codeScanningEnabled) throw new AppError("CONFIG_VALIDATION_ERROR", "code-scanning requires the github-dependabot alert source (Code Scanning alerts are fetched from the GitHub API).");
+	if (isAuditSource && config.codeQualityEnabled) throw new AppError("CONFIG_VALIDATION_ERROR", "code-quality requires the github-dependabot alert source (Code Quality findings are fetched from the GitHub API).");
 	if (isAuditSource && config.mode === "fix-and-pr") throw new AppError("CONFIG_VALIDATION_ERROR", "fix-and-pr mode requires the github-dependabot alert source. Use pnpm-audit with report-only/fix mode instead.");
 	if (isAuditSource && config.mode === "cleanup-branches") throw new AppError("CONFIG_VALIDATION_ERROR", "cleanup-branches mode requires the github-dependabot alert source (branch cleanup needs GitHub API).");
 	if (config.mode === "report-only" && config.createPullRequest) throw new AppError("CONFIG_VALIDATION_ERROR", "createPullRequest cannot be enabled when mode is report-only.");
@@ -2681,6 +3016,7 @@ function resolveRuntimeConfig(options = {}) {
 		alertsToken: cliOverrides.alertsToken ?? envConfig.alertsToken,
 		alertSource: cliOverrides.alertSource ?? envConfig.alertSource ?? DEFAULT_RUNTIME_CONFIG.alertSource,
 		codeScanningEnabled: cliOverrides.codeScanningEnabled ?? envConfig.codeScanningEnabled ?? DEFAULT_RUNTIME_CONFIG.codeScanningEnabled,
+		codeQualityEnabled: cliOverrides.codeQualityEnabled ?? envConfig.codeQualityEnabled ?? DEFAULT_RUNTIME_CONFIG.codeQualityEnabled,
 		allowMajorUpgrade: cliOverrides.allowMajorUpgrade ?? DEFAULT_RUNTIME_CONFIG.allowMajorUpgrade,
 		maxAlertsPerRepository: cliOverrides.maxAlertsPerRepository ?? envConfig.maxAlertsPerRepository ?? DEFAULT_RUNTIME_CONFIG.maxAlertsPerRepository,
 		maxConcurrency: cliOverrides.maxConcurrency ?? envConfig.maxConcurrency ?? DEFAULT_RUNTIME_CONFIG.maxConcurrency,
@@ -2897,6 +3233,250 @@ function formatHistory(entries, repo) {
 	return lines.join("\n");
 }
 
+//#endregion
+//#region src/runners/network-audit.ts
+const CONNECT_TIMEOUT_MS = 1e4;
+/**
+* 默认出站白名单（网络白名单治理决策：仅 registry + GitHub API/资产域 + 受信任构建工具文档站）。
+* - `*.npmjs.org` 覆盖 npm registry 全子域（含 registry.npmjs.org 的 tarball 下载域）
+* - GitHub 相关：REST API（api.github.com）、git clone/网页（github.com）、
+*   release 资产（objects.githubusercontent.com）、raw 文件（raw.githubusercontent.com）
+* - `rolldown.rs` = vite 6/7 Rust 实现官方文档站；vite 跨 major 升级 verification 阶段命令输出
+*   会出现 `https://rolldown.rs/reference/...` 链接（verification-runner 命令输出 URL 提取会捕获），
+*   不放行则合法 verification 被误判 network_violation → run exitCode=1
+* 需要更多域时通过环境变量扩展（见 readAllowedDomains）。
+*/
+const DEFAULT_ALLOWED_DOMAINS = [
+	"*.npmjs.org",
+	"api.github.com",
+	"github.com",
+	"objects.githubusercontent.com",
+	"raw.githubusercontent.com",
+	"rolldown.rs"
+];
+/**
+* 从环境读取出站白名单：默认清单 + 扩展域（逗号分隔，追加不替换）。
+* 读取顺序：`DEPENDFIX_ALLOWED_DOMAINS` 优先，回退裸 `ALLOWED_DOMAINS`
+* （与 CLI 配置层的 DEPENDFIX_ 前缀惯例一致，同时兼容决策文档中的裸变量名）。
+* 空/未配置 → 仅默认清单。
+*/
+function readAllowedDomains(env = process.env) {
+	const raw = env.DEPENDFIX_ALLOWED_DOMAINS ?? env.ALLOWED_DOMAINS;
+	if (!raw) return [...DEFAULT_ALLOWED_DOMAINS];
+	const extra = raw.split(",").map((s) => s.trim()).filter(Boolean);
+	return [.../* @__PURE__ */ new Set([...DEFAULT_ALLOWED_DOMAINS, ...extra])];
+}
+/**
+* 从外联目标提取主机名（去协议、去路径、去端口；IPv6 方括号形式保留括号）。
+* - `host:port` / `https://host/path` / `host` → `host`
+* - `[::1]:443` → `[::1]`
+*/
+function extractHostname(target) {
+	let t = target.trim();
+	const protoIdx = t.indexOf("://");
+	if (protoIdx >= 0) t = t.slice(protoIdx + 3);
+	const slashIdx = t.indexOf("/");
+	if (slashIdx >= 0) t = t.slice(0, slashIdx);
+	if (t.startsWith("[")) {
+		const close = t.indexOf("]");
+		return close >= 0 ? t.slice(0, close + 1) : t;
+	}
+	const colonIdx = t.lastIndexOf(":");
+	return colonIdx >= 0 ? t.slice(0, colonIdx) : t;
+}
+/**
+* 白名单命中判定（大小写不敏感）。
+* - `*.domain` 通配符：匹配任意**子域**（`sub.domain`、`a.b.domain`），不含裸 `domain` 本身；
+*   边界由前导点保证（`evilnpmjs.org` 不会被 `*.npmjs.org` 命中）
+* - 其他条目：主机名精确匹配（IPv6 需带方括号，与 extractHostname 输出一致）
+*/
+function isDomainAllowed(hostname, allowedDomains) {
+	const host = hostname.trim().toLowerCase();
+	return allowedDomains.some((pattern) => {
+		const p = pattern.trim().toLowerCase();
+		if (p.startsWith("*.")) {
+			const base = p.slice(2);
+			return host.length > base.length + 1 && host.endsWith(`.${base}`);
+		}
+		return host === p;
+	});
+}
+/**
+* 将外联目标最小化为报告安全形态：仅保留 host[:port]，丢弃路径与查询串。
+* deny-by-default 拦截的证据字段不落 payload——恶意脚本通过 URL query 外带凭据时，
+* 网络层已拦截但查询串不得原样回显进报告/日志（防御纵深，最小暴露）。
+* - `evil.example.com:443`（CONNECT）→ 原样
+* - `https://evil.example.com/exfil?token=x` → `evil.example.com`
+* - `[::1]:443` / `http://host:8080/path` → 保留方括号/端口
+* - 空/无法解析 → `<unknown-target>`（防报告出现空目标）
+*/
+function redactUrlForReport(target) {
+	let t = target.trim();
+	const protoIdx = t.indexOf("://");
+	if (protoIdx >= 0) t = t.slice(protoIdx + 3);
+	const slashIdx = t.indexOf("/");
+	if (slashIdx >= 0) t = t.slice(0, slashIdx);
+	return t || "<unknown-target>";
+}
+/**
+* 启动本地网络拦截代理（127.0.0.1 随机端口）。
+* 支持 CONNECT 隧道（HTTPS）与明文 HTTP 转发；deny-by-default：非白名单目标
+* 返回 502/销毁 socket 且不建立上游连接，并记录违规外联；白名单命中才转发
+* （转发失败仍返回 502，不挂死调用方）。停止后服务器关闭。
+*/
+async function startNetworkAudit(options) {
+	const allowedDomains = options?.allowedDomains ?? readAllowedDomains();
+	const entries = [];
+	const violations = [];
+	const server = createServer();
+	server.on("connect", (req, clientSocket, head) => {
+		const target = req.url ?? "";
+		const baseEntry = {
+			time: (/* @__PURE__ */ new Date()).toISOString(),
+			source: "proxy",
+			method: "CONNECT",
+			target
+		};
+		const allowed = isDomainAllowed(extractHostname(target), allowedDomains);
+		const entry = allowed ? baseEntry : {
+			...baseEntry,
+			violation: true
+		};
+		entries.push(entry);
+		if (!allowed) {
+			violations.push(entry);
+			clientSocket.write("HTTP/1.1 502 Bad Gateway\r\n\r\n");
+			clientSocket.end();
+			return;
+		}
+		const idx = target.lastIndexOf(":");
+		const upstreamHost = target.slice(0, idx);
+		const port = Number.parseInt(target.slice(idx + 1), 10) || 443;
+		const upstream = connect(port, upstreamHost);
+		const timer = setTimeout(() => {
+			upstream.destroy();
+			clientSocket.destroy();
+		}, CONNECT_TIMEOUT_MS);
+		upstream.on("connect", () => {
+			clearTimeout(timer);
+			clientSocket.write("HTTP/1.1 200 Connection Established\r\n\r\n");
+			if (head && head.length > 0) upstream.write(head);
+			upstream.pipe(clientSocket);
+			clientSocket.pipe(upstream);
+		});
+		upstream.on("error", () => {
+			clearTimeout(timer);
+			clientSocket.destroy();
+		});
+		clientSocket.on("error", () => {
+			clearTimeout(timer);
+			upstream.destroy();
+		});
+	});
+	server.on("request", (req, res) => {
+		const hostHeader = req.headers.host ?? "";
+		const target = `${hostHeader}${req.url ?? ""}`;
+		const baseEntry = {
+			time: (/* @__PURE__ */ new Date()).toISOString(),
+			source: "proxy",
+			method: req.method ?? "GET",
+			target
+		};
+		const host = extractHostname(hostHeader);
+		const allowed = isDomainAllowed(host, allowedDomains);
+		const entry = allowed ? baseEntry : {
+			...baseEntry,
+			violation: true
+		};
+		entries.push(entry);
+		if (!allowed) {
+			violations.push(entry);
+			res.statusCode = 502;
+			res.end();
+			return;
+		}
+		const port = Number.parseInt(hostHeader.split(":")[1], 10) || 80;
+		const proxyReq = request({
+			host,
+			port,
+			path: req.url,
+			method: req.method,
+			headers: req.headers,
+			timeout: CONNECT_TIMEOUT_MS
+		}, (proxyRes) => {
+			const cleanHeaders = { ...proxyRes.headers };
+			for (const hop of [
+				"connection",
+				"keep-alive",
+				"transfer-encoding",
+				"te",
+				"trailer",
+				"upgrade",
+				"proxy-connection"
+			]) Reflect.deleteProperty(cleanHeaders, hop);
+			res.writeHead(proxyRes.statusCode ?? 500, cleanHeaders);
+			proxyRes.pipe(res);
+		});
+		proxyReq.on("error", () => {
+			res.statusCode = 502;
+			res.end();
+		});
+		proxyReq.on("timeout", () => {
+			proxyReq.destroy();
+			res.statusCode = 502;
+			res.end();
+		});
+		req.pipe(proxyReq);
+	});
+	await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
+	const address = server.address();
+	return {
+		proxyUrl: `http://127.0.0.1:${typeof address === "object" && address ? address.port : 0}`,
+		allowedDomains,
+		entries,
+		violations,
+		addEntries: (newEntries) => entries.push(...newEntries),
+		addViolation: (entry) => {
+			const violation = {
+				...entry,
+				violation: true
+			};
+			entries.push(violation);
+			violations.push(violation);
+		},
+		stop: () => new Promise((resolve) => {
+			server.closeAllConnections?.();
+			server.close(() => resolve());
+		})
+	};
+}
+const URL_PATTERN = /https?:\/\/[^\s"'<>)\]]+/g;
+/** 单条命令输出提取的外联 URL 数量上限（防恶意脚本输出轰炸撑爆审计记录） */
+const MAX_URLS_PER_COMMAND = 100;
+/**
+* 从命令输出提取外联 URL（去重、限数、截断超长）。
+* 仅提取 http(s) URL；无 URL 返回空数组。
+*/
+function extractUrlsFromOutput(output) {
+	if (!output) return [];
+	const urls = [];
+	for (const match of output.match(URL_PATTERN) ?? []) {
+		const clean = match.replace(/[.,;:]+$/, "");
+		if (!urls.includes(clean)) urls.push(clean);
+		if (urls.length >= MAX_URLS_PER_COMMAND) break;
+	}
+	return urls;
+}
+/**
+* 输出外联审计记录到执行日志：总数进 info、明细进 debug（verbose 才逐条）。
+* 仅记录方法+目标，无请求/响应体（无敏感信息）。
+*/
+function logNetworkAudit(logger, repo, entries) {
+	if (entries.length === 0) return;
+	logger.info(`[network-audit] ${repo}: ${entries.length} outbound connection(s) recorded`);
+	for (const entry of entries) logger.debug(`[network-audit] ${repo}: ${entry.source} ${entry.method} ${entry.target}`);
+}
+
 //#endregion
 //#region src/runners/verification-runner.ts
 const DEFAULT_COMMANDS = [
@@ -2904,8 +3484,29 @@ const DEFAULT_COMMANDS = [
 	"pnpm lint",
 	"pnpm build"
 ];
+const DEFAULT_COMMAND_TIMEOUT_MS = 6e5;
 const MAX_OUTPUT_LINES = 200;
 /**
+* 已知工具链 telemetry 关闭开关（治本实证 2026-08-25 —— Nuxt CLI 默认 telemetry 上报
+* 会向 telemetry.nuxt.com:443 真实外联，被审计代理 deny-by-default 命中，触发 verification
+* 阶段的外联拦截记录。verification 是离线构建验证，不应允许任何匿名 telemetry 上报）。
+*
+* 每条 entry 是 `[varName, disabledValue]`；子进程未设置该变量时注入 `disabledValue`。
+* 父进程已设置时不覆盖（保留用户显式选择，例如测试场景重新开启 telemetry）。
+*
+* 覆盖范围：
+* - `NUXT_TELEMETRY_DISABLED=1` — Nuxt CLI 3.x telemetry 开关（默认开启）
+* - `NEXT_TELEMETRY_DISABLED=1` — Next.js（备查，Nuxt 场景不命中但保留通用化）
+* - `DO_NOT_TRACK=1` — Vercel CLI / Sentry / 通用 DO_NOT_TRACK 协议
+*
+* 未涵盖的工具链：pnpm / npm / yarn 当前无内置 telemetry 上报，无需禁用。
+*/
+const TELEMETRY_DISABLED_VARS = [
+	["NUXT_TELEMETRY_DISABLED", "1"],
+	["NEXT_TELEMETRY_DISABLED", "1"],
+	["DO_NOT_TRACK", "1"]
+];
+/**
 * 压缩验证命令输出为报告可读的摘要（首尾各取若干行，超长中间省略）。
 * 完整输出由日志承载；报告保持紧凑，避免 error 字段失控膨胀。
 */
@@ -2917,9 +3518,11 @@ function summarizeVerificationOutput(output) {
 }
 /**
 * 构造失败验证命令的 error 描述：`exit code N — <stdout/stderr 摘要>`。
-* 无输出时退化为裸 `exit code N`。stdout/stderr 已在 execCommand 中脱敏、截断 200 行。
+* 无输出时退化为裸 `exit code N`；超时命令归类为 `timed out after Xms`。
+* stdout/stderr 已在 execCommand 中脱敏、截断 200 行。
 */
 function formatVerificationError(cr) {
+	if (cr.timedOut) return `timed out after ${cr.durationMs}ms`;
 	const detail = [cr.stdout, cr.stderr].filter(Boolean).join("\n--- stderr ---\n").trim();
 	return detail ? `exit code ${cr.exitCode} — ${summarizeVerificationOutput(detail)}` : `exit code ${cr.exitCode}`;
 }
@@ -2937,34 +3540,98 @@ function formatVerificationError(cr) {
 async function runVerification(params) {
 	const commands = params.commands ?? DEFAULT_COMMANDS;
 	const commandResults = [];
-	for (const command of commands) {
-		const result = await execCommand(command, params.workDir);
-		commandResults.push(result);
-		if (result.exitCode !== 0) return {
-			success: false,
-			commandResults,
-			failedCommand: command,
-			failure: `command "${command}" exited with code ${result.exitCode}`
-		};
+	let audit;
+	if (!params.networkAuditDisabled) audit = await startNetworkAudit().catch(() => void 0);
+	const hasExistingProxy = Boolean(process.env.HTTP_PROXY || process.env.HTTPS_PROXY || process.env.ALL_PROXY || process.env.http_proxy || process.env.https_proxy || process.env.all_proxy);
+	const proxyUrl = audit && !hasExistingProxy ? audit.proxyUrl : void 0;
+	try {
+		for (const command of commands) {
+			const result = await execCommand(command, params.workDir, params.commandTimeoutMs, proxyUrl);
+			commandResults.push(result);
+			if (audit) {
+				const urls = extractUrlsFromOutput(`${result.stdout}\n${result.stderr}`);
+				if (urls.length > 0) {
+					const time = (/* @__PURE__ */ new Date()).toISOString();
+					const entries = urls.map((target) => ({
+						time,
+						source: "command-output",
+						method: "GET",
+						target
+					}));
+					audit.addEntries(entries);
+				}
+			}
+			if (result.exitCode !== 0 || result.timedOut) return {
+				success: false,
+				commandResults,
+				failedCommand: command,
+				failure: result.timedOut ? `command "${command}" timed out after ${result.durationMs}ms` : `command "${command}" exited with code ${result.exitCode}`,
+				...audit ? {
+					networkAudit: audit.entries,
+					networkViolations: audit.violations
+				} : {}
+			};
+		}
+	} finally {
+		if (audit) await audit.stop().catch(() => {});
 	}
 	return {
 		success: true,
-		commandResults
+		commandResults,
+		...audit ? {
+			networkAudit: audit.entries,
+			networkViolations: audit.violations
+		} : {}
 	};
 }
 /**
+* 构造 verification 子进程环境变量：
+* - **基础**：`process.env` 全量复制（含 PATH 等系统变量），不丢失用户 shell 环境
+* - **telemetry 默认禁用**：注入 `NUXT_TELEMETRY_DISABLED=1` 等（父进程未设置时）；
+*   已设置时不覆盖，保留用户显式选择
+* - **审计代理**：`proxyUrl` 提供时附加 HTTP_PROXY/HTTPS_PROXY/ALL_PROXY/NO_PROXY
+*   重写；`proxyUrl` 为 undefined 时不动 HTTP_PROXY（用户既有代理不覆盖）
+*/
+function buildSpawnEnv(proxyUrl) {
+	const env = { ...process.env };
+	for (const [name, value] of TELEMETRY_DISABLED_VARS) if (env[name] === void 0 || env[name] === "") env[name] = value;
+	if (proxyUrl) {
+		env.HTTP_PROXY = proxyUrl;
+		env.HTTPS_PROXY = proxyUrl;
+		env.ALL_PROXY = proxyUrl;
+		env.NO_PROXY = "";
+		env.no_proxy = "";
+	}
+	return env;
+}
+/**
 * 执行单条 shell 命令，捕获 stdout/stderr（截断到 200 行）并脱敏。
+* 超过超时时间后中止命令并终止其进程树（防死循环脚本孙进程残留）。
+*
+* env 构造（治本实证 2026-08-25）：
+* - **总是构造**（不再 `undefined` 让子进程继承父环境）——为了精确控制 telemetry 禁用与代理注入
+* - **telemetry 默认禁用**：`NUXT_TELEMETRY_DISABLED=1` 等注入；父进程已设置时不覆盖
+* - **审计代理**：`proxyUrl` 提供时附加 HTTP_PROXY 等；用户既有代理时**不**覆盖父环境代理
+*   （覆盖会破坏用户网络行为，稳定性优先 —— 与既有 `skips proxy injection` 行为一致）
 */
-function execCommand(command, workDir) {
+function execCommand(command, workDir, timeoutMs = DEFAULT_COMMAND_TIMEOUT_MS, proxyUrl) {
 	return new Promise((resolve) => {
 		const startTime = Date.now();
+		let timedOut = false;
 		const cp = spawn(command, {
 			cwd: workDir,
 			shell: true,
-			stdio: "pipe"
+			stdio: "pipe",
+			detached: process.platform !== "win32",
+			env: buildSpawnEnv(proxyUrl)
 		});
 		const stdoutChunks = [];
 		const stderrChunks = [];
+		const timer = setTimeout(() => {
+			timedOut = true;
+			killProcessTree(cp.pid);
+			cp.kill("SIGKILL");
+		}, timeoutMs);
 		cp.stdout.on("data", (data) => {
 			stdoutChunks.push(data.toString("utf-8"));
 		});
@@ -2972,6 +3639,7 @@ function execCommand(command, workDir) {
 			stderrChunks.push(data.toString("utf-8"));
 		});
 		cp.on("error", (err) => {
+			clearTimeout(timer);
 			resolve({
 				command,
 				exitCode: -1,
@@ -2981,18 +3649,38 @@ function execCommand(command, workDir) {
 			});
 		});
 		cp.on("close", (code) => {
+			clearTimeout(timer);
 			const stdout = truncateLines(stdoutChunks.join(""), MAX_OUTPUT_LINES);
 			const stderr = truncateLines(stderrChunks.join(""), MAX_OUTPUT_LINES);
 			resolve({
 				command,
 				exitCode: code ?? -1,
 				durationMs: Date.now() - startTime,
+				timedOut,
 				stdout: sanitizeOutput(stdout),
 				stderr: sanitizeOutput(stderr)
 			});
 		});
 	});
 }
+/**
+* 终止进程树：POSIX 杀进程组（detached 进程组组长），Windows 用 taskkill /T /F。
+* 失败时静默退化（主终止路径已由调用方 cp.kill 兜底）。
+*/
+function killProcessTree(pid) {
+	if (pid === void 0 || pid <= 0) return;
+	if (process.platform === "win32") try {
+		spawnSync("taskkill", [
+			"/pid",
+			String(pid),
+			"/T",
+			"/F"
+		], { stdio: "ignore" });
+	} catch {}
+	else try {
+		process.kill(-pid, "SIGKILL");
+	} catch {}
+}
 /** 截断文本到指定行数 */
 function truncateLines(text, maxLines) {
 	const lines = text.split("\n");
@@ -3596,10 +4284,16 @@ async function fetchPnpmAuditAlerts(params) {
 * ⚠️ 发现漏洞时 pnpm audit 返回非零退出码（exit 1）是**正常行为**——JSON 输出仍然有效，
 * 不能以 exit code 判断失败（参考 security-alert-remediator 的 loadAuditReport 同款语义）。
 * 仅在空输出或 JSON 解析失败时视为硬失败。
+*
+* ⚠️ 显式 `--registry=https://registry.npmjs.org/`：
+* pnpm audit 默认继承用户 `.npmrc` / `npm_config_registry` 的镜像源（如 npmmirror），
+* 部分镜像站 advisory metadata 缺失或不同步会导致漏报安全漏洞——与 dependfix 的核心目标
+* （修复安全告警）直接冲突。对齐 `changelog-fetcher.ts` 默认口径（`registryBaseUrl ??
+* 'https://registry.npmjs.org'`）。追溯见 [backlog B 类登记「C35 pnpm audit 拉取应显式指定官方 registry」](../plan/backlog.md)。
 */
 function runPnpmAudit(workDir) {
 	return new Promise((resolve, reject) => {
-		const cp = spawn("pnpm audit --json", {
+		const cp = spawn("pnpm audit --json --registry=https://registry.npmjs.org/", {
 			cwd: workDir,
 			shell: true,
 			stdio: [
@@ -3643,6 +4337,8 @@ function normalizePatchedVersionValue(value) {
 		"none",
 		"unavailable"
 	].includes(normalized)) return null;
+	const versionMatch = /^[^\d]*(\d+(?:\.\d+){1,2}(?:-[0-9a-z.]+)?)/i.exec(normalized);
+	if (versionMatch) return versionMatch[1];
 	return String(value).trim();
 }
 /** 提取 advisory id：GitHub Advisory → CVE → URL → 原始 id（参考实现 resolveAdvisoryId） */
@@ -4314,6 +5010,180 @@ function enforceVerificationGate(ctx, options) {
 	return true;
 }
 
+//#endregion
+//#region src/supply-chain/index.ts
+/**
+* 供应链信号披露（安全治理：路径 A"合法包被投毒"合入前人工确认的关键依据）。
+*
+* 信号定义：本次新增/升级的包**带 lifecycle scripts**（install/preinstall/postinstall）
+* 且**已被目标仓库 `allowBuilds` / `onlyBuiltDependencies` 批准**——pnpm 10+/11 默认
+* 忽略依赖 lifecycle scripts，仅显式批准的包才在安装时执行脚本；被批准 + 带脚本
+* 的组合意味着升级该包会在目标仓库真实执行其脚本（投毒扩散面）。
+*
+* 数据源（不依赖 lockfile 的 hasInstallScript 字段——pnpm 11.17 实证该字段不写入）：
+* - 批准列表：目标仓库 `pnpm-workspace.yaml` 的 `allowBuilds`（对象）/
+*   `onlyBuiltDependencies`（数组）
+* - 脚本类型：升级验证后的 `node_modules/.pnpm/{pkg}@{ver}/node_modules/{pkg}/package.json`
+*   的 scripts 键（install/preinstall/postinstall）
+*/
+/** pnpm 生命周期的可执行脚本键（白名单，忽略 test/build 等非安装期脚本） */
+const LIFECYCLE_SCRIPT_KEYS = [
+	"install",
+	"preinstall",
+	"postinstall"
+];
+/** pnpm-workspace.yaml 中批准配置的键名（pnpm 10+ / pnpm 11 allowBuilds 对象） */
+const ALLOW_BUILDS_KEY = "allowBuilds";
+const ONLY_BUILT_DEPENDENCIES_KEY = "onlyBuiltDependencies";
+/**
+* 解析 pnpm-workspace.yaml 中被批准执行 install 脚本的包集合。
+*
+* 支持两种形态（行级解析，不引入 yaml 依赖）：
+* ```yaml
+* allowBuilds:            # pnpm 11 对象形态（pkg: true 或 pkg: [scripts]）
+*   esbuild: true
+*   better-sqlite3: true
+* onlyBuiltDependencies:  # pnpm 10 数组形态
+*   - esbuild
+* ```
+* 注释（#）、引号包名、行内尾注均可处理；缺失文件返回空集合。
+*/
+function parseWorkspaceAllowBuilds(workspaceYamlContent) {
+	const approved = /* @__PURE__ */ new Set();
+	if (!workspaceYamlContent) return approved;
+	const lines = workspaceYamlContent.split(/\r?\n/);
+	let section = null;
+	for (const rawLine of lines) {
+		const line = stripInlineComment(rawLine).trim();
+		if (!line) continue;
+		if (line === `${ALLOW_BUILDS_KEY}:`) {
+			section = "allowBuilds";
+			continue;
+		}
+		if (line === `${ONLY_BUILT_DEPENDENCIES_KEY}:`) {
+			section = "onlyBuiltDependencies";
+			continue;
+		}
+		if (isTopLevelKey(line)) {
+			section = null;
+			continue;
+		}
+		if (section === null) continue;
+		if (section === "allowBuilds") {
+			const match = line.match(/^([^:]+):\s*(.+)?$/);
+			if (match) {
+				const pkg = unquote(match[1].trim());
+				const value = (match[2] ?? "").trim();
+				if (pkg && value !== "false") approved.add(pkg);
+			}
+		} else if (section === "onlyBuiltDependencies") {
+			const match = line.match(/^-\s*(.+)$/);
+			if (match) {
+				const pkg = unquote(match[1].trim());
+				if (pkg) approved.add(pkg);
+			}
+		}
+	}
+	return approved;
+}
+/** 读取目标仓库的 pnpm-workspace.yaml 批准配置（文件不存在返回空集合）。 */
+function readWorkspaceAllowBuilds(workDir) {
+	const file = join(workDir, "pnpm-workspace.yaml");
+	if (!existsSync(file)) return /* @__PURE__ */ new Set();
+	return parseWorkspaceAllowBuilds(readFileSync(file, "utf-8"));
+}
+/**
+* 读取已安装包（node_modules/.pnpm 布局）的 lifecycle 脚本类型。
+* pnpm 布局：`node_modules/.pnpm/{name}@{version}/node_modules/{name}/package.json`
+* （scoped 包的 store 目录为 `@scope+pkg@version`）。
+* 带 peer 依赖的包 store 目录带后缀（`name@version_peer@v...`）——先精确匹配，
+* 未命中时前缀匹配兜底（防 peer 后缀漏披露）。
+* 包未安装（dry-run / install 未执行）时返回 undefined（调用方跳过）。
+*/
+function readInstalledPackageScriptTypes(workDir, packageName, version) {
+	const pkgJsonPath = resolveStorePackageJson(workDir, packageName, version);
+	if (!pkgJsonPath) return;
+	try {
+		const scripts = JSON.parse(readFileSync(pkgJsonPath, "utf-8")).scripts ?? {};
+		const types = LIFECYCLE_SCRIPT_KEYS.filter((key) => typeof scripts[key] === "string");
+		return types.length > 0 ? types : [];
+	} catch {
+		return;
+	}
+}
+/** 解析 pnpm store 内包的 package.json 路径（精确路径 → peer 后缀前缀匹配兜底）。 */
+function resolveStorePackageJson(workDir, packageName, version) {
+	const storeBase = `${packageName.replace("/", "+")}@${version}`;
+	const exact = join(workDir, "node_modules", ".pnpm", storeBase, "node_modules", packageName, "package.json");
+	if (existsSync(exact)) return exact;
+	const pnpmDir = join(workDir, "node_modules", ".pnpm");
+	if (!existsSync(pnpmDir)) return;
+	try {
+		const match = readdirSync(pnpmDir).find((name) => name.startsWith(`${storeBase}_`));
+		if (!match) return;
+		const peerPath = join(pnpmDir, match, "node_modules", packageName, "package.json");
+		return existsSync(peerPath) ? peerPath : void 0;
+	} catch {
+		return;
+	}
+}
+/**
+* 收集本次运行的供应链信号警示：成功升级的包 ∩ 目标仓库批准列表 ∩ 实际带 lifecycle 脚本。
+* 任一环节缺失（无 workspace.yaml / 包未安装 / 无脚本）自然降级为不披露。
+*/
+function collectSupplyChainWarnings(workDir, actions) {
+	const approved = readWorkspaceAllowBuilds(workDir);
+	if (approved.size === 0) return [];
+	const upgraded = /* @__PURE__ */ new Map();
+	for (const action of actions) {
+		if (action.type !== "dependency-upgrade" || !action.success || !action.target || !action.toVersion) continue;
+		const key = `${action.repository}\u0000${action.target}`;
+		upgraded.set(key, {
+			repository: action.repository,
+			packageName: action.target,
+			version: action.toVersion
+		});
+	}
+	const warnings = [];
+	for (const { repository, packageName, version } of upgraded.values()) {
+		if (!approved.has(packageName)) continue;
+		const scriptTypes = readInstalledPackageScriptTypes(workDir, packageName, version);
+		if (scriptTypes === void 0 || scriptTypes.length === 0) continue;
+		warnings.push({
+			repository,
+			packageName,
+			version,
+			scriptTypes
+		});
+	}
+	return warnings;
+}
+/** 剥离行内注释（# 在引号外才生效；包名含 # 的极端场景由 unquote 顺序保护）。 */
+function stripInlineComment(line) {
+	let inSingle = false;
+	let inDouble = false;
+	for (let i = 0; i < line.length; i++) {
+		const ch = line[i];
+		if (ch === "'" && !inDouble) inSingle = !inSingle;
+		else if (ch === "\"" && !inSingle) inDouble = !inDouble;
+		else if (ch === "#" && !inSingle && !inDouble) return line.slice(0, i);
+	}
+	return line;
+}
+/** 顶层配置键（两空格缩进为 0 或非空格的键；用于退出批准段）。 */
+function isTopLevelKey(line) {
+	return !line.startsWith(" ") && line.endsWith(":");
+}
+/** 去除单/双引号包裹。 */
+function unquote(value) {
+	if (value.length >= 2) {
+		const first = value[0];
+		const last = value[value.length - 1];
+		if (first === "\"" && last === "\"" || first === "'" && last === "'") return value.slice(1, -1);
+	}
+	return value;
+}
+
 //#endregion
 //#region src/app/branch-cleanup.ts
 /**
@@ -4524,6 +5394,101 @@ function confirmCleanup(ctx, repo, candidates) {
 	});
 }
 
+//#endregion
+//#region src/app/result-assembly.ts
+/** 汇总所有动作到 summary（alertsSkipped 已在 repo-fix 修复管线中累加）。 */
+function computeSummary(ctx) {
+	const { allActions, allAlerts, repoResults, summary } = ctx;
+	let fixed = 0;
+	let failed = 0;
+	let lockfileRepairs = 0;
+	let verificationsPassed = 0;
+	let verificationsFailed = 0;
+	for (const action of allActions) {
+		if (action.noOp) continue;
+		if (action.strategy === "ai-patch" || action.strategy === "ai-suggestion") continue;
+		if (action.type === "dependency-upgrade" || action.type === "code-scanning-fix") if (action.success) fixed++;
+		else failed++;
+		if (action.type === "lockfile-repair" && action.success) lockfileRepairs++;
+		if (action.type === "verification") if (action.success) verificationsPassed++;
+		else verificationsFailed++;
+	}
+	const fixable = allAlerts.filter((a) => a.fixable).length;
+	summary.repositoriesScanned = repoResults.length;
+	summary.alertsFound = allAlerts.length;
+	summary.alertsFixable = fixable;
+	summary.alertsFixed = fixed;
+	summary.alertsFailed = failed;
+	summary.lockfileRepairs = lockfileRepairs;
+	summary.verificationsPassed = verificationsPassed;
+	summary.verificationsFailed = verificationsFailed;
+}
+function buildRunResult(ctx, aiUsage, supplyChainWarnings) {
+	const reportConfig = {
+		mode: ctx.config.mode,
+		severityThreshold: ctx.config.severityThreshold,
+		repositories: ctx.config.repositories,
+		dryRun: ctx.config.dryRun,
+		createPullRequest: ctx.config.createPullRequest,
+		maxAlertsPerRepository: ctx.config.maxAlertsPerRepository,
+		alertSource: ctx.config.alertSource,
+		codeScanningEnabled: ctx.config.codeScanningEnabled,
+		codeQualityEnabled: ctx.config.codeQualityEnabled
+	};
+	return {
+		runId: ctx.runId,
+		startedAt: ctx.startedAt,
+		finishedAt: ctx.finishedAt,
+		config: reportConfig,
+		summary: ctx.summary,
+		repositories: ctx.repoResults,
+		alerts: ctx.allAlerts,
+		actions: ctx.allActions,
+		errors: ctx.allErrors,
+		aiUsage: aiUsage && aiUsage.calls > 0 ? aiUsage : void 0,
+		supplyChainWarnings: supplyChainWarnings && supplyChainWarnings.length > 0 ? supplyChainWarnings : void 0
+	};
+}
+/**
+* 聚合一次 AI 研判消耗到 run 级累计。
+* - 单次未调用（usage 为 undefined）幂等返回原累计
+* - 成本合并：任一侧 undefined 时结果 undefined（模型无单价 → 不做误导性估算）
+*/
+function mergeAiUsage(aggregate, usage) {
+	if (!usage || usage.calls === 0) return aggregate;
+	const next = {
+		calls: (aggregate?.calls ?? 0) + usage.calls,
+		inputTokens: (aggregate?.inputTokens ?? 0) + usage.inputTokens,
+		outputTokens: (aggregate?.outputTokens ?? 0) + usage.outputTokens,
+		totalTokens: (aggregate?.totalTokens ?? 0) + usage.totalTokens
+	};
+	if (aggregate === void 0) next.estimatedCostUsd = usage.estimatedCostUsd;
+	else if (aggregate.estimatedCostUsd === void 0 || usage.estimatedCostUsd === void 0) next.estimatedCostUsd = void 0;
+	else next.estimatedCostUsd = aggregate.estimatedCostUsd + usage.estimatedCostUsd;
+	return next;
+}
+/**
+* 计算退出码：
+* - 0: 全部仓库处理成功（无 failed actions、无 errors）
+* - 1: 部分仓库失败
+* - 2: 全部仓库失败（或无仓库被成功处理）
+*
+* 语义注记：AI 辅助动作（ai-patch）失败计入 exit code（fail-safe——AI 修复失败
+* 说明 breaking change 未解决，应报红提醒人工），但不计入 summary.alertsFailed
+* （告警结果由主动作代表；见 computeSummary 的 ai 辅助动作排除规则）。
+*/
+function computeExitCode(ctx) {
+	const { config, allErrors, allActions, repoResults } = ctx;
+	const hasErrors = allErrors.length > 0;
+	const hasFailures = allActions.some((a) => !a.success);
+	const hasRepoSuccess = repoResults.length > 0 && repoResults.some((r) => r.verificationPassed !== false && (r.alertsCount > 0 || r.fixed > 0 || r.verificationPassed === true));
+	const hasCleanupSuccess = config.mode === "cleanup-branches" && allActions.some((a) => a.success && a.type === "branch-cleanup");
+	const hasSuccess = hasRepoSuccess || hasCleanupSuccess;
+	if (!hasErrors && !hasFailures) return 0;
+	if (hasSuccess) return 1;
+	return 2;
+}
+
 //#endregion
 //#region src/app/helpers.ts
 const DEFAULT_VERIFY_COMMANDS = [
@@ -4623,6 +5588,19 @@ function codeScanningAlertsTokenHint(error) {
 	return null;
 }
 /**
+* Code Quality findings fetch 错误用户指引（token 需 fine-grained `Code quality: read`
+* 或 classic PAT `repo`/`public_repo` scope）。
+* 仅用于 Code Quality fetch 错误路径；按精确 context 匹配（`fetch code quality findings for`），
+* 不依赖裸关键字。
+*/
+function codeQualityAlertsTokenHint(error) {
+	if (!(error instanceof AppError)) return null;
+	if (!error.message.includes("fetch code quality findings for")) return null;
+	if (error.code === "PERMISSION_DENIED") return "请检查 token 是否具备 Code Quality findings 读取权限（fine-grained PAT 需 Code quality: read；classic PAT 需 repo / public_repo scope；GitHub App 需对应仓库权限）";
+	if (error.code === "AUTHENTICATION_FAILED") return "token 无效或已过期，请检查 GITHUB_TOKEN / alertsToken 配置";
+	return null;
+}
+/**
 * 为 lockfile 中存在脆弱实例的包构建 overrides 映射。
 *
 * 输入为该包所有 fixable 告警（不同 GHSA 推荐版本不同），按大版本分组取各线
@@ -4871,10 +5849,23 @@ async function verifyProject(ctx, repo) {
 		return [];
 	}
 	try {
-		return (await runVerification({
+		const result = await runVerification({
 			workDir,
 			commands: valid
-		})).commandResults.map((cr) => {
+		});
+		logNetworkAudit(logger, repo, result.networkAudit ?? []);
+		for (const violation of result.networkViolations ?? []) {
+			const redacted = redactUrlForReport(violation.target);
+			allErrors.push({
+				repository: repo,
+				target: redacted,
+				stage: "verify",
+				category: "network_violation",
+				message: `outbound blocked by allowlist: ${violation.method} ${redacted}`
+			});
+			logger.error(`[network-audit] ${repo}: outbound blocked (network_violation): ${violation.method} ${redacted}`);
+		}
+		return result.commandResults.map((cr) => {
 			const error = cr.exitCode !== 0 ? formatVerificationError(cr) : void 0;
 			if (error) logger.error(`Verification failed for ${repo}: ${cr.command} — ${error}`);
 			return {
@@ -4969,104 +5960,15 @@ function buildPrTitle(summary, actions) {
 	if (codeFixes > 0) parts.push(`${codeFixes} code fix${codeFixes > 1 ? "es" : ""}`);
 	return parts.length > 0 ? `fix(deps): automated security fix — ${parts.join(", ")}` : "fix(deps): automated security fix";
 }
-/** 汇总所有动作到 summary（alertsSkipped 已在 repo-fix 修复管线中累加）。 */
-function computeSummary(ctx) {
-	const { allActions, allAlerts, repoResults, summary } = ctx;
-	let fixed = 0;
-	let failed = 0;
-	let lockfileRepairs = 0;
-	let verificationsPassed = 0;
-	let verificationsFailed = 0;
-	for (const action of allActions) {
-		if (action.noOp) continue;
-		if (action.strategy === "ai-patch" || action.strategy === "ai-suggestion") continue;
-		if (action.type === "dependency-upgrade" || action.type === "code-scanning-fix") if (action.success) fixed++;
-		else failed++;
-		if (action.type === "lockfile-repair" && action.success) lockfileRepairs++;
-		if (action.type === "verification") if (action.success) verificationsPassed++;
-		else verificationsFailed++;
-	}
-	const fixable = allAlerts.filter((a) => a.fixable).length;
-	summary.repositoriesScanned = repoResults.length;
-	summary.alertsFound = allAlerts.length;
-	summary.alertsFixable = fixable;
-	summary.alertsFixed = fixed;
-	summary.alertsFailed = failed;
-	summary.lockfileRepairs = lockfileRepairs;
-	summary.verificationsPassed = verificationsPassed;
-	summary.verificationsFailed = verificationsFailed;
-}
-/** 组装最终运行结果。 */
-function buildRunResult(ctx, aiUsage) {
-	const reportConfig = {
-		mode: ctx.config.mode,
-		severityThreshold: ctx.config.severityThreshold,
-		repositories: ctx.config.repositories,
-		dryRun: ctx.config.dryRun,
-		createPullRequest: ctx.config.createPullRequest,
-		maxAlertsPerRepository: ctx.config.maxAlertsPerRepository,
-		alertSource: ctx.config.alertSource,
-		codeScanningEnabled: ctx.config.codeScanningEnabled
-	};
-	return {
-		runId: ctx.runId,
-		startedAt: ctx.startedAt,
-		finishedAt: ctx.finishedAt,
-		config: reportConfig,
-		summary: ctx.summary,
-		repositories: ctx.repoResults,
-		alerts: ctx.allAlerts,
-		actions: ctx.allActions,
-		errors: ctx.allErrors,
-		aiUsage: aiUsage && aiUsage.calls > 0 ? aiUsage : void 0
-	};
-}
-/**
-* 聚合一次 AI 研判消耗到 run 级累计。
-* - 单次未调用（usage 为 undefined）幂等返回原累计
-* - 成本合并：任一侧 undefined 时结果 undefined（模型无单价 → 不做误导性估算）
-*/
-function mergeAiUsage(aggregate, usage) {
-	if (!usage || usage.calls === 0) return aggregate;
-	const next = {
-		calls: (aggregate?.calls ?? 0) + usage.calls,
-		inputTokens: (aggregate?.inputTokens ?? 0) + usage.inputTokens,
-		outputTokens: (aggregate?.outputTokens ?? 0) + usage.outputTokens,
-		totalTokens: (aggregate?.totalTokens ?? 0) + usage.totalTokens
-	};
-	if (aggregate === void 0) next.estimatedCostUsd = usage.estimatedCostUsd;
-	else if (aggregate.estimatedCostUsd === void 0 || usage.estimatedCostUsd === void 0) next.estimatedCostUsd = void 0;
-	else next.estimatedCostUsd = aggregate.estimatedCostUsd + usage.estimatedCostUsd;
-	return next;
-}
-/**
-* 计算退出码：
-* - 0: 全部仓库处理成功（无 failed actions、无 errors）
-* - 1: 部分仓库失败
-* - 2: 全部仓库失败（或无仓库被成功处理）
-*
-* 语义注记：AI 辅助动作（ai-patch）失败计入 exit code（fail-safe——AI 修复失败
-* 说明 breaking change 未解决，应报红提醒人工），但不计入 summary.alertsFailed
-* （告警结果由主动作代表；见 computeSummary 的 ai 辅助动作排除规则）。
-*/
-function computeExitCode(ctx) {
-	const { config, allErrors, allActions, repoResults } = ctx;
-	const hasErrors = allErrors.length > 0;
-	const hasFailures = allActions.some((a) => !a.success);
-	const hasRepoSuccess = repoResults.length > 0 && repoResults.some((r) => r.verificationPassed !== false && (r.alertsCount > 0 || r.fixed > 0 || r.verificationPassed === true));
-	const hasCleanupSuccess = config.mode === "cleanup-branches" && allActions.some((a) => a.success && a.type === "branch-cleanup");
-	const hasSuccess = hasRepoSuccess || hasCleanupSuccess;
-	if (!hasErrors && !hasFailures) return 0;
-	if (hasSuccess) return 1;
-	return 2;
-}
 
 //#endregion
 //#region src/app/repo-alerts.ts
 /**
 * 告警数据源统一入口：
 * - `github-dependabot`：Octokit 拉取 Dependabot alerts（alertsToken 优先）；
-*   `codeScanningEnabled` 时**并行**拉取 Code Scanning alerts（互不覆盖、互不回退）
+*   `codeScanningEnabled` 时**并行**拉取 Code Scanning alerts（互不覆盖、互不回退）；
+*   `codeQualityEnabled` 时**并行**拉取 Code Quality findings（与 Code Scanning 同源独立开启）。
+*   三个 GitHub 源完全独立（可单独开启任意组合）。
 * - `pnpm-audit`：本地 `pnpm audit --json` 回退（无 token；repository 已由 resolveAlertRepositories 解析）
 *
 * per-source 错误隔离：并行源任一失败 → 记录该源 FETCH_FAILED 错误
@@ -5081,13 +5983,20 @@ async function fetchRepoAlerts(deps, repo) {
 	});
 	const alertsClient = createAlertsClientFromConfig(config);
 	const [owner, name] = repo.split("/");
-	const [dependabotResult, codeScanningResult] = await Promise.allSettled([fetchDependabotAlerts(alertsClient, {
-		owner,
-		repo: name
-	}), config.codeScanningEnabled ? fetchCodeScanningAlerts(alertsClient, {
-		owner,
-		repo: name
-	}) : Promise.resolve([])]);
+	const [dependabotResult, codeScanningResult, codeQualityResult] = await Promise.allSettled([
+		fetchDependabotAlerts(alertsClient, {
+			owner,
+			repo: name
+		}),
+		config.codeScanningEnabled ? fetchCodeScanningAlerts(alertsClient, {
+			owner,
+			repo: name
+		}) : Promise.resolve([]),
+		config.codeQualityEnabled ? fetchCodeQualityFindings(alertsClient, {
+			owner,
+			repo: name
+		}) : Promise.resolve([])
+	]);
 	const alerts = [];
 	const failedSources = [];
 	if (dependabotResult.status === "fulfilled") alerts.push(...dependabotResult.value);
@@ -5102,11 +6011,21 @@ async function fetchRepoAlerts(deps, repo) {
 		failedSources.push("code-scanning");
 		recordAlertSourceError(deps, repo, "code-scanning", codeScanningResult.reason);
 	}
-	const totalSources = config.codeScanningEnabled ? 2 : 1;
+	if (config.codeQualityEnabled) if (codeQualityResult.status === "fulfilled") {
+		alerts.push(...codeQualityResult.value);
+		deps.logger.info(`Fetched ${codeQualityResult.value.length} code quality findings for ${repo}`);
+	} else {
+		failedSources.push("code-quality");
+		recordAlertSourceError(deps, repo, "code-quality", codeQualityResult.reason);
+	}
+	let totalSources = 1;
+	if (config.codeScanningEnabled) totalSources++;
+	if (config.codeQualityEnabled) totalSources++;
 	if (failedSources.length === totalSources) {
 		let firstReason;
 		if (dependabotResult.status === "rejected") firstReason = dependabotResult.reason;
 		else if (codeScanningResult.status === "rejected") firstReason = codeScanningResult.reason;
+		else if (codeQualityResult.status === "rejected") firstReason = codeQualityResult.reason;
 		else firstReason = /* @__PURE__ */ new Error(`failed to fetch alerts for ${repo}`);
 		throw firstReason;
 	}
@@ -5130,7 +6049,7 @@ function createAlertsClientFromConfig(config) {
 /** 记录单个告警源的拉取失败（不中断另一源的处理）。 */
 function recordAlertSourceError(deps, repo, source, error) {
 	const message = toErrorMessage(error);
-	const hint = dependabotAlertsTokenHint(error) ?? codeScanningAlertsTokenHint(error);
+	const hint = dependabotAlertsTokenHint(error) ?? codeScanningAlertsTokenHint(error) ?? codeQualityAlertsTokenHint(error);
 	deps.logger.error(`Failed to fetch ${source} alerts for ${repo}: ${message}${hint ? ` — ${hint}` : ""}`);
 	deps.allErrors.push({
 		repository: repo,
@@ -5840,7 +6759,7 @@ async function applyLockfileFixes(ctx, client, repo, sets, progress) {
 		const targets = Object.values(versionedOverrides);
 		const targetSummary = targets.length > 0 ? targets.join(", ") : alert.recommendedVersion;
 		if (ctx.config.dryRun) {
-			ctx.logger.info(`[dry-run] Would apply versioned overrides for ${alert.packageName}: ${JSON.stringify(versionedOverrides)}`);
+			ctx.logger.info(`[dry-run] Would apply versioned overrides for ${alert.packageName}`, { overrides: versionedOverrides });
 			ctx.allActions.push({
 				type: "dependency-upgrade",
 				repository: alert.repository,
@@ -5861,7 +6780,7 @@ async function applyLockfileFixes(ctx, client, repo, sets, progress) {
 			continue;
 		}
 		const snapshot = snapshotTrackedFiles(ctx.workDir);
-		ctx.logger.info(`[multi-version] ${alert.packageName}: applying versioned overrides ${JSON.stringify(versionedOverrides)}`);
+		ctx.logger.info(`[multi-version] ${alert.packageName}: applying versioned overrides`, { overrides: versionedOverrides });
 		const result = await applyVersionedOverrides({
 			packageName: alert.packageName,
 			versionedOverrides,
@@ -6242,6 +7161,7 @@ var DependfixApp = class {
 	logger;
 	verbose;
 	customCommands;
+	executionEnvironment;
 	runId;
 	allAlerts = [];
 	allActions = [];
@@ -6260,11 +7180,21 @@ var DependfixApp = class {
 		this.reportOutputDir = options.reportOutputDir ?? "./dependfix-reports";
 		this.verbose = options.verbose ?? false;
 		this.customCommands = options.commands;
+		this.executionEnvironment = options.executionEnvironment ?? "local";
 		this.runId = `dependfix-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
 		this.logger = createLogger({
 			name: "dependfix",
 			minLevel: this.verbose ? "debug" : "info"
 		});
+		resetActiveRulesConfig();
+		const ruleConfig = loadRulesConfigFromEnv(process.env);
+		if (ruleConfig) {
+			setActiveRulesConfig(ruleConfig);
+			this.logger.debug("Loaded custom code-scanning rules config from env", {
+				autoFixableCount: ruleConfig.autoFixable.size,
+				suggestedCount: ruleConfig.suggested.size
+			});
+		}
 	}
 	/** 供辅助方法使用的状态切片。 */
 	get ctx() {
@@ -6286,6 +7216,7 @@ var DependfixApp = class {
 	/** 执行完整的编排流程，返回结构化结果和退出码。 */
 	async run() {
 		this.startedAt = (/* @__PURE__ */ new Date()).toISOString();
+		await this.runStartupSecurityChecks();
 		this.preExistingDirty = hasGitChanges(this.workDir);
 		this.logger.info(`Starting dependfix run ${this.runId}`, {
 			mode: this.config.mode,
@@ -6305,7 +7236,8 @@ var DependfixApp = class {
 		}
 		this.finishedAt = (/* @__PURE__ */ new Date()).toISOString();
 		computeSummary(this.ctx);
-		const runResult = buildRunResult(this.ctx, this.aiUsageRef.aggregate);
+		const supplyChainWarnings = collectSupplyChainWarnings(this.workDir, this.allActions);
+		const runResult = buildRunResult(this.ctx, this.aiUsageRef.aggregate, supplyChainWarnings);
 		const exitCode = computeExitCode(this.ctx);
 		try {
 			const md = generateMarkdownReport(runResult);
@@ -6330,6 +7262,20 @@ var DependfixApp = class {
 			exitCode
 		};
 	}
+	/**
+	* 启动安全自检（best-effort，任何失败不阻断运行）：
+	* - 本地模式风险提示：fix/fix-and-pr 会在用户机器直接执行目标仓库的
+	*   依赖脚本（不可信代码）；容器环境（平台沙箱）属于设计内隔离，跳过。
+	* - token 权限面探测：超权限 token（classic repo scope）启动即警告，
+	*   Code Scanning 开启但缺 security-events 权限时提示。
+	*/
+	async runStartupSecurityChecks() {
+		if (this.executionEnvironment === "local" && !this.config.dryRun && (this.config.mode === "fix" || this.config.mode === "fix-and-pr") && process.env.DEPENDFIX_SUPPRESS_LOCAL_EXECUTION_WARNING !== "1") this.logger.warn("[local-exec] 本地模式将直接执行目标仓库的依赖安装/验证脚本（install/lint/build 钩子，属不可信代码）——若仓库或依赖被恶意控制，脚本可读取本机环境变量（含 GITHUB_TOKEN）。建议：使用专用低权限 token，并在专用环境（容器/VM/CI runner）运行；已确认风险可设置 DEPENDFIX_SUPPRESS_LOCAL_EXECUTION_WARNING=1 抑制本提示（详见 quick-start 安全注意事项）。");
+		if (this.config.alertSource === "github-dependabot" && this.config.githubToken) {
+			const result = await checkTokenPermissions(this.createClient(), { codeScanningEnabled: this.config.codeScanningEnabled });
+			if (result.ok && result.warnings.length > 0) for (const warning of result.warnings) this.logger.warn(`[token-scope] ${warning.message}`);
+		}
+	}
 	async executeMode() {
 		switch (this.config.mode) {
 			case "report-only":
@@ -6484,7 +7430,8 @@ var DependfixApp = class {
 			pushBranch(branchName, this.workDir);
 			const defaultBranch = await fetchDefaultBranch(client, owner, repo);
 			computeSummary(this.ctx);
-			const runResult = buildRunResult(this.ctx, this.aiUsageRef.aggregate);
+			const supplyChainWarnings = collectSupplyChainWarnings(this.workDir, this.allActions);
+			const runResult = buildRunResult(this.ctx, this.aiUsageRef.aggregate, supplyChainWarnings);
 			const prBody = generatePRBody(runResult, plan.supersedePRs.map((pr) => pr.number));
 			const prTitle = buildPrTitle(this.summary, this.allActions);
 			const pr = await createPullRequest({
@@ -6627,5 +7574,5 @@ var DependfixApp = class {
 };
 
 //#endregion
-export { ALERT_SOURCES, AUTO_FIXABLE_RULES, AiUsageTracker, DEFAULT_CONCURRENCY, DEFAULT_RUNTIME_CONFIG, DependfixApp, ENV_PREFIX, MAX_CONCURRENCY_LIMIT, MAX_GLOB_PATTERN_LENGTH, RUNTIME_MODES, SEVERITY_THRESHOLDS, SUGGESTED_RULES, applyCodeScanningFix, applyVersionedOverrides, assessBreakingChange, buildUpgradeGroups, classifyLockfileFailure, classifyRule, closePullRequest, compareSemver, computeFixAndPrPlan, computeFixFingerprint, computeLockfileDiff, computeRetryDelayMs, createFixBranch, createGitHubClient, createPullRequest, dedupeFixableAlerts, deleteRemoteBranch, detectPnpmMajor, discoverRepositories, ensurePnpmOverrides, estimateCostUsd, extractFingerprintFromBranch, extractLockfileVersion, extractMainPackage, extractPrefix, fetchCodeScanningAlerts, fetchDependabotAlerts, fetchPnpmAuditAlerts, filterExplicitRepositories, findDependencyVersion, findDependfixOpenPR, formatHistory, formatVerificationError, generatePRBody, getBranchPrStatus, getCodeScanningFixTemplate, hashAdvisoryId, inferRepoFromGitRemote, isConfirmAnswer, isCrossMajorFixRequired, isMainPackagePresent, isNonSemverDeclaration, isRootDirectDependency, isValidConcurrency, isValidPnpmVersion, listDependfixBranches, mapGitHubError, maskSecrets, matchesPattern, matchesRepoExclude, matchesRepoGlob, matchesRepoInclude, matchesTopicsExclude, mergeRepositories, overrideTransitiveDependency, parseAuditReport, parseDependabotGroups, parseMajorVersion, partitionSubmanifestAlerts, pushBranch, queryRepoHistory, quickVerifyProject, readArchiveIndex, readEnv, readEnvConfig, readExistingOverrides, readLockfileVersion, readLockfileVersions, readReposFile, repairLockfile, repoGlobToRegExp, resolvePnpmVersion, resolveRepoList, resolveRuntimeConfig, resolveWithinWorkDir, restoreSourceFile, restoreTrackedFiles, runVerification, runWithConcurrency, sanitizeOutput, snapshotSourceFile, snapshotTrackedFiles, stageAndCommit, suggestionFor, summarizeVerificationOutput, upgradeDependency, writeArchive };
+export { ALERT_SOURCES, AUTO_FIXABLE_RULES, AiUsageTracker, DEFAULT_CONCURRENCY, DEFAULT_RULES_CONFIG, DEFAULT_RUNTIME_CONFIG, DependfixApp, ENV_PREFIX, MAX_CONCURRENCY_LIMIT, MAX_GLOB_PATTERN_LENGTH, RULE_CONFIG_ENV, RUNTIME_MODES, SEVERITY_THRESHOLDS, SUGGESTED_RULES, analyzeTokenScope, applyCodeScanningFix, applyVersionedOverrides, assessBreakingChange, buildPrTitle, buildUpgradeGroups, checkTokenPermissions, classifyLockfileFailure, classifyRule, closePullRequest, compareSemver, computeFixAndPrPlan, computeFixFingerprint, computeLockfileDiff, computeRetryDelayMs, createFixBranch, createGitHubClient, createPullRequest, dedupeFixableAlerts, deleteRemoteBranch, detectPnpmMajor, discoverRepositories, ensurePnpmOverrides, estimateCostUsd, extractFingerprintFromBranch, extractLockfileVersion, extractMainPackage, extractPrefix, fetchCodeQualityFindings, fetchCodeScanningAlerts, fetchDefaultBranch, fetchDependabotAlerts, fetchPnpmAuditAlerts, filterExplicitRepositories, findDependencyVersion, findDependfixOpenPR, formatHistory, formatVerificationError, generatePRBody, getActiveRulesConfig, getBranchPrStatus, getCodeScanningFixTemplate, hashAdvisoryId, inferRepoFromGitRemote, isConfirmAnswer, isCrossMajorFixRequired, isMainPackagePresent, isNonSemverDeclaration, isRootDirectDependency, isValidConcurrency, isValidPnpmVersion, listDependfixBranches, loadRulesConfigFromEnv, loadRulesConfigFromFile, mapCodeQualitySeverity, mapGitHubError, maskSecrets, matchesPattern, matchesRepoExclude, matchesRepoGlob, matchesRepoInclude, matchesTopicsExclude, mergeRepositories, overrideTransitiveDependency, parseAuditReport, parseDependabotGroups, parseMajorVersion, parseRulesConfig, partitionSubmanifestAlerts, pushBranch, queryRepoHistory, quickVerifyProject, readArchiveIndex, readEnv, readEnvConfig, readExistingOverrides, readLockfileVersion, readLockfileVersions, readReposFile, repairLockfile, repoGlobToRegExp, resetActiveRulesConfig, resolvePnpmVersion, resolveRepoList, resolveRuntimeConfig, resolveWithinWorkDir, restoreSourceFile, restoreTrackedFiles, runVerification, runWithConcurrency, sanitizeOutput, setActiveRulesConfig, snapshotSourceFile, snapshotTrackedFiles, stageAndCommit, suggestionFor, summarizeVerificationOutput, upgradeDependency, writeArchive };
 //# sourceMappingURL=index.mjs.map