@zhushanwen/pi-permission 1.0.0 → 1.2.0

package/README.md

@@ -12,7 +12,6 @@ Pi permission 扩展 — 四档权限模式（yolo / auto / approve / strict）+
 - **AI Classifier**：auto 模式下用 LLM 评估未知命令风险（low/medium/high）
 - **用户审批 UI**：TUI（自定义 Component）/ RPC（select 对话框）/ headless（fail-closed deny）
 - **Reject-with-Reason**：用户拒绝时可输入真实理由（回传 agent 辅助理解）
-- **statusline 集成**：TUI 底部 footer 显示当前权限模式标签（通过 globalThis Symbol 握手协议向 statusline 注册一行 footer line renderer）
 - **fail-closed**：任何异常路径 → block（绝不静默放行）
 
 ## 安装
@@ -28,7 +27,7 @@ ln -s /path/to/xyz-pi-extensions-workspace/feat-permission-and-auto-mode/extensi
 
 ## 配置
 
-配置文件位置：`~/.pi/agent/permission-config.json`（首次运行自动创建默认配置）。
+配置文件位置：`<agentDir>/config/permission-ext-config.json`（`<agentDir>` = pi agent 目录，`PI_CODING_AGENT_DIR` 覆盖，默认 `~/.pi/agent`；首次运行自动创建默认配置）。
 
 可通过 `PI_CODING_AGENT_DIR` 环境变量覆盖基础路径。
 
@@ -54,7 +53,7 @@ ln -s /path/to/xyz-pi-extensions-workspace/feat-permission-and-auto-mode/extensi
 | `mode` | `"yolo"` | 当前权限模式（yolo/auto/approve/strict） |
 | `enabled` | `true` | 扩展是否启用（false=完全放行，等同 yolo 但保留配置） |
 | `classifier.enabled` | `true` | 是否启用 AI 层（auto 模式自动 true） |
-| `classifier.model` | `"auto"` | AI 模型（`auto` 选最便宜，或 `provider/model-id`） |
+| `classifier.model` | `"auto"` | AI 模型（`auto` = scoped：取 settings.json enabledModels 首个可用，或 `provider/model-id`） |
 | `classifier.timeout` | `90` | AI 分类超时秒数 |
 | `classifier.autoApproveLowRisk` | `true` | 低风险是否自动放行（false=转人工） |
 | `classifier.autoDenyHighRisk` | `true` | 高风险是否自动拦截（true=强制 deny） |
@@ -118,7 +117,7 @@ ln -s /path/to/xyz-pi-extensions-workspace/feat-permission-and-auto-mode/extensi
 |------|-------------|------|------|------|
 | 内置安全白名单 | `builtin-safe` | 50 无条件 + 9 条件 | 函数实现（`isKnownSafeCommand`），不进 `Rule[]` 数组 | 不可改 |
 | 内置危险规则 | `builtin-danger` | 12 条正则 | `BUILTIN_DANGER_RULES` 常量，代码硬编码 | 不可改 |
-| 用户自定义规则 | `user` | 任意 | `permission-config.json` 的 `userRules` 数组 | 可改 |
+| 用户自定义规则 | `user` | 任意 | `config/permission-ext-config.json` 的 `userRules` 数组 | 可改 |
 
 规则层在整个权限管道中的位置（auto / approve 模式）：
 
@@ -197,7 +196,7 @@ wc / whereis / who / whoami / which
 
 ### 4. 自定义规则（用户编辑指南）
 
-在 `~/.pi/agent/permission-config.json` 的 `userRules` 数组中添加。完整示例：
+在 `<agentDir>/config/permission-ext-config.json` 的 `userRules` 数组中添加。完整示例：
 
 ```json
 {
@@ -342,7 +341,7 @@ publish 规则在后，last-match-wins 时 deny 胜出。
 
 ### 10. 配置文件管理
 
-- **路径**：`~/.pi/agent/permission-config.json`，可用 `PI_CODING_AGENT_DIR` 环境变量覆盖基础目录
+- **路径**：`<agentDir>/config/permission-ext-config.json`（`<agentDir>` 可用 `PI_CODING_AGENT_DIR` 环境变量覆盖，默认 `~/.pi/agent`）
 - **首次创建**：扩展启动时若文件不存在，自动写入默认配置（`mode: "yolo"`、空 `userRules`）
 - **权限**：`0o600`（原子写：先写 `.tmp` 再 rename，避免半写状态）
 - **编辑方式**：目前需手动编辑 JSON 文件（未来计划提供 `/permission add-rule` 命令辅助编辑）
@@ -360,7 +359,7 @@ publish 规则在后，last-match-wins 时 deny 胜出。
 
 auto 模式下层 3 用 LLM 评估未知命令风险：
 
-- **模型**：`classifier.model`（`auto` 自动选最便宜，或指定 `provider/model-id`）
+- **模型**：`classifier.model`（`auto` = scoped：取 enabledModels 首个可用（空则 fallback available），或指定 `provider/model-id`）
 - **输出**：`risk_level`（low/medium/high）+ `outcome`（allow/deny/ask）+ `reasoning` + `confidence`
 - **override**（WT7 偏差补丁）：
   - `low + allow + autoApproveLowRisk=false` → 强制 `ask`（转人工）
@@ -371,7 +370,7 @@ auto 模式下层 3 用 LLM 评估未知命令风险：
 
 `/permission model` 弹出 overlay 选择 AI classifier 使用的模型，写回 `classifier.model`：
 
-- **第一级 provider 选择**：列出 `Auto`（自动选最便宜可用模型）+ 所有可用 provider（来自 `~/.pi/agent/models.json`，按字母序）。当前 `classifier.model` 预选高亮。
+- **第一级 provider 选择**：列出 `Auto`（自动：scoped 取 enabledModels 首个可用）+ 所有可用 provider（来自 `~/.pi/agent/models.json`，按字母序）。当前 `classifier.model` 预选高亮。
 - **第二级 model 选择**：选中具体 provider 后，列出该 provider 下所有可用 model（按 `cost.input` 升序，并列按 id 字母序）。`Esc` 回退到 provider 列表。
 - **键位**：`↑/↓` 导航、`Enter` 确认、`Esc` 取消（provider stage）或回退（model stage）。
 - **三模式分发**：
@@ -381,42 +380,8 @@ auto 模式下层 3 用 LLM 评估未知命令风险：
 - **无可用模型**：`models.json` 不存在 / 无 provider 配 `apiKey` / 解析失败时，`listAvailableModels` 返回空 Map，命令降级为提示 `No available models. Configure ~/.pi/agent/models.json first.`（不阻塞，不修改配置）。
 - **结果写回**：选中后 `classifier.model` 更新为 `auto` 或 `provider/model-id`，其余字段（mode/enabled/timeout/userRules）保留。
 
-## statusline 集成
-
-permission 不再自管 footer，而是通过 **globalThis Symbol 握手协议** 向 `@zhushanwen/pi-statusline` 注册一行 footer line renderer（`session_start` 时调用 `registerPermissionFooterLine`）：
-
-- **statusline 是 footer canonical owner**：唯一创建 footer registry（`getOrCreateFooterRegistry`）。
-- **permission 是 consumer**：永不创建 registry 实例，永不写 `slot.registry` 字段；只通过 `FOOTER_HANDSHAKE_KEY = Symbol.for('@zhushanwen/pi-statusline.footerHandshake')` 读写 slot。
-- **插入位置**：renderer `order=2`，聚合排序后落在 line2（model）和 line3（ctx）之间。
-- **加载顺序无关**：slot 形状 `{version, registry?, pending:[]}`。registry 未就绪时 consumer 只 push pending，等 statusline 后到时 flush（沿用 ask-user 的 pending-flush 修复模式）。
-- **无代码层 import**：permission 仅对 statusline 做运行时 `globalThis` 反射，statusline 是可选 `peerDep`，未安装时静态 import 不会破坏 permission。
-- **重绘触发**：mode/enabled 切换后调用 `requestFooterRender()`（`REQUEST_RENDER_KEY`），statusline 立即重绘 footer。
-
-footer line 内容（精简版，避免 footer 拥挤）：
-
-```
-[permission] Auto · enabled
-[permission] disabled
-```
-
-模式标签：YOLO / Auto / Approve / Strict（对应 yolo/auto/approve/strict）。
-
-**未安装 statusline 时 silent 降级**：permission 功能完整，仅 footer 不显示 mode 标签。可用 `/permission status` 查看 mode。
-
-## 升级须知
-
-**v0.0.1 → v0.1.0 breaking change**：本扩展不再自管 footer，权限模式标签现在由 `@zhushanwen/pi-statusline` 聚合提供（通过 globalThis Symbol 握手协议）。此前 footer 由各扩展各自调用 `ctx.ui.setFooter` 单例渲染、互相覆盖。
-
-- **同时安装 statusline 的用户**：无需任何操作。mode 标签自动作为 statusline footer 的一行出现（line2 和 line3 之间）。
-- **未安装 statusline 的用户**：footer 不再显示 mode 标签。两种恢复方式：
-  - 安装 statusline：`pi install npm:@zhushanwen/pi-statusline`，mode 标签回到 footer。
-  - 或随时用 `/permission status` 查看/切换 mode（不依赖 footer）。
-
-详见下方「statusline 集成」章节。
-
 ## 已知限制
 
-- **Footer 由 statusline 聚合**：本扩展不再自管 footer，mode 标签通过 globalThis Symbol 握手协议向 `@zhushanwen/pi-statusline` 注册（见「statusline 集成」）。未安装 statusline 时 footer 不显示 mode 标签（silent 降级，不影响功能）。
 - **TUI Reject-with-Reason**：当前 RPC 分支已完整接入 `ctx.ui.input` 采集拒绝理由；TUI 分支因 pi-tui Input 组件集成成本较高，暂保留简化 deny（固定文案），后续迭代补齐内联文本输入。
 - **headless 模式**：json/print 模式无交互 UI，所有审批请求 fail-closed deny（不阻塞自动化流程，但 strict/approve 模式下无法放行）。
 - **wasm 加载**：AST 分析依赖 tree-sitter-bash wasm，加载失败时 fail-closed（clean=false, parseError=true）。

package/package.json

@@ -1,12 +1,15 @@
 {
   "name": "@zhushanwen/pi-permission",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "Pi permission extension — four permission modes (yolo/auto/approve/strict) with three-layer pipeline (AST + rules + AI classifier).",
   "type": "module",
   "main": "src/index.ts",
   "pi": {
     "extensions": [
       "./index.ts"
+    ],
+    "skills": [
+      "./skills"
     ]
   },
   "keywords": [
@@ -20,31 +23,33 @@
   "license": "MIT",
   "files": [
     "src/",
+    "skills/",
     "index.ts"
   ],
   "dependencies": {
     "tree-sitter-bash": "^0.25.1",
-    "web-tree-sitter": "^0.26.11"
+    "web-tree-sitter": "^0.26.11",
+    "@zhushanwen/pi-llm-shared": "0.3.0"
   },
   "peerDependencies": {
     "@earendil-works/pi-ai": "*",
     "@earendil-works/pi-coding-agent": "*",
-    "@earendil-works/pi-tui": "*",
-    "@zhushanwen/pi-statusline": "*"
+    "@earendil-works/pi-tui": "*"
   },
   "peerDependenciesMeta": {
     "@earendil-works/pi-ai": {
       "optional": true
     },
-    "@earendil-works/pi-tui": {
+    "@earendil-works/pi-coding-agent": {
       "optional": true
     },
-    "@zhushanwen/pi-statusline": {
+    "@earendil-works/pi-tui": {
       "optional": true
     }
   },
   "devDependencies": {
     "@earendil-works/pi-ai": "*",
+    "@earendil-works/pi-coding-agent": "*",
     "@earendil-works/pi-tui": "*",
     "vitest": "^4.1.8"
   },

package/skills/permission-ext-config/SKILL.md

@@ -0,0 +1,151 @@
+---
+name: permission-ext-config
+description: "配置 @zhushanwen/pi-permission（四档权限模式 + AI 风险分类）时加载。含配置文件路径、PermissionConfig/ClassifierConfig schema、权限模式、classifier model、默认值、示例、userRules、enabled 反直觉行为、热重载。触发词：配置权限、permission 配置、权限模式、classifier model、permission.json、permission 配置文件、auto/approve/strict/yolo 模式、热重载、enabled。"
+---
+
+# permission 配置指南
+
+> @zhushanwen/pi-permission：四档权限模式（yolo/auto/approve/strict）+ 三层管道（AST 分析 + 规则匹配 + AI 风险分类）。
+
+## ⚠ 先看：`enabled` 字段的反直觉行为
+
+**`enabled: false` 不是「锁定/安全模式」，而是「扩展完全不介入」= 全部放行（等同 yolo，仅保留配置文件）。**
+
+想提高安全性，改 `mode`（`auto`/`approve`/`strict`），**不要**把 `enabled` 设 false。把 `enabled` 设 false 是最危险的误配置——用户以为关掉了扩展等于安全锁死，实际等于完全无防护。（源码：`pipeline.ts`「config.enabled=false 等同 yolo」）
+
+## 配置文件位置
+
+`<agentDir>/config/permission-ext-config.json`
+
+- `<agentDir>` = pi agent 目录（`PI_CODING_AGENT_DIR` 覆盖，默认 `~/.pi/agent`；xyz-agent 隔离环境为 `~/.xyz-agent/pi/agent`）
+- 走 llm-shared 泛型 config（config/ 子目录 + getAgentDir 派生 + mtime+size 缓存 + 原子写）
+- 文件缺失/坏 JSON 返回默认值，不抛错；首次加载自动创建默认配置文件
+- [HISTORICAL] 旧路径 `<agentDir>/permission-config.json`（agentDir 根）：**session_start hook 运行时迁移**到新路径（幂等，过渡性，Added in v1.0.0, remove after v2.0.0）
+
+## 热重载：改文件即生效
+
+配置走 **mtime+size 读时刷新（pull-based）**：每次权限检查（每个 tool_call）都 stat 文件，变了就读新配置，**无需重启 session**。
+
+- 在编辑器改 JSON 保存 → 下一次工具调用立即按新配置拦截
+- `/permission` 命令执行时也会读最新
+- 不要担心性能：文件没变时只做一次 `statSync`（metadata 读，不读文件内容），开销可忽略
+
+> 这是 llm-shared config 框架统一提供的热重载能力。早期版本曾用闭包缓存架空了它（同一 session 改文件不生效），已修复——现在每次 tool_call 直接读最新。
+
+## Schema
+
+```ts
+interface PermissionConfig {
+  mode: "yolo" | "auto" | "approve" | "strict";  // 权限模式，默认 "yolo"
+  enabled: boolean;                                 // 扩展总开关（false=全部放行，见上方警告），默认 true
+  classifier: ClassifierConfig;                     // AI 分类器配置（仅 auto 模式生效，见下）
+  userRules: Rule[];                                // 用户自定义规则
+}
+
+interface ClassifierConfig {
+  enabled: boolean;           // AI 层开关，默认 true
+  model: string;              // 'auto' 或 'provider/model-id'，默认 "auto"
+  timeout: number;            // 超时秒，默认 90
+  autoApproveLowRisk: boolean;   // 低风险自动放行，默认 true
+  autoDenyHighRisk: boolean;     // 高风险转人工审批，默认 true
+  thinkingLevel: ModelThinkingLevel;  // thinking 级别，默认 "off"（直接透传，llm-shared 映射为不传）；"minimal"~"max" 透传
+}
+```
+
+### 权限模式
+
+| 模式 | 行为 | classifier 是否介入 |
+|---|---|---|
+| yolo | 完全无防护，全部放行 | 否 |
+| auto | 安全命令规则直通 + 非安全过 AI 审查 | **是（仅此模式）** |
+| approve | 规则直通安全 + 非安全直接人工审批（无 AI） | 否 |
+| strict | 全部审批 | 否 |
+
+> `classifier.*` 配置**仅在 `mode: "auto"` 下生效**。在 approve/strict/yolo 模式下调 classifier 字段（timeout/model 等）无任何效果。
+
+### classifier.model（只接受 string）
+
+- `"auto"`（默认）→ permission 本地取 `ctx.modelRegistry.getAvailable()` 首个（不经过 llm-shared 的非精确 selector）
+- `"provider/model-id"`（如 `"zhipu/glm-4-flash"`）→ 精确匹配（llm-shared `ModelSelector` 仅支持 ref）
+- 传对象形式会被 console.warn 忽略，回落 auto
+
+### auto 模式的风险判定（autoApproveLowRisk / autoDenyHighRisk）
+
+AI classifier 输出三档风险，对应处理：
+
+| 风险 | autoApproveLowRisk=true | autoDenyHighRisk=true | 实际动作 |
+|---|---|---|---|
+| low | ✓ 自动放行 | — | allow |
+| **medium** | — | — | **ask（转人工审批）** |
+| high | — | ✓ 转人工审批 | ask |
+
+> medium 风险**总是转人工审批**，不受这两个开关影响。两个开关只拨动 low/high 的边界。
+
+## 默认值
+
+```json
+{
+  "mode": "yolo",
+  "enabled": true,
+  "classifier": {
+    "enabled": true,
+    "model": "auto",
+    "timeout": 90,
+    "autoApproveLowRisk": true,
+    "autoDenyHighRisk": true,
+    "thinkingLevel": "off"
+  },
+  "userRules": []
+}
+```
+
+> ⚠ 默认 `mode: "yolo"` = 安装后默认**无任何防护**。生产/敏感环境务必改为 `auto` 或 `strict`。
+
+## 验证配置已生效
+
+改完配置文件后，用 `/permission` 命令确认：
+
+- `/permission` — 显示当前模式 + 可用模式
+- `/permission status` — 显示详细配置（mode/classifier/userRules 全貌）
+- `/permission <mode>` — 切换模式（yolo/auto/approve/strict）
+
+`/permission status` 的输出应与你改后的 JSON 一致；不一致说明文件没保存成功或 JSON 语法错误（此时会回落默认值并 console.warn）。
+
+## 配置示例
+
+auto 模式 + 指定 classifier 用 glm-4-flash + 自定义危险规则：
+```json
+{
+  "mode": "auto",
+  "enabled": true,
+  "classifier": {
+    "enabled": true,
+    "model": "zhipu/glm-4-flash",
+    "timeout": 60
+  },
+  "userRules": [
+    {
+      "tool": "bash",
+      "pattern": "rm -rf *",
+      "action": "deny",
+      "source": "user",
+      "description": "禁止递归删除当前目录"
+    }
+  ]
+}
+```
+
+## userRules 字段
+
+每条规则：`{ id?, tool, pattern, action, source, description? }`
+- tool：工具名（`*` 匹配全部，`bash` 精确）
+- pattern：命令模式（wildcard，仅 bash 用）
+- action：`allow` | `deny` | `ask`
+- source：`user`（用户规则；内置规则 builtin-safe/builtin-danger 在代码里不进配置）
+- id 省略时自动分配 `user-<n>`
+
+## classifier LLM 调用
+
+- 走 llm-shared callLLM（凭证 getApiKeyAndHeaders，含 OAuth/env/auth.json 三源合并）
+- model 不可用 / 调用失败 / 超时 → fail-closed 降级为 `ask`（转人工审批）
+- classifier 的 stopReason=error/aborted 同样降级 ask

package/src/__tests__/commands.test.ts

@@ -217,21 +217,28 @@ function makeModelEntry(provider: string, id: string, inputCost: number): Resolv
 		name: id,
 		api: "openai-completions",
 		cost: { input: inputCost, output: 0, cacheRead: 0, cacheWrite: 0 },
-		hasApiKey: true,
 	};
 }
 
-/** 构造 mock ctx（mode + ui.notify/custom/select）。 */
+/** 构造 mock ctx（mode + modelRegistry + ui.notify/custom/select）。 */
 function makeModelPickerCtx(overrides: Partial<ModelPickerContext> = {}): ModelPickerContext {
 	const base: ModelPickerContext = {
 		mode: "rpc",
+		modelRegistry: {
+			getAll: vi.fn(() => []),
+			hasConfiguredAuth: vi.fn(() => false),
+		},
 		ui: {
 			notify: vi.fn(),
 			select: vi.fn(() => Promise.resolve("Auto")),
 			custom: vi.fn(() => Promise.resolve(undefined)),
 		},
 	};
-	return { mode: overrides.mode ?? base.mode, ui: { ...base.ui, ...overrides.ui } };
+	return {
+		mode: overrides.mode ?? base.mode,
+		modelRegistry: overrides.modelRegistry ?? base.modelRegistry,
+		ui: { ...base.ui, ...overrides.ui },
+	};
 }
 
 /** 构造 mock deps（listModels + save）。 */

package/src/__tests__/config.test.ts

@@ -1,12 +1,13 @@
 /**
- * WT1-WT5/WT7: 配置加载/保存/mtime 缓存测试
+ * WT1-WT5/WT7: 配置加载/保存/mtime 缓存测试（委托 llm-shared 泛型 config）
  *
- * 用真实 fs + 临时目录（os.tmpdir + 随机子目录），不用 mock fs。
+ * 用真实 fs + 临时目录（os.tmpdir + 随机子目录），PI_CODING_AGENT_DIR 指向临时目录隔离，
+ * 配置文件路径 = <temp>/config/permission-ext-config.json（llm-shared getConfigPath 推导）。
  */
 import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, statSync, utimesSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 
 import { DEFAULT_CONFIG } from "../types.js";
 import {
@@ -17,23 +18,27 @@ import {
 } from "../config.js";
 
 let tempDir: string;
+let configPath: string;
 
 beforeEach(() => {
 	tempDir = mkdtempSync(join(tmpdir(), "pi-perm-test-"));
+	process.env.PI_CODING_AGENT_DIR = tempDir;
+	mkdirSync(join(tempDir, "config"), { recursive: true });
+	configPath = join(tempDir, "config", "permission-ext-config.json");
 	clearConfigCache();
 });
 
 afterEach(() => {
+	delete process.env.PI_CODING_AGENT_DIR;
 	rmSync(tempDir, { recursive: true, force: true });
 	clearConfigCache();
 });
 
 describe("WT1: 默认配置生成（首次无配置文件）", () => {
 	it("文件不存在时创建默认配置并返回", () => {
-		const configPath = join(tempDir, "permission-config.json");
 		expect(existsSync(configPath)).toBe(false);
 
-		const config = loadAndWatchConfig(configPath);
+		const config = loadAndWatchConfig();
 
 		expect(config.mode).toBe("yolo");
 		expect(config.enabled).toBe(true);
@@ -49,8 +54,7 @@ describe("WT1: 默认配置生成（首次无配置文件）", () => {
 	});
 
 	it("创建的文件是合法 JSON", () => {
-		const configPath = join(tempDir, "permission-config.json");
-		loadAndWatchConfig(configPath);
+		loadAndWatchConfig();
 
 		const content = readFileSync(configPath, "utf-8");
 		expect(() => JSON.parse(content)).not.toThrow();
@@ -59,7 +63,6 @@ describe("WT1: 默认配置生成（首次无配置文件）", () => {
 
 describe("WT2: 配置解析（合法配置）", () => {
 	it("正确解析完整配置", () => {
-		const configPath = join(tempDir, "permission-config.json");
 		const rawConfig = {
 			mode: "auto",
 			enabled: true,
@@ -77,7 +80,7 @@ describe("WT2: 配置解析（合法配置）", () => {
 		};
 		writeFileSync(configPath, JSON.stringify(rawConfig), "utf-8");
 
-		const config = loadAndWatchConfig(configPath);
+		const config = loadAndWatchConfig();
 
 		expect(config.mode).toBe("auto");
 		expect(config.classifier.enabled).toBe(false);
@@ -93,11 +96,10 @@ describe("WT2: 配置解析（合法配置）", () => {
 
 describe("WT3: 配置解析容错（malformed JSON）", () => {
 	it("malformed JSON fallback 到默认配置，不 throw", () => {
-		const configPath = join(tempDir, "permission-config.json");
 		writeFileSync(configPath, "{ invalid json missing quotes:", "utf-8");
 
 		const warnings: string[] = [];
-		const config = loadAndWatchConfig(configPath, (msg) => warnings.push(msg));
+		const config = loadAndWatchConfig((msg) => warnings.push(msg));
 
 		expect(config.mode).toBe("yolo"); // 默认值
 		expect(config.enabled).toBe(true);
@@ -106,25 +108,64 @@ describe("WT3: 配置解析容错（malformed JSON）", () => {
 	});
 
 	it("mode 字段非法时 fallback 到 yolo", () => {
-		const configPath = join(tempDir, "permission-config.json");
 		writeFileSync(configPath, JSON.stringify({ mode: "unknown-mode" }), "utf-8");
 
-		const config = loadAndWatchConfig(configPath);
+		const config = loadAndWatchConfig();
 		expect(config.mode).toBe("yolo");
 	});
 
 	it("classifier 字段缺失时用默认值", () => {
-		const configPath = join(tempDir, "permission-config.json");
 		writeFileSync(configPath, JSON.stringify({ mode: "strict" }), "utf-8");
 
-		const config = loadAndWatchConfig(configPath);
+		const config = loadAndWatchConfig();
 		expect(config.mode).toBe("strict");
 		expect(config.classifier.model).toBe("auto"); // 默认
 		expect(config.classifier.timeout).toBe(90); // 默认
 	});
 
+	it("TC6 (C3b): classifier.model 传对象形式 → console.warn + 回落默认 auto", () => {
+		// 用户照旧设计文档配对象形式 selector（不受支持）
+		writeFileSync(configPath, JSON.stringify({ classifier: { model: { type: "available" } } }), "utf-8");
+
+		const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+		try {
+			const config = loadAndWatchConfig();
+			// 回落默认 auto（不再静默）
+			expect(config.classifier.model).toBe("auto");
+			// warn 提示忽略无效 classifier.model
+			expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining("Ignoring invalid classifier.model"));
+		} finally {
+			warnSpy.mockRestore();
+		}
+	});
+
+	it("classifier.model 传数字 → console.warn + 回落默认 auto", () => {
+		writeFileSync(configPath, JSON.stringify({ classifier: { model: 42 } }), "utf-8");
+
+		const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+		try {
+			const config = loadAndWatchConfig();
+			expect(config.classifier.model).toBe("auto");
+			expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining("Ignoring invalid classifier.model"));
+		} finally {
+			warnSpy.mockRestore();
+		}
+	});
+
+	it("classifier.model 合法 string（'auto' / 'provider/model-id'）→ 不 warn", () => {
+		writeFileSync(configPath, JSON.stringify({ classifier: { model: "zhipu/glm-4-flash" } }), "utf-8");
+
+		const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+		try {
+			const config = loadAndWatchConfig();
+			expect(config.classifier.model).toBe("zhipu/glm-4-flash");
+			expect(warnSpy).not.toHaveBeenCalledWith(expect.stringContaining("Ignoring invalid classifier.model"));
+		} finally {
+			warnSpy.mockRestore();
+		}
+	});
+
 	it("userRules 含非法条目时过滤掉", () => {
-		const configPath = join(tempDir, "permission-config.json");
 		writeFileSync(configPath, JSON.stringify({
 			mode: "yolo",
 			userRules: [
@@ -135,7 +176,7 @@ describe("WT3: 配置解析容错（malformed JSON）", () => {
 			],
 		}), "utf-8");
 
-		const config = loadAndWatchConfig(configPath);
+		const config = loadAndWatchConfig();
 		expect(config.userRules).toHaveLength(1);
 		expect(config.userRules[0].pattern).toBe("ls");
 	});
@@ -143,12 +184,11 @@ describe("WT3: 配置解析容错（malformed JSON）", () => {
 
 describe("WT4: mtime 缓存（文件未变化时不重读）", () => {
 	it("连续两次调用，第二次返回缓存（同 mtime）", () => {
-		const configPath = join(tempDir, "permission-config.json");
-		const original = loadAndWatchConfig(configPath);
+		const original = loadAndWatchConfig();
 		const originalMode = original.mode;
 
 		// 不修改文件，第二次调用
-		const cached = loadAndWatchConfig(configPath);
+		const cached = loadAndWatchConfig();
 
 		// 返回的 config 应该与第一次一致（深相等）
 		expect(cached).toEqual(original);
@@ -158,8 +198,7 @@ describe("WT4: mtime 缓存（文件未变化时不重读）", () => {
 
 describe("WT5: mtime 缓存（文件变化时重读）", () => {
 	it("修改文件后第二次调用返回新内容", () => {
-		const configPath = join(tempDir, "permission-config.json");
-		const first = loadAndWatchConfig(configPath);
+		const first = loadAndWatchConfig();
 		expect(first.mode).toBe("yolo");
 
 		// 修改文件（写入新 mode）
@@ -170,17 +209,16 @@ describe("WT5: mtime 缓存（文件变化时重读）", () => {
 		const future = new Date(Date.now() + 2000);
 		utimesSync(configPath, future, future);
 
-		const second = loadAndWatchConfig(configPath);
+		const second = loadAndWatchConfig();
 		expect(second.mode).toBe("strict");
 	});
 });
 
 describe("WT7: 保存配置", () => {
 	it("saveConfig 写入文件并更新缓存", () => {
-		const configPath = join(tempDir, "permission-config.json");
 		const newConfig = { ...DEFAULT_CONFIG, mode: "strict" as const };
 
-		const result = saveConfig(newConfig, configPath);
+		const result = saveConfig(newConfig);
 		expect(result.success).toBe(true);
 
 		// 文件被写入
@@ -190,16 +228,18 @@ describe("WT7: 保存配置", () => {
 		expect(parsed.mode).toBe("strict");
 
 		// 后续 loadAndWatchConfig 返回新配置（缓存已更新）
-		const loaded = loadAndWatchConfig(configPath);
+		const loaded = loadAndWatchConfig();
 		expect(loaded.mode).toBe("strict");
 	});
 
 	it("saveConfig 失败时返回 error（只读目录）", () => {
 		const readOnlyDir = join(tempDir, "readonly");
 		mkdirSync(readOnlyDir, { mode: 0o500 });
-		const configPath = join(readOnlyDir, "permission-config.json");
+		// 直接把 agentDir 指向只读目录（config/ 建不出来 / tmp 写不进）
+		process.env.PI_CODING_AGENT_DIR = readOnlyDir;
+		clearConfigCache();
 
-		const result = saveConfig(DEFAULT_CONFIG, configPath);
+		const result = saveConfig(DEFAULT_CONFIG);
 		// 可能成功也可能失败取决于系统权限实现，主要验证不 throw
 		expect(typeof result.success).toBe("boolean");
 		if (!result.success) {
@@ -208,8 +248,7 @@ describe("WT7: 保存配置", () => {
 	});
 
 	it("saveConfig 后文件权限是 0o600（仅用户可读写）", () => {
-		const configPath = join(tempDir, "permission-config.json");
-		saveConfig(DEFAULT_CONFIG, configPath);
+		saveConfig(DEFAULT_CONFIG);
 
 		const stat = statSync(configPath);
 		// macOS/Linux 下 mode & 0o777 应该是 0o600
@@ -221,9 +260,38 @@ describe("WT7: 保存配置", () => {
 });
 
 describe("getConfigPath", () => {
-	it("返回 ~/.pi/agent/permission-config.json 路径", () => {
+	it("返回 <agentDir>/config/permission-ext-config.json 路径", () => {
 		const path = getConfigPath();
-		expect(path).toContain("permission-config.json");
-		expect(path).toContain(".pi");
+		expect(path).toContain("config");
+		expect(path).toContain("permission-ext-config.json");
+		// 受 PI_CODING_AGENT_DIR 隔离（本测试 beforeEach 已指向临时目录）
+		expect(path.startsWith(tempDir)).toBe(true);
+	});
+});
+
+describe("[MIGRATION] legacy config 降级告警（ensureConfigFile 兜底）", () => {
+	it("旧路径残留 + 新路径缺失 → console.warn 提醒 strict→yolo 降级", () => {
+		// 写 legacy 文件到 agentDir 根（PI_CODING_AGENT_DIR=tempDir）
+		const legacyPath = join(tempDir, "permission-config.json");
+		writeFileSync(legacyPath, JSON.stringify({ mode: "strict" }), "utf-8");
+
+		const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+		try {
+			loadAndWatchConfig();
+			expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining("Legacy config detected"));
+			expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining("downgrade"));
+		} finally {
+			warnSpy.mockRestore();
+		}
+	});
+
+	it("旧路径不存在 → 不触发 legacy 告警", () => {
+		const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+		try {
+			loadAndWatchConfig();
+			expect(warnSpy).not.toHaveBeenCalledWith(expect.stringContaining("Legacy config detected"));
+		} finally {
+			warnSpy.mockRestore();
+		}
 	});
 });