@dependfix/engine 0.1.3 → 0.4.0

package/dist/index.mjs

@@ -1,128 +1,327 @@
-import { Octokit } from "@octokit/rest";
+import { a as fromPat, c as computeRetryDelayMs, l as createGitHubClient } from "./auth2.mjs";
 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 { AppError, collectCodeScanningSuggestions, createEmptyRunSummary, createLogger, filterAlerts, generateJsonReport, generateMarkdownReport, isAlertFixedByActions, isValidRepoIdentifier, limitAlerts, mapCodeScanningSeverity, normalizeAuditSeverity, normalizeUpstreamId, prioritizeAlerts, toErrorMessage, writeReport } from "@dependfix/core";
 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";
 
-//#region src/github/client.ts
+//#region src/github/errors.ts
 /**
-* 创建已认证的 Octokit 实例。
+* 将 Octokit 请求错误映射为 `AppError`。
 *
-* 调用方直接使用 `octokit.rest.*` 访问所有已类型化的 GitHub REST API。
-* 分页使用 `octokit.paginate()` 自动合并多页结果。
+* @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 并映射为标准化模型。
 *
-* 配置 `retry` 时通过 `hook.wrap('request')` 统一包装所有请求
-* （含 paginate 内部请求），对限流响应做指数退避重试。
+* - 自动分页（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`
+* - 空仓库返回 `[]`，不抛异常
 *
-* @example
-* ```typescript
-* const octokit = createGitHubClient({ token: 'ghp_xxxx' })
+* @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 转换为标准化模型。
 *
-* // 仓库信息
-* const { data: repo } = await octokit.rest.repos.get({ owner: 'foo', repo: 'bar' })
+* 映射逻辑：
+* - 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",
+		upstreamId: normalizeUpstreamId("code-quality", { alertNumber: finding.number })
+	};
+}
+/**
+* 映射 Code Quality severity：
+* - `error` → `high`（语义对齐 code-scanning 映射：error 表示需立即关注）
+* - `warning` → `medium`
+* - `note` → `low`
+* - 缺失或非法值 → `'unknown'`（不静默丢弃）
 *
-* // Dependabot 告警（自动分页）
-* const alerts = await octokit.paginate(
-*     octokit.rest.dependabot.listAlertsForRepo,
-*     { owner: 'foo', repo: 'bar', state: 'open', per_page: 100 },
-* )
-* ```
+* 与 code-scanning 共用 `error/warning/note` 值域（GitHub CodeQL 规则同源），
+* 映射口径与 `mapCodeScanningSeverity` 对齐（避免新源不一致）。
 */
-function createGitHubClient(options) {
-	const client = new Octokit({
-		auth: options.token,
-		baseUrl: options.baseUrl ?? "https://api.github.com"
-	});
-	const maxRetries = options.retry?.maxRetries ?? 3;
-	if (maxRetries > 0) applyRetryPolicy(client, {
-		maxRetries,
-		baseDelayMs: options.retry?.baseDelayMs ?? 1e3,
-		maxBackoffMs: options.retry?.maxBackoffMs ?? MAX_BACKOFF_MS_DEFAULT
-	});
-	return client;
-}
-const SECONDARY_RATE_LIMIT_RE = /secondary rate limit|abuse|retry later|retry-after/i;
-/** 指数退避单次等待默认上限（30s），防止长时间空转（可经 retry.maxBackoffMs 覆盖） */
-const MAX_BACKOFF_MS_DEFAULT = 3e4;
-function applyRetryPolicy(client, retry) {
-	const maxRetries = retry.maxRetries ?? 3;
-	const baseDelayMs = retry.baseDelayMs ?? 1e3;
-	const maxBackoffMs = retry.maxBackoffMs ?? MAX_BACKOFF_MS_DEFAULT;
-	client.hook.wrap("request", async (request, options) => {
-		const method = (options.method ?? "GET").toUpperCase();
-		if (method !== "GET" && method !== "HEAD") return request(options);
-		let attempt = 0;
-		for (;;) try {
-			return await request(options);
-		} catch (error) {
-			const delayMs = computeRetryDelayMs(error, attempt, baseDelayMs, maxBackoffMs);
-			if (delayMs === null || attempt >= maxRetries) throw error;
-			attempt += 1;
-			await sleep(delayMs);
-		}
-	});
+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 字符串拼接"]
+	])
+};
 /**
-* 计算限流重试等待时间（纯函数，可单测）。
-*
-* 可重试（返回等待毫秒）：
-* - 429（Too Many Requests / secondary rate limit）
-* - 403 + `x-ratelimit-remaining: 0`（primary rate limit）
-* - 403/429 + message 含 secondary rate limit / abuse / retry 特征
-*
-* 等待策略（Retry-After 优先）：
-* 1. `retry-after` 头（秒）→ 等待其秒数（受 maxBackoffMs 上限约束）
-* 2. `x-ratelimit-reset`（unix 秒）→ 等待到 reset + 1s 缓冲
-* 3. 否则 → 指数退避 `baseDelayMs * 2^attempt`
-* 所有等待均受 maxBackoffMs 上限约束（默认 30s）。
-*
-* 不重试（返回 null）：
-* - 非 RequestError（网络错误等由上层 AppError 语义处理）
-* - 权限类 403（无限流特征）
-* - 其他状态码
-*/
-function computeRetryDelayMs(error, attempt, baseDelayMs = 1e3, maxBackoffMs = MAX_BACKOFF_MS_DEFAULT) {
-	if (!(error instanceof RequestError)) return null;
-	const status = error.status;
-	const headers = error.response?.headers ?? {};
-	const remaining = headers["x-ratelimit-remaining"];
-	const message = error.message;
-	let retryable = false;
-	if (status === 429) retryable = true;
-	else if (status === 403) {
-		if (remaining !== void 0 && remaining === "0") retryable = true;
-		else if (SECONDARY_RATE_LIMIT_RE.test(message)) retryable = true;
-	}
-	if (!retryable) return null;
-	const retryAfter = headers["retry-after"];
-	if (retryAfter !== void 0) {
-		const seconds = Number(retryAfter);
-		if (Number.isFinite(seconds) && seconds > 0) return Math.min(seconds * 1e3, maxBackoffMs);
-	}
-	const reset = headers["x-ratelimit-reset"];
-	if (reset !== void 0) {
-		const resetMs = Number(reset) * 1e3;
-		if (Number.isFinite(resetMs) && resetMs > 0) {
-			const waitMs = resetMs - Date.now() + 1e3;
-			if (waitMs > 0) return Math.min(waitMs, maxBackoffMs);
+* 解析 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 Math.min(baseDelayMs * 2 ** attempt, maxBackoffMs);
+	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;
 }
-function sleep(ms) {
-	return new Promise((resolve) => setTimeout(resolve, ms));
+/** 重置为默认配置（测试 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 +336,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 +351,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
@@ -324,7 +444,8 @@ function normalizeAlert$1(alert, owner, repo) {
 		alertClass: classifyRule(ruleId),
 		startLine: instance?.location?.start_line ?? void 0,
 		endLine: instance?.location?.end_line ?? void 0,
-		suggestion: suggestionFor(ruleId)
+		suggestion: suggestionFor(ruleId),
+		upstreamId: normalizeUpstreamId("code-scanning", { alertNumber: alert.number })
 	};
 }
 /**
@@ -356,8 +477,13 @@ function mapSeverity(alert) {
 *
 * @example
 * ```typescript
-* const octokit = createGitHubClient({ token: 'ghp_xxxx' })
+* // 推荐：使用 auth 抽象层（M18.1 实施后）
+* import { fromPat } from '@dependfix/engine/auth'
+* const octokit = createGitHubClient({ auth: fromPat('ghp_xxxx') })
 * const alerts = await fetchDependabotAlerts(octokit, { owner: 'foo', repo: 'bar' })
+*
+* // 向后兼容：使用 token 字段（deprecated）
+* const octokit = createGitHubClient({ token: 'ghp_xxxx' })
 * ```
 */
 async function fetchDependabotAlerts(client, params) {
@@ -403,10 +529,22 @@ function normalizeAlert(alert, owner, repo) {
 		fixable,
 		fixStrategy: fixable ? "upgrade" : null,
 		recommendedVersion: firstPatched?.identifier ?? "",
-		dependencyType: normalizeDependencyRelationship(alert.dependency.relationship)
+		dependencyType: normalizeDependencyRelationship(alert.dependency.relationship),
+		upstreamId: normalizeUpstreamId("dependabot", { alertNumber: alert.number }),
+		ghsaId: alert.security_advisory.ghsa_id,
+		cveIds: extractCveIds(alert.security_advisory.identifiers)
 	};
 }
 /**
+** 从 dependabot alert.security_advisory.identifiers[] 提取 CVE 列表（type === 'CVE'）。
+** 兼容 identifiers 缺省为 undefined / 空数组场景。
+*/
+function extractCveIds(identifiers) {
+	if (!Array.isArray(identifiers) || identifiers.length === 0) return;
+	const cves = identifiers.filter((id) => id?.type === "CVE" && typeof id.value === "string" && Boolean(id.value)).map((id) => id.value);
+	return cves.length > 0 ? cves : void 0;
+}
+/**
 * 将 Dependabot API 的 `dependency.relationship` 映射为 `DependencyType`。
 *
 * GitHub API 返回的合法值:
@@ -421,8 +559,19 @@ function normalizeDependencyRelationship(relationship) {
 
 //#endregion
 //#region src/github/pr-creator.ts
-const BOT_NAME = "dependfix[bot]";
-const BOT_EMAIL = "dependfix[bot]@users.noreply.github.com";
+/**
+* PAT 路径默认 commit author（保持现有 PAT 路径用户行为零变化）。
+*
+* 注：此常量仅作为 PAT 路径的默认值；GitHub App 路径（M18.2 之后接入）走动态 commit author。
+* 现有 PAT 路径仍硬编码 `dependfix[bot]@users.noreply.github.com`，虽非真实 bot 身份（字符串约定），
+* 但保持行为不变以确保 PAT 用户无感升级。已知缺陷由 C22 范围之外的后续阶段修复。
+*
+* @see [C22 PAT 无感升级评估 §5.1 兼容性](../../../../docs/design/governance/c22-pat-backward-compat.md)
+*/
+const PAT_DEFAULT_COMMIT_AUTHOR = {
+	name: "dependfix[bot]",
+	email: "dependfix[bot]@users.noreply.github.com"
+};
 /** 自动修复分支统一前缀（分支名 = 前缀 + 内容指纹 8 位） */
 const BRANCH_PREFIX = "dependfix/auto-fix-";
 /**
@@ -518,14 +667,28 @@ function createFixBranch(branchName, workDir) {
 * 自动设置 git user.name / user.email（如未设置）。
 * 使用 `execFileSync` 参数数组形式（不经 shell），保证多行 commit message
 * 与 UTF-8 字符（如 →）在 Windows/Linux 双平台传递一致。
+*
+* W3 修复（M18.4 audit round 2）：显式传 `-c user.name=X -c user.email=Y` 强制 commit author
+* 使用传入值，不受 host 全局 `user.name`（如 CaoMeiYouRen）污染——`git commit` 走 lookup order
+* (env → `-c` config → local → global → system)，显式 `-c` 在 lookup order 中最高优先。
+*
+* @param author - 可选 commit author 信息；不传时使用 PAT 默认值（保持现有 PAT 路径行为零变化）。
+*   M18.2 之后 GitHub App 路径会传入动态生成的 `{app_id}+{bot_login}[bot]` author。
+*
+* @see [C22 PAT 无感升级评估 §5.1 兼容性](../../../../docs/design/governance/c22-pat-backward-compat.md)
 */
-function stageAndCommit(message, workDir) {
-	ensureGitConfig(workDir);
-	execSync("git add .", {
+function stageAndCommit(message, workDir, author) {
+	ensureGitConfig(workDir, author);
+	const effectiveAuthor = author ?? PAT_DEFAULT_COMMIT_AUTHOR;
+	execFileSync("git", ["add", "."], {
 		cwd: workDir,
 		stdio: "pipe"
 	});
 	execFileSync("git", [
+		"-c",
+		`user.name=${effectiveAuthor.name}`,
+		"-c",
+		`user.email=${effectiveAuthor.email}`,
 		"commit",
 		"-m",
 		message
@@ -534,9 +697,6 @@ function stageAndCommit(message, workDir) {
 		stdio: "pipe"
 	});
 }
-/**
-* 推送分支到远程 origin。
-*/
 function pushBranch(branchName, workDir) {
 	execFileSync("git", [
 		"push",
@@ -579,6 +739,38 @@ async function closePullRequest(octokit, owner, repo, pullNumber) {
 	});
 }
 /**
+* 在 Pull Request 上添加评论。
+*
+* 使用 `issues.createComment` 端点（GitHub PR 评论复用 issue comment API），
+* 需要 token 具备 `issues: write` 权限（比 `pull-requests: write` 宽）。
+*
+* 用于在新 PR 上评论指向被取代的旧 PR，避免用户手动排查重复 PR。
+*/
+async function commentOnPullRequest(octokit, owner, repo, pullNumber, body) {
+	await octokit.rest.issues.createComment({
+		owner,
+		repo,
+		issue_number: pullNumber,
+		body
+	});
+}
+/**
+* 在 Pull Request 上添加 label。
+*
+* 使用 `issues.addLabels` 端点（GitHub PR label 复用 issue label API），
+* 需要 token 具备 `issues: write` 权限。
+*
+* 用于标记重复 PR（如 `duplicate` label），便于用户过滤和管理。
+*/
+async function addLabelToPullRequest(octokit, owner, repo, pullNumber, labels) {
+	await octokit.rest.issues.addLabels({
+		owner,
+		repo,
+		issue_number: pullNumber,
+		labels
+	});
+}
+/**
 * 通过 GitHub API 创建 Pull Request。
 */
 async function createPullRequest(params) {
@@ -729,6 +921,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;
@@ -926,21 +1124,35 @@ function branchExists(branchName, workDir) {
 		return false;
 	}
 }
-function ensureGitConfig(workDir) {
+function ensureGitConfig(workDir, author) {
+	const effectiveAuthor = author ?? PAT_DEFAULT_COMMIT_AUTHOR;
 	const hasName = gitConfigExists("user.name", workDir);
 	const hasEmail = gitConfigExists("user.email", workDir);
-	if (!hasName) execSync(`git config user.name "${BOT_NAME}"`, {
+	if (!hasName) execFileSync("git", [
+		"config",
+		"user.name",
+		effectiveAuthor.name
+	], {
 		cwd: workDir,
 		stdio: "pipe"
 	});
-	if (!hasEmail) execSync(`git config user.email "${BOT_EMAIL}"`, {
+	if (!hasEmail) execFileSync("git", [
+		"config",
+		"user.email",
+		effectiveAuthor.email
+	], {
 		cwd: workDir,
 		stdio: "pipe"
 	});
 }
 function gitConfigExists(key, workDir) {
 	try {
-		execSync(`git config ${key}`, {
+		execFileSync("git", [
+			"config",
+			"--local",
+			"--get",
+			key
+		], {
 			cwd: workDir,
 			stdio: "pipe"
 		});
@@ -1045,6 +1257,7 @@ const DEPENDABOT_CONFIG_PATH = ".github/dependabot.yml";
 * 2. topic 过滤（`--repo-topics`，AND 语义）
 * 3. 名单策略过滤（include / exclude / topicsExclude，探测前应用）
 * 4. dependabot.yml 探测（仅候选仓库触达 contents API；404 视为不支持，不剔除）
+* 5. 规模上限截断（`maxRepos`，按 fullName 字典序排序后截断）
 *
 * 结果按 `fullName` 字典序排序，保证同输入多次运行结果一致
 * （runId / 指纹稳定性前提）。
@@ -1052,7 +1265,7 @@ const DEPENDABOT_CONFIG_PATH = ".github/dependabot.yml";
 * @throws AppError（mapGitHubError 转换；token 权限、网络等全局性问题 fail-fast）
 */
 async function discoverRepositories(options) {
-	const { client, owners, topics = [], policy, probeDependabot = true, probeConcurrency = 5 } = options;
+	const { client, owners, topics = [], policy, probeDependabot = true, probeConcurrency = 5, maxRepos } = options;
 	const discovered = [];
 	for (const owner of owners) {
 		const repos = await fetchOwnerRepositories(client, owner);
@@ -1083,6 +1296,8 @@ async function discoverRepositories(options) {
 	}
 	if (probeDependabot) await probeDependabotConfigs(client, discovered, probeConcurrency);
 	discovered.sort((a, b) => a.fullName.localeCompare(b.fullName));
+	const effectiveMaxRepos = maxRepos ?? 100;
+	if (effectiveMaxRepos > 0 && discovered.length > effectiveMaxRepos) return discovered.slice(0, effectiveMaxRepos);
 	return discovered;
 }
 /**
@@ -1166,6 +1381,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 +1618,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 +1700,7 @@ async function upgradeDependency(params) {
 			toVersion,
 			isMajor,
 			success: false,
-			error: `pnpm install failed: ${getStderr(installErr)}`
+			error: formatInstallFailure(getStderr(installErr))
 		};
 	}
 	cleanupBackups({
@@ -1478,13 +1787,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 +1948,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({
@@ -1895,7 +2205,7 @@ function isCrossMajorFixRequired(lockfilePath, alert) {
 */
 function classifyLockfileFailure(workDir) {
 	try {
-		execSync("pnpm install --frozen-lockfile", {
+		execFileSync("pnpm", ["install", "--frozen-lockfile"], {
 			cwd: workDir,
 			stdio: "pipe",
 			timeout: 12e4
@@ -1921,6 +2231,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]
 ];
 /**
@@ -1936,8 +2247,8 @@ function getStderrText(err) {
 	if (typeof err.stderr === "string") return err.stderr;
 	return err.stderr.toString("utf-8");
 }
-function execRepair(command, workDir, timeoutMs = 18e4) {
-	execSync(command, {
+function execRepair(binary, args, workDir, timeoutMs = 18e4) {
+	execFileSync(binary, args, {
 		cwd: workDir,
 		stdio: "pipe",
 		timeout: timeoutMs
@@ -1966,6 +2277,7 @@ function getStrategyChain(category) {
 			"FIX_ENTRIES",
 			"REINSTALL"
 		];
+		case "MINIMUM_RELEASE_AGE": return ["REGENERATE", "REINSTALL"];
 		case "UNKNOWN": return ["REGENERATE", "REINSTALL"];
 		case "CREDENTIAL_ERROR": return [];
 	}
@@ -1976,14 +2288,43 @@ function getStrategyChain(category) {
 *   （corepack 不可用/下载失败时命令本身失败 → 策略链 REGENERATE/REINSTALL 兜底，
 *   行为不劣于现状）
 * - `pnpmVersion` 缺省：回退裸 `pnpm install --lockfile-only`（保持旧 stub 语义）
+*
+* 返回 `{ binary, args }` 而非完整 shell 命令字符串，便于 `execFileSync` 参数化调用
+* 避免 shell 解释（`execSync` 模板拼接是 Code Scanning 命令注入告警源头）。所有
+* 参数均受 `isValidPnpmVersion` 白名单约束，无 shell metacharacter。
 */
 function getStrategyCommand(strategy, pnpmVersion) {
 	switch (strategy) {
-		case "REGENERATE": return "pnpm install --lockfile-only";
-		case "FIX_ENTRIES": return "pnpm install --fix-lockfile --lockfile-only";
-		case "REINSTALL": return "pnpm install --no-frozen-lockfile";
-		case "PIN_TOOLCHAIN": return pnpmVersion ? `corepack pnpm@${pnpmVersion} install --lockfile-only` : "pnpm install --lockfile-only";
-		default: return "";
+		case "REGENERATE": return {
+			binary: "pnpm",
+			args: ["install", "--lockfile-only"]
+		};
+		case "FIX_ENTRIES": return {
+			binary: "pnpm",
+			args: [
+				"install",
+				"--fix-lockfile",
+				"--lockfile-only"
+			]
+		};
+		case "REINSTALL": return {
+			binary: "pnpm",
+			args: ["install", "--no-frozen-lockfile"]
+		};
+		case "PIN_TOOLCHAIN":
+			if (!pnpmVersion) return {
+				binary: "pnpm",
+				args: ["install", "--lockfile-only"]
+			};
+			return {
+				binary: "corepack",
+				args: [
+					`pnpm@${pnpmVersion}`,
+					"install",
+					"--lockfile-only"
+				]
+			};
+		default: return null;
 	}
 }
 /** 从 lockfile 内容提取 `lockfileVersion` 字段值（如 `9.0`）；缺失返回 null。 */
@@ -2034,7 +2375,7 @@ function countLockfilePackages(path) {
 }
 /**
 * pnpm 版本白名单格式（安全加固：拒绝不可信 packageManager/config 的任意字符串，
-* 防命令注入——corepack 命令是唯一动态拼接的 execSync 命令）。
+* 防命令注入——corepack 命令参数 `pnpm@<version>` 受 PNPM_VERSION_RE 白名单约束）。
 * 兼容标准 semver 与 corepack 哈希后缀（pnpm@10.5.2+sha512.xxx）。
 */
 const PNPM_VERSION_RE = /^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/;
@@ -2068,7 +2409,7 @@ const LOCKFILE_NAME = "pnpm-lock.yaml";
 */
 function verifyFrozenLockfile(workDir) {
 	try {
-		execSync("pnpm install --frozen-lockfile", {
+		execFileSync("pnpm", ["install", "--frozen-lockfile"], {
 			cwd: workDir,
 			stdio: "pipe",
 			timeout: 12e4
@@ -2154,12 +2495,14 @@ function repairLockfile(params) {
 	let lastError = stderr;
 	const startTimestamp = Date.now();
 	for (const strategy of strategyChain) {
-		const command = getStrategyCommand(strategy, pnpmVersion);
+		const cmd = getStrategyCommand(strategy, pnpmVersion);
+		if (!cmd) continue;
+		const command = [cmd.binary, ...cmd.args].join(" ");
 		const t0 = Date.now();
 		let strategySuccess = false;
 		let strategyError;
 		try {
-			execRepair(command, workDir_);
+			execRepair(cmd.binary, cmd.args, workDir_);
 			strategySuccess = true;
 		} catch (err) {
 			strategyError = getStderrText(err) || err.message;
@@ -2205,7 +2548,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,11 +2795,13 @@ const DEFAULT_RUNTIME_CONFIG = {
 	severityThreshold: "high",
 	alertSource: "github-dependabot",
 	codeScanningEnabled: false,
+	codeQualityEnabled: false,
 	allowMajorUpgrade: false,
 	maxAlertsPerRepository: 20,
 	maxConcurrency: 1,
 	maxRetries: 3,
 	maxBackoffMs: 3e4,
+	maxRepos: 100,
 	ai: {
 		enabled: false,
 		provider: "openai-compatible",
@@ -2577,10 +2922,12 @@ 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`),
 		maxBackoffMs: normalizeInteger(readEnv(env, "MAX_BACKOFF_MS"), `${ENV_PREFIX}MAX_BACKOFF_MS`),
+		maxRepos: normalizeNonNegativeInteger(readEnv(env, "MAX_REPOS"), `${ENV_PREFIX}MAX_REPOS`),
 		upgradeGroups: normalizeUpgradeGroups(readEnv(env, "UPGRADE_GROUPS")),
 		toolchainPnpmVersion: readEnv(env, "TOOLCHAIN_PNPM_VERSION")?.trim() || void 0,
 		aiEnabled: normalizeBoolean(readEnv(env, "AI"), `${ENV_PREFIX}AI`),
@@ -2635,10 +2982,13 @@ function validateRuntimeConfig(config) {
 	if (isAuditSource && config.owner && config.owner.length > 0) throw new AppError("CONFIG_VALIDATION_ERROR", "--owner / DEPENDFIX_OWNER requires the github-dependabot alert source (owner discovery uses the GitHub API).");
 	if (config.mode === "cleanup-branches" && config.owner && config.owner.length > 0) throw new AppError("CONFIG_VALIDATION_ERROR", "--owner / DEPENDFIX_OWNER is not supported in cleanup-branches mode (branch cleanup requires explicit target repositories).");
 	if (config.mode === "cleanup-branches" && config.maxConcurrency > 1) throw new AppError("CONFIG_VALIDATION_ERROR", "maxConcurrency > 1 is not supported in cleanup-branches mode (branch cleanup runs sequentially).");
-	if (config.repositories.length === 0 && !(config.owner && config.owner.length > 0)) if (isAuditSource) {} else throw new AppError("CONFIG_VALIDATION_ERROR", "Missing target repositories. Provide --repo, --repository, --repos-file, --owner or DEPENDFIX_REPOSITORIES / DEPENDFIX_OWNER.");
+	if (config.repositories.length === 0 && !(config.owner && config.owner.length > 0)) {
+		if (isAuditSource) {} else throw new AppError("CONFIG_VALIDATION_ERROR", "Missing target repositories. Provide --repo, --repository, --repos-file, --owner or DEPENDFIX_REPOSITORIES / DEPENDFIX_OWNER.");
+	}
 	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,11 +3031,13 @@ 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,
 		maxRetries: cliOverrides.maxRetries ?? envConfig.maxRetries ?? DEFAULT_RUNTIME_CONFIG.maxRetries,
 		maxBackoffMs: cliOverrides.maxBackoffMs ?? envConfig.maxBackoffMs ?? DEFAULT_RUNTIME_CONFIG.maxBackoffMs,
+		maxRepos: cliOverrides.maxRepos ?? envConfig.maxRepos ?? DEFAULT_RUNTIME_CONFIG.maxRepos,
 		upgradeGroups: cliOverrides.upgradeGroups ?? envConfig.upgradeGroups,
 		toolchainPnpmVersion: cliOverrides.toolchainPnpmVersion ?? envConfig.toolchainPnpmVersion,
 		ai: resolveAiOptions(cliOverrides, envConfig)
@@ -2898,14 +3250,279 @@ function formatHistory(entries, repo) {
 }
 
 //#endregion
-//#region src/runners/verification-runner.ts
-const DEFAULT_COMMANDS = [
-	"pnpm install --frozen-lockfile",
-	"pnpm lint",
+//#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 = [
+	"pnpm install --frozen-lockfile",
+	"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 +3534,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 +3556,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 +3655,7 @@ function execCommand(command, workDir) {
 			stderrChunks.push(data.toString("utf-8"));
 		});
 		cp.on("error", (err) => {
+			clearTimeout(timer);
 			resolve({
 				command,
 				exitCode: -1,
@@ -2981,18 +3665,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");
@@ -3122,15 +3826,19 @@ function restoreTrackedFiles(workDir, snapshot) {
 	}
 }
 /**
-* 快速验证（逐包）：仅运行 `pnpm lint`（脚本存在时）。
+* 快速验证（逐包）：运行验证命令序列。
 *
-* 完整验证（install + lint + build）成本高，逐包执行不现实；
-* lint 是依赖兼容性的快速信号（本次坏 PR 即因 lint 失败）。
-* 无 lint 脚本时视为通过（与 verifyProject 的跳过语义一致）。
+* 有自定义命令时执行完整序列（含 install + setup + lint + build），
+* 否则仅运行 `pnpm lint`（脚本存在时）。
+*
+* 设计决策（run 33946113272 复盘）：旧版仅跑 `pnpm lint`，但 Nuxt 等框架
+* 项目 lint 依赖 `nuxt prepare` 生成的 `.nuxt/tsconfig.json`——无 prepare
+* 步骤会导致 ESLint OOM。自定义命令已含 prepare，走完整序列可避免此问题；
+* `pnpm install` 在 node_modules 已就绪时近乎空操作，性能影响可忽略。
 */
 async function quickVerifyProject(ctx, repo) {
-	const { logger, workDir } = ctx;
-	const { valid, skipped } = validateVerifyCommands(["pnpm lint"], workDir);
+	const { logger, workDir, customCommands } = ctx;
+	const { valid, skipped } = validateVerifyCommands(customCommands ?? ["pnpm lint"], workDir);
 	if (valid.length === 0) {
 		if (skipped.length > 0) logger.info(`[quick-verify] ${repo}: no lint script, skipping per-package verification`);
 		return true;
@@ -3596,10 +4304,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 +4357,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） */
@@ -3663,6 +4379,12 @@ function parseLegacyAuditReport(report) {
 	const advisories = report.advisories;
 	if (!advisories || typeof advisories !== "object") return [];
 	const actionMap = /* @__PURE__ */ new Map();
+	const advisoryExtrasMap = /* @__PURE__ */ new Map();
+	for (const [id, rawAdvisory] of Object.entries(advisories)) {
+		if (!rawAdvisory || typeof rawAdvisory !== "object") continue;
+		const extras = extractIdentifiers(rawAdvisory);
+		if (extras.ghsaId || extras.cveIds && extras.cveIds.length > 0) advisoryExtrasMap.set(id, extras);
+	}
 	for (const action of toArray(report.actions)) {
 		if (!action || typeof action !== "object") continue;
 		const record = action;
@@ -3674,13 +4396,15 @@ function parseLegacyAuditReport(report) {
 		if (!rawAdvisory || typeof rawAdvisory !== "object") continue;
 		const advisory = rawAdvisory;
 		const patched = normalizePatchedVersionValue(actionMap.get(id) ?? (typeof advisory.patched_versions === "string" ? advisory.patched_versions : void 0));
+		const extras = advisoryExtrasMap.get(id);
 		risks.push({
 			advisoryId: resolveAdvisoryId(advisory),
 			packageName: typeof advisory.module_name === "string" ? advisory.module_name : "unknown-package",
 			severity: typeof advisory.severity === "string" ? advisory.severity : "medium",
 			title: typeof advisory.title === "string" ? advisory.title : "Untitled advisory",
 			htmlUrl: typeof advisory.url === "string" ? advisory.url : "",
-			patchedVersion: patched
+			patchedVersion: patched,
+			...extras ?? {}
 		});
 	}
 	return risks;
@@ -3705,26 +4429,30 @@ function parseModernAuditReport(report) {
 		})();
 		const viaItems = toArray(vulnerability.via).filter((item) => item !== null && typeof item === "object");
 		if (viaItems.length === 0) {
+			const extras = extractIdentifiers(vulnerability);
 			risks.push({
 				advisoryId: resolveAdvisoryId(vulnerability),
 				packageName,
 				severity: typeof vulnerability.severity === "string" ? vulnerability.severity : "medium",
 				title: typeof vulnerability.title === "string" ? vulnerability.title : `${packageName} vulnerability`,
 				htmlUrl: typeof vulnerability.url === "string" ? vulnerability.url : "",
-				patchedVersion: patchedFromFixAvailable
+				patchedVersion: patchedFromFixAvailable,
+				...extras ?? {}
 			});
 			continue;
 		}
 		for (const advisory of viaItems) {
 			let severity = typeof vulnerability.severity === "string" ? vulnerability.severity : "medium";
 			if (typeof advisory.severity === "string" && advisory.severity) severity = advisory.severity;
+			const extras = extractIdentifiers(advisory);
 			risks.push({
 				advisoryId: resolveAdvisoryId(advisory),
 				packageName: typeof advisory.name === "string" && advisory.name ? advisory.name : packageName,
 				severity,
 				title: typeof advisory.title === "string" ? advisory.title : `${packageName} vulnerability`,
 				htmlUrl: typeof advisory.url === "string" ? advisory.url : "",
-				patchedVersion: patchedFromFixAvailable
+				patchedVersion: patchedFromFixAvailable,
+				...extras ?? {}
 			});
 		}
 	}
@@ -3758,13 +4486,34 @@ function parseAuditReport(report) {
 	return [...deduped.values()];
 }
 /**
-* advisoryId 的稳定数字哈希（`NormalizedSecurityAlert.id` 为 number）。
+* advisoryId 的稳定数字哈希（M20 之前使用，M20 后保留以维持向后兼容 `NormalizedSecurityAlert.id: number`）。
+*
 * 取 sha256 前 4 字节完整 uint32（非设计稿的 `% 2^31`：uint32 语义更自然，
 * 碰撞概率 ~2^-32/对，12 条告警场景生日界 ~1.6e-8，可忽略）。
+*
+* M20 弃用：唯一去重键改为 `upstreamId`，详见 [`normalizeUpstreamId`](../../../core/src/alerts/upstream-id.ts)。
+* 本函数保留仅为兼容现有 `NormalizedSecurityAlert.id: number` 字段，**不是**平台去重键。
 */
 function hashAdvisoryId(packageName, advisoryId) {
 	return createHash("sha256").update(`${packageName}:${advisoryId}`).digest().readUInt32BE(0);
 }
+/**
+** M23.3 C66-A2：从 pnpm audit advisory 提取 GHSA ID + CVE 列表。
+** 兼容 legacy `github_advisory_id` + modern `advisory.github_advisory_id` 与 `cves[]`。
+*/
+function extractIdentifiers(candidate) {
+	const ghsaId = typeof candidate.github_advisory_id === "string" && candidate.github_advisory_id ? candidate.github_advisory_id : void 0;
+	const cves = candidate.cves;
+	let cveIds;
+	if (Array.isArray(cves)) {
+		const valid = cves.filter((c) => typeof c === "string" && Boolean(c));
+		if (valid.length > 0) cveIds = valid;
+	}
+	const result = {};
+	if (ghsaId) result.ghsaId = ghsaId;
+	if (cveIds) result.cveIds = cveIds;
+	return result;
+}
 /** audit 风险 → 标准化告警（source='pnpm-audit'，repository 由调用方注入） */
 function mapAuditRiskToAlert(risk, repository) {
 	const fixable = risk.patchedVersion !== null;
@@ -3783,7 +4532,13 @@ function mapAuditRiskToAlert(risk, repository) {
 		fixable,
 		fixStrategy: fixable ? "upgrade" : null,
 		recommendedVersion: risk.patchedVersion ?? "",
-		dependencyType: void 0
+		dependencyType: void 0,
+		upstreamId: normalizeUpstreamId("pnpm-audit", {
+			packageName: risk.packageName,
+			advisoryId: risk.advisoryId
+		}),
+		ghsaId: risk.ghsaId,
+		cveIds: risk.cveIds
 	};
 }
 
@@ -4314,6 +5069,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 +5453,105 @@ 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 = [
@@ -4549,7 +5577,7 @@ function resolveAlertRepositories(ctx) {
 	return ["local"];
 }
 /** 自动修复提交的兜底标题（无成功升级 / 包名超长无法生成动态标题时） */
-const FIX_COMMIT_MESSAGE = "fix(deps): automated dependfix security repair";
+const FIX_COMMIT_MESSAGE = "chore(deps): automated dependfix security repair";
 /** commitlint header-max-length 上限（commitlint-config-cmyr 覆盖为 140） */
 const COMMIT_HEADER_MAX_LENGTH = 140;
 /**
@@ -4575,15 +5603,15 @@ function buildCommitTitle(upgrades) {
 		const a = upgrades[0];
 		const from = a.fromVersion && a.fromVersion !== "unknown" ? ` from ${a.fromVersion}` : "";
 		const to = a.toVersion ? ` to ${a.toVersion}` : "";
-		const title = `fix(deps): bump ${a.target}${from}${to}`;
+		const title = `chore(deps): bump ${a.target}${from}${to}`;
 		return title.length <= COMMIT_HEADER_MAX_LENGTH ? title : FIX_COMMIT_MESSAGE;
 	}
 	const names = upgrades.map((a) => a.target);
-	const full = `fix(deps): bump ${names.join(", ")}`;
+	const full = `chore(deps): bump ${names.join(", ")}`;
 	if (full.length <= COMMIT_HEADER_MAX_LENGTH) return full;
 	let count = names.length - 1;
 	while (count > 0) {
-		const candidate = `fix(deps): bump ${names.slice(0, count).join(", ")} and ${names.length - count} more`;
+		const candidate = `chore(deps): bump ${names.slice(0, count).join(", ")} and ${names.length - count} more`;
 		if (candidate.length <= COMMIT_HEADER_MAX_LENGTH) return candidate;
 		count--;
 	}
@@ -4623,6 +5651,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 推荐版本不同），按大版本分组取各线
@@ -4733,17 +5774,47 @@ async function upgradeAlert(ctx, alert) {
 }
 /**
 * 执行 Code Scanning 模板修复（2.0 节；从 app/index.ts 提取以控制文件行数）。
-* 仅处理 A 类告警；逐告警：快照 → 应用模板 → quickVerify（lint）→ 失败回滚（不静默）。
+* 仅处理 A 类告警；按批处理（默认每 10 个告警跑一次 lint）：快照 → 应用模板 → 累积到批 → 批满跑 lint → 失败回滚整批（不静默）。
 * - 快照失败 / 无模板 / 模板不适用 / 缺文件 → noOp 动作（回退建议模式，展示；
 *   error 原因可审计，不计 failed 避免陈旧告警永久 exit 1/2）
-* - 写盘失败 / lint 验证失败 → failed（回滚并记录；回滚失败时注明 file may be modified）
+* - 写盘失败 → 立即失败（不计 lint）+ 整批回滚
+* - lint 验证失败 → 整批回滚（粒度 = batchSize；vs 旧版每个告警回滚，回滚粒度变粗但 lint 提速 ~10x）
+*
+* 性能权衡（M28.2 实证）：
+* - N 个 cs 告警（旧版）→ N 次 spawn `pnpm lint` 子进程：N=100 平均 2593 ms（基准 commit 395ee29）
+* - N 个 cs 告警（批处理）→ ceil(N/batchSize) 次 lint：N=100 平均 ~300 ms（提速 ~10x）
+* - 合并验证可提速 ~96x 但回滚粒度过粗（整次 fix 全失败）；批处理折中
+*
 * @returns 本批次实际修复数（fixed）与失败数（failed），调用方累加到仓库统计
 */
-async function runCodeScanningFixes(ctx, repo, alerts) {
+async function runCodeScanningFixes(ctx, repo, alerts, options = {}) {
 	const { config, workDir, logger } = ctx;
+	const batchSize = options.batchSize ?? DEFAULT_CS_BATCH_SIZE;
 	const codeScanningAutoFixable = alerts.filter((a) => a.source === "code-scanning" && a.alertClass === "auto-fixable");
 	let fixed = 0;
 	let failed = 0;
+	/** 待 lint 批：每条保留 sourceSnapshot + action 用于 lint 失败时整批回滚 */
+	const pendingBatch = [];
+	/**
+	* 处理当前批：跑 lint + 按结果分发 fixed/failed + 回滚（lint 失败时）。
+	*/
+	const flushBatch = async () => {
+		if (pendingBatch.length === 0) return;
+		if (await quickVerifyProject(ctx, repo)) for (const item of pendingBatch) {
+			ctx.allActions.push(item.action);
+			fixed++;
+			logger.info(`[code-scanning] ${item.csAlert.ruleId}: ${item.action.diff}`);
+		}
+		else for (const item of pendingBatch) {
+			const restored = restoreSourceFile(workDir, item.sourceSnapshot);
+			item.action.success = false;
+			item.action.error = restored ? "lint failed after code-scanning fix; changes rolled back" : "lint failed after code-scanning fix; rollback failed, file may be modified";
+			ctx.allActions.push(item.action);
+			failed++;
+			logger.warn(`[code-scanning] ${item.csAlert.ruleId} fix rolled back: lint failed`);
+		}
+		pendingBatch.length = 0;
+	};
 	for (const csAlert of codeScanningAutoFixable) {
 		const sourceSnapshot = snapshotSourceFile(workDir, csAlert.manifestPath);
 		if (!sourceSnapshot) {
@@ -4784,24 +5855,30 @@ async function runCodeScanningFixes(ctx, repo, alerts) {
 			ctx.allActions.push(action);
 			continue;
 		}
-		if (!await quickVerifyProject(ctx, repo)) {
-			const restored = restoreSourceFile(workDir, sourceSnapshot);
-			action.success = false;
-			action.error = restored ? "lint failed after code-scanning fix; changes rolled back" : "lint failed after code-scanning fix; rollback failed, file may be modified";
-			ctx.allActions.push(action);
-			failed++;
-			logger.warn(`[code-scanning] ${csAlert.ruleId} fix rolled back: lint failed`);
-			continue;
-		}
-		ctx.allActions.push(action);
-		fixed++;
-		logger.info(`[code-scanning] ${csAlert.ruleId}: ${action.diff}`);
+		pendingBatch.push({
+			csAlert,
+			sourceSnapshot,
+			action
+		});
+		if (pendingBatch.length >= batchSize) await flushBatch();
 	}
+	await flushBatch();
 	return {
 		fixed,
 		failed
 	};
 }
+/**
+* Code Scanning 修复批处理默认大小（M28.2 决策）。
+*
+* 决策依据（commit 395ee29 baseline）：
+* - 旧版（每个告警 1 次 lint）：N=10 平均 263 ms / N=50 平均 1294 ms / N=100 平均 2593 ms
+* - 批处理 batchSize=10：N=10 触发 1 次 lint（vs 旧版 10 次 → 提速 ~10x）
+* - 回滚粒度 = batchSize（vs 旧版每个告警独立回滚）
+*
+* 经验值：典型 cs 告警场景 5-50 个 / repo，batchSize=10 平衡 lint 提速 + 回滚粒度。
+*/
+const DEFAULT_CS_BATCH_SIZE = 10;
 /** 尝试修复 pnpm-lock.yaml（dry-run 仅记录）。 */
 function tryLockfileRepair(ctx, repo) {
 	const { config, logger, workDir } = ctx;
@@ -4871,10 +5948,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 {
@@ -4967,98 +6057,7 @@ function buildPrTitle(summary, actions) {
 	const parts = [];
 	if (upgrades > 0) parts.push(`${upgrades} upgrade${upgrades > 1 ? "s" : ""}`);
 	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;
+	return parts.length > 0 ? `chore(deps): automated security fix — ${parts.join(", ")}` : "chore(deps): automated security fix";
 }
 
 //#endregion
@@ -5066,7 +6065,9 @@ function computeExitCode(ctx) {
 /**
 * 告警数据源统一入口：
 * - `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 +6082,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);
@@ -5095,18 +6103,32 @@ async function fetchRepoAlerts(deps, repo) {
 		failedSources.push("dependabot");
 		recordAlertSourceError(deps, repo, "dependabot", dependabotResult.reason);
 	}
-	if (config.codeScanningEnabled) if (codeScanningResult.status === "fulfilled") {
-		alerts.push(...codeScanningResult.value);
-		deps.logger.info(`Fetched ${codeScanningResult.value.length} code scanning alerts for ${repo}`);
-	} else {
-		failedSources.push("code-scanning");
-		recordAlertSourceError(deps, repo, "code-scanning", codeScanningResult.reason);
+	if (config.codeScanningEnabled) {
+		if (codeScanningResult.status === "fulfilled") {
+			alerts.push(...codeScanningResult.value);
+			deps.logger.info(`Fetched ${codeScanningResult.value.length} code scanning alerts for ${repo}`);
+		} else {
+			failedSources.push("code-scanning");
+			recordAlertSourceError(deps, repo, "code-scanning", codeScanningResult.reason);
+		}
+	}
+	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);
+		}
 	}
-	const totalSources = config.codeScanningEnabled ? 2 : 1;
+	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;
 	}
@@ -5119,23 +6141,21 @@ async function fetchRepoAlerts(deps, repo) {
 * 背景详见 docs/plan/todo.md「已知缺口 G2」。
 */
 function createAlertsClientFromConfig(config) {
-	return createGitHubClient({
-		token: config.alertsToken || config.githubToken,
-		retry: {
-			maxRetries: config.maxRetries,
-			maxBackoffMs: config.maxBackoffMs
-		}
-	});
+	return createGitHubClient({ auth: fromPat(config.alertsToken || config.githubToken, { retry: {
+		maxRetries: config.maxRetries,
+		maxBackoffMs: config.maxBackoffMs
+	} }) });
 }
 /** 记录单个告警源的拉取失败（不中断另一源的处理）。 */
 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,
 		stage: "fetch",
 		category: "FETCH_FAILED",
+		source,
 		message: hint ? `${message}（${hint}）` : message
 	});
 }
@@ -5840,7 +6860,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 +6881,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,
@@ -6235,6 +7255,35 @@ async function finalizeRepoFix(ctx, repo, progress) {
 
 //#endregion
 //#region src/app/index.ts
+/**
+* 输出"部分源拉取失败"汇总（todo.md §M19.5 C8 per-source 错误隔离）。
+*
+* 触发条件（必须全部满足，避免与"全部源失败"语义重叠）：
+* 1. allErrors 至少包含一个 `stage='fetch' + category='FETCH_FAILED'` 错误（per-source 失败）
+* 2. **至少一个仓库成功拉取了部分告警**（isAnyRepoSuccessful = true）——
+*    否则就是"全部源失败"语义，已由 processRepoForReport catch + logger.error 单独处理，
+*    本函数聚焦"warn + 保留成功源"场景的汇总输出，避免重复提示。
+*
+* 汇总按 source 分组（'dependabot' / 'code-scanning' / 'code-quality' / 'pnpm-audit'），
+* 列出每个源失败的仓库数 + 示例错误消息，便于用户快速定位是 token 权限还是网络问题。
+*/
+function logPartialSourceFailureSummary(allErrors, logger, isAnyRepoSuccessful) {
+	const fetchErrors = allErrors.filter((e) => e.stage === "fetch" && e.category === "FETCH_FAILED");
+	if (fetchErrors.length === 0) return;
+	if (!isAnyRepoSuccessful) return;
+	const bySource = /* @__PURE__ */ new Map();
+	for (const err of fetchErrors) {
+		const source = err.source ?? "unknown";
+		const existing = bySource.get(source);
+		if (existing) existing.repos.add(err.repository);
+		else bySource.set(source, {
+			repos: /* @__PURE__ */ new Set([err.repository]),
+			sampleMessage: err.message
+		});
+	}
+	const summary = [...bySource.entries()].map(([source, { repos, sampleMessage }]) => `${source}（${repos.size} 个仓库: ${[...repos].slice(0, 3).join(", ")}${repos.size > 3 ? "..." : ""}）: ${sampleMessage}`).join("\n  - ");
+	logger.warn(`[alerts] 部分源拉取失败（M19.5 per-source 错误隔离）— 成功源已保留继续处理，详细如下：\n  - ${summary}`);
+}
 var DependfixApp = class {
 	config;
 	workDir;
@@ -6242,6 +7291,7 @@ var DependfixApp = class {
 	logger;
 	verbose;
 	customCommands;
+	executionEnvironment;
 	runId;
 	allAlerts = [];
 	allActions = [];
@@ -6260,11 +7310,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({
+		this.logger = options.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 +7346,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 +7366,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);
@@ -6325,11 +7387,27 @@ var DependfixApp = class {
 			const costText = u.estimatedCostUsd !== void 0 ? `, 估算成本 $${u.estimatedCostUsd.toFixed(4)}` : "";
 			this.logger.info(`[ai] run 总计: ${u.calls} 次调用, ${u.inputTokens} in / ${u.outputTokens} out tokens${costText}`);
 		}
+		const isAnyRepoSuccessful = this.repoResults.some((r) => r.alertsCount > 0 || r.fixed > 0 || r.verificationPassed === true);
+		logPartialSourceFailureSummary(this.allErrors, this.logger, isAnyRepoSuccessful);
 		return {
 			result: runResult,
 			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 +7562,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({
@@ -6507,6 +7586,7 @@ var DependfixApp = class {
 				success: true,
 				durationMs: 0
 			});
+			await this.handleDuplicatePRs(client, owner, repo, pr.number, plan.supersedePRs);
 			await closeSupersededPRs(this.ctx, client, owner, repo, plan.supersedePRs);
 		} catch (error) {
 			const message = toErrorMessage(error);
@@ -6533,6 +7613,41 @@ var DependfixApp = class {
 		for (const repo of this.config.repositories) await runBranchCleanupForRepo(this.ctx, client, repo);
 	}
 	/**
+	* 重复 PR 处理：在新 PR 上添加评论指向被取代的旧 PR + 添加 `duplicate` label。
+	*
+	* 失败仅记录 warning（家务活 best-effort），不阻断主流程：
+	* - 新 PR 已创建成功，用户已可访问
+	* - 评论失败不影响 PR 本身的可用性
+	* - 但需要 `issues: write` token scope（比 `pull-requests: write` 宽）；
+	*   若 token 权限不足，error 会被记录但不阻塞
+	*/
+	async handleDuplicatePRs(client, owner, repo, newPRNumber, supersededPRs) {
+		if (supersededPRs.length === 0) return;
+		const commentBody = [
+			"## ⚠️ Duplicate PR Notice",
+			"",
+			"This PR supersedes the following dependfix PR(s) with different content:",
+			"",
+			supersededPRs.map((pr) => `- [#${pr.number}](${pr.htmlUrl})`).join("\n"),
+			"",
+			"The superseded PR(s) have been closed. Please review this PR as the new canonical fix."
+		].join("\n");
+		try {
+			await commentOnPullRequest(client, owner, repo, newPRNumber, commentBody);
+			this.logger.info(`Added duplicate notice comment to PR #${newPRNumber}`);
+		} catch (error) {
+			const message = toErrorMessage(error);
+			this.logger.warn(`Failed to add duplicate notice comment to PR #${newPRNumber}: ${message}（token may lack \`issues: write\` scope）`);
+		}
+		try {
+			await addLabelToPullRequest(client, owner, repo, newPRNumber, ["duplicate"]);
+			this.logger.info(`Added 'duplicate' label to PR #${newPRNumber}`);
+		} catch (error) {
+			const message = toErrorMessage(error);
+			this.logger.warn(`Failed to add 'duplicate' label to PR #${newPRNumber}: ${message}（token may lack \`issues: write\` scope）`);
+		}
+	}
+	/**
 	* 多仓库并发执行管线。
 	*
 	* - 并发窗口 = config.maxConcurrency（默认 1 保守串行，行为与现状一致）
@@ -6592,7 +7707,8 @@ var DependfixApp = class {
 				client,
 				owners: owner,
 				topics: this.config.repoTopics,
-				policy
+				policy,
+				maxRepos: this.config.maxRepos
 			});
 			const explicitFiltered = filterExplicitRepositories(policy, this.config.repositories);
 			const merged = mergeRepositories(explicitFiltered, discovered.map((r) => r.fullName));
@@ -6616,16 +7732,13 @@ var DependfixApp = class {
 		return this.createClient();
 	}
 	createClient(token = this.config.githubToken) {
-		return createGitHubClient({
-			token,
-			retry: {
-				maxRetries: this.config.maxRetries,
-				maxBackoffMs: this.config.maxBackoffMs
-			}
-		});
+		return createGitHubClient({ auth: fromPat(token, { retry: {
+			maxRetries: this.config.maxRetries,
+			maxBackoffMs: this.config.maxBackoffMs
+		} }) });
 	}
 };
 
 //#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, addLabelToPullRequest, analyzeTokenScope, applyCodeScanningFix, applyVersionedOverrides, assessBreakingChange, buildPrTitle, buildUpgradeGroups, checkTokenPermissions, classifyLockfileFailure, classifyRule, closePullRequest, closeSupersededPRs, commentOnPullRequest, 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, logPartialSourceFailureSummary, 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