claude-coder 1.7.1 → 1.8.1

package/README.md

@@ -2,9 +2,14 @@
 
 **中文** | [English](docs/README.en.md)
 
-受 [Anthropic: Effective harnesses for long-running agents](https://www.anthropic.com/engineering/effective-harnesses-for-long-running-agents) 启发，Claude Coder 是一个**自主编码 harness**，依托 Claude Agent SDK 的 `query()` 接口，提供项目扫描、任务分解、多 session 编排、自动校验与 git 回滚的能力，支持一句话需求或 `requirements.md` 驱动，兼容所有 Anthropic API 兼容的模型提供商。
+一个**长时间自运行的自主编码 Agent Harness**：基于 Claude Agent SDK，通过 Hook 提示注入引导模型行为，倒计时活跃度监控保障稳定运行，多 session 编排实现一句话需求到完整项目的全自动交付。
 
-**核心思路**：AI Agent 单次会话上下文有限，大型需求容易丢失进度或产出不可用代码。本工具将 Agent 包装为一个**可靠的、可重试的函数** — harness 管理任务状态、校验每次产出、失败时自动回滚，Agent 只需专注于编码。
+### 亮点
+
+- **Harness 生命周期管理**：统一的 Harness 类封装环境准备、任务调度、校验、回滚、推送全生命周期，含 AI 驱动的 JSON 自愈修复
+- **Hook 提示注入**：通过 JSON 配置在工具调用时向模型注入上下文引导，零代码修改即可扩展规则（[机制详解](design/hook-mechanism.md)）
+- **长时间自循环编码**：多 session 编排 + 倒计时活跃度监控 + git 回滚重试，Agent 可持续编码数小时不中断（[守护机制](design/session-guard.md)）
+- **配置驱动**：支持 Claude 官方、Coding Plan 多模型路由、DeepSeek 等任意 Anthropic 兼容 API
 
 ---
 
@@ -20,11 +25,35 @@ npm install -g claude-coder
 # 配置模型
 claude-coder setup
 
-# 开始自动编码
+# 进入项目目录
 cd your-project
+
+# 初始化项目（扫描技术栈、生成 profile）
+claude-coder init
+
+# 开始自动编码
 claude-coder run "实现用户注册和登录功能"
 ```
 
+## 命令列表
+
+| 命令 | 说明 |
+|------|------|
+| `claude-coder setup` | 交互式配置（模型、MCP、安全限制、自动审查） |
+| `claude-coder init` | 初始化项目环境（扫描技术栈、生成 profile） |
+| `claude-coder plan "需求"` | 生成计划方案 |
+| `claude-coder plan -r [file]` | 从需求文件生成计划 |
+| `claude-coder plan --planOnly` | 仅生成计划文档，不分解任务 |
+| `claude-coder plan -i "需求"` | 交互模式，允许模型提问 |
+| `claude-coder run [需求]` | 自动编码循环 |
+| `claude-coder run --max 1` | 单次执行 |
+| `claude-coder run --dry-run` | 预览模式（查看任务队列） |
+| `claude-coder simplify [focus]` | 代码审查和简化 |
+| `claude-coder auth [url]` | 导出 Playwright 登录状态 |
+| `claude-coder status` | 查看进度和成本 |
+
+**选项**：`--max N` 限制 session 数（默认 50），`--pause N` 每 N 个 session 暂停确认，`--model M` 指定模型。
+
 ## 工作原理
 
 ```
@@ -33,34 +62,29 @@ claude-coder run "实现用户注册和登录功能"
                                  ┌──────┴──────┐
                                  │  Session N   │
                                  │  Claude SDK  │
-                                 │  6 步流程    │
+                                 │  3 步流程    │
                                  └──────┬──────┘
                                         │
-                                   harness 校验
+                                   Harness 校验
+                                   (含 AI 自愈)
                                         │
-                              通过 → 下一个任务
+                              通过 → simplify? → push → 下一个任务
                               失败 → git 回滚 + 重试
 ```
 
-每个 session 内，Agent 自主执行 6 步：恢复上下文 → 环境检查 → 选任务 → 编码 → 测试 → 收尾（git commit）。
+每个 session 内，Agent 自主执行 3 步：**实现**（任务上下文由 harness 注入，编码实现） → **验证**（按 category 选最轻量测试） → **收尾**（git commit + 写 session_result.json）。
 
-## 命令
+Harness 在 session 结束后自动校验 `session_result.json` + git 进度。校验失败时 AI 自动尝试修复损坏的 JSON 文件（`repair.js`），仍失败则回滚代码并重试。
 
-| 命令 | 说明 |
-|------|------|
-| `claude-coder setup` | 交互式模型配置 |
-| `claude-coder run [需求]` | 自动编码循环 |
-| `claude-coder run --max 1` | 单次执行 |
-| `claude-coder run --dry-run` | 预览模式 |
-| `claude-coder init` | 初始化项目环境 |
-| `claude-coder add "指令"` | 追加任务 |
-| `claude-coder add -r [file]` | 从需求文件追加任务 |
-| `claude-coder add "..." --model M` | 指定模型追加任务 |
-| `claude-coder auth [url]` | 导出 Playwright 登录状态 |
-| `claude-coder validate` | 手动校验 |
-| `claude-coder status` | 查看进度和成本 |
+## 机制文档
 
-**选项**：`--max N` 限制 session 数（默认 50），`--pause N` 每 N 个 session 暂停确认（默认不暂停）。
+| 文档 | 说明 |
+|------|------|
+| [技术架构](design/ARCHITECTURE.md) | 核心设计规则、Harness 类职责、模块关系、Prompt 注入架构 |
+| [Hook 注入机制](design/hook-mechanism.md) | SDK Hook 调研、GuidanceInjector 三级匹配、配置格式、副作用评估 |
+| [Session 守护机制](design/session-guard.md) | 中断策略、倒计时活跃度检测、工具运行状态追踪、防刷屏 |
+| [测试凭证方案](docs/PLAYWRIGHT_CREDENTIALS.md) | Playwright 登录态导出、API Key 持久化 |
+| [SDK 使用指南](docs/CLAUDE_AGENT_SDK_GUIDE.md) | Claude Agent SDK 接口参考 |
 
 ## 使用场景
 
@@ -68,21 +92,37 @@ claude-coder run "实现用户注册和登录功能"
 
 **已有项目**：`claude-coder run "新增头像上传功能"` — 先扫描现有代码和技术栈，再增量开发。
 
-**需求文档驱动**：在项目根目录创建 `requirements.md`，运行 `claude-coder run` — 需求变更后用 `claude-coder add -r` 同步新任务。
-
-**追加任务**：`claude-coder add "新增管理员后台"` 或 `claude-coder add -r requirements.md` — 仅追加到任务列表，下次 run 时执行。
+**需求文档驱动**：在项目根目录创建 `requirements.md`，运行 `claude-coder run`。需求变更后 `claude-coder add -r` 同步新任务。
 
-**自动测试 + 凭证持久化**：`claude-coder auth http://localhost:3000` — 导出浏览器登录态（cookies + localStorage），Agent 测试时自动使用。缺 API Key 时 Agent 会自行记录到 `test.env` 并继续推进，不会停工。详见 [测试凭证持久化方案](docs/PLAYWRIGHT_CREDENTIALS.md)。
+**自动测试 + 凭证持久化**：`claude-coder auth http://localhost:3000` — 导出浏览器登录态，Agent 测试时自动使用。详见 [测试凭证方案](docs/PLAYWRIGHT_CREDENTIALS.md)。
 
 ## 模型支持
 
 | 提供商 | 说明 |
 |--------|------|
-| Claude 官方 | 默认，Anthropic 原版 API |
-| GLM (智谱/Z.AI) | GLM 4.7 / GLM 5 |
-| 阿里云百炼 | qwen3-coder-plus / glm-5 |
-| DeepSeek | deepseek-chat / reasoner |
-| 自定义 | 任何 Anthropic 兼容 API |
+| 默认 | Claude 官方模型，使用系统登录态 |
+| Coding Plan | 自建 API，推荐的多模型路由配置 |
+| API | DeepSeek 或其他 Anthropic 兼容 API |
+
+## 建议配置
+
+### 长时间自运行 Agent（最稳）
+
+```bash
+ANTHROPIC_DEFAULT_OPUS_MODEL=glm-5
+ANTHROPIC_DEFAULT_SONNET_MODEL=qwen3-coder-next
+ANTHROPIC_DEFAULT_HAIKU_MODEL=qwen3-coder-plus
+ANTHROPIC_MODEL=kimi-k2.5
+```
+
+### 自用 Claude Code（最强）
+
+```bash
+ANTHROPIC_DEFAULT_OPUS_MODEL=qwen3-max-2026-01-23
+ANTHROPIC_DEFAULT_SONNET_MODEL=qwen3-coder-next
+ANTHROPIC_DEFAULT_HAIKU_MODEL=qwen3-coder-plus
+ANTHROPIC_MODEL=glm-5
+```
 
 ## 项目结构
 
@@ -92,33 +132,27 @@ your-project/
     .env                    # 模型配置
     project_profile.json    # 项目扫描结果
     tasks.json              # 任务列表 + 状态
-    session_result.json     # 上次 session 结果（扁平）
+    session_result.json     # 上次 session 结果
     progress.json           # 会话历史 + 成本
-    tests.json              # 验证记录
-    test.env                # 测试凭证（API Key 等，可选）
-    playwright-auth.json    # 登录状态快照（isolated 模式，auth 命令生成）
-    .runtime/               # 临时文件
-      logs/                 # 每 session 独立日志（含工具调用记录）
-      browser-profile/      # 持久化浏览器 Profile（persistent 模式，auth 命令生成）
-  requirements.md           # 需求文档（可选）
+    test.env                # 测试凭证（可选）
+    .runtime/
+      harness_state.json    # Harness 状态（session 计数等）
+      logs/                 # 每 session 独立日志
 ```
 
 ## 常见问题
 
 **"Credit balance is too low"**：运行 `claude-coder setup` 重新配置 API Key。
 
-**中断恢复**：直接重新运行 `claude-coder run`，会从上次中断处继续。
+**中断恢复**：直接重新运行 `claude-coder run`，从上次中断处继续。
 
-**长时间无响应**：模型处理复杂文件时可能出现 10-20 分钟的思考间隔（spinner 会显示红色警告），这是正常行为。超过 20 分钟无工具调用时 Harness 会自动中断并重试。可通过 `.env` 中 `SESSION_STALL_TIMEOUT=秒数` 调整阈值。
+**长时间无响应**：模型处理复杂任务时可能出现长思考间隔（indicator 显示黄色"工具执行中"或红色"无响应"），这是正常行为。超过阈值后 harness 自动中断并重试。通过 `claude-coder setup` 的安全限制配置或 `.env` 中 `SESSION_STALL_TIMEOUT=秒数` 调整。
 
 **跳过任务**：将 `.claude-coder/tasks.json` 中该任务的 `status` 改为 `done`。
 
-**Windows 支持**：完全支持，纯 Node.js 实现。
-
-## 文档
+## 参考文章
 
-- [技术架构](docs/ARCHITECTURE.md) — 核心设计规则、模块职责、提示语注入架构、注意力机制、Hook 数据流
-- [测试凭证持久化方案](docs/PLAYWRIGHT_CREDENTIALS.md) — 自动测试的凭证管理：Playwright 登录态导出、API Key 持久化、Agent 缺凭证时的行为策略
+[Anthropic: Effective harnesses for long-running agents](https://www.anthropic.com/engineering/effective-harnesses-for-long-running-agents)
 
 ## License
 

package/bin/cli.js

@@ -1,16 +1,16 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 'use strict';
 
 const pkg = require('../package.json');
 
 const COMMANDS = {
-  run:      { desc: '自动编码循环',             usage: 'claude-coder run [--max N] [--pause N] [--dry-run]' },
-  setup:    { desc: '交互式模型配置',           usage: 'claude-coder setup' },
-  init:     { desc: '初始化项目环境',           usage: 'claude-coder init' },
-  add:      { desc: '追加任务并可选自动执行',   usage: 'claude-coder add "指令" [--model M] | add -r [file]' },
-  auth:     { desc: '导出 Playwright 登录状态', usage: 'claude-coder auth [url]' },
-  validate: { desc: '手动校验上次 session',     usage: 'claude-coder validate' },
-  status:   { desc: '查看任务进度和成本',       usage: 'claude-coder status' },
+  run:       { desc: '自动编码循环',             usage: 'claude-coder run [--max N] [--pause N] [--dry-run]' },
+  setup:     { desc: '交互式模型配置',           usage: 'claude-coder setup' },
+  init:      { desc: '初始化项目环境',           usage: 'claude-coder init' },
+  plan:      { desc: '生成计划方案',             usage: 'claude-coder plan "需求" | plan -r requirements.md [--planOnly] [-i]' },
+  simplify:  { desc: '代码审查和简化',           usage: 'claude-coder simplify [focus]' },
+  auth:      { desc: '导出 Playwright 登录状态', usage: 'claude-coder auth [url]' },
+  status:    { desc: '查看任务进度和成本',       usage: 'claude-coder status' },
 };
 
 function showHelp() {
@@ -22,15 +22,18 @@ function showHelp() {
   }
   console.log('\n示例:');
   console.log('  claude-coder setup                   配置模型和 API Key');
-  console.log('  claude-coder add "实现用户登录"       添加任务（询问是否自动执行）');
+  console.log('  claude-coder plan "实现用户登录"      生成计划方案');
+  console.log('  claude-coder plan -r requirements.md 从文件读取需求');
+  console.log('  claude-coder plan --planOnly         仅生成计划文档');
+  console.log('  claude-coder plan -i "优化系统"      交互模式，允许模型提问');
   console.log('  claude-coder run                     执行所有待处理任务');
   console.log('  claude-coder run --max 1             单次执行');
   console.log('  claude-coder run --max 5 --pause 5   每 5 个 session 暂停确认');
   console.log('  claude-coder run --dry-run            预览模式');
-  console.log('  claude-coder add -r                   从 requirements.md 追加任务');
-  console.log('  claude-coder add "..." --model opus-4 指定模型追加任务');
+  console.log('  claude-coder simplify               代码审查和简化');
+  console.log('  claude-coder simplify "内存效率"     聚焦特定领域审查');
   console.log('  claude-coder auth                    导出 Playwright 登录状态');
-  console.log('  claude-coder auth http://localhost:8080  指定登录 URL');
+  console.log('  claude-coder auth http://localhost:8080   指定登录 URL'); 
   console.log('  claude-coder status                  查看进度和成本');
   console.log(`\n前置条件: npm install -g @anthropic-ai/claude-agent-sdk`);
 }
@@ -38,7 +41,7 @@ function showHelp() {
 function parseArgs(argv) {
   const args = argv.slice(2);
   const command = args[0];
-  const opts = { max: 50, pause: 0, dryRun: false, readFile: null, model: null };
+  const opts = { max: 50, pause: 0, dryRun: false, readFile: null, model: null, n: 3, planOnly: false, interactive: false };
   const positional = [];
 
   for (let i = 1; i < args.length; i++) {
@@ -55,6 +58,10 @@ function parseArgs(argv) {
       case '--model':
         opts.model = args[++i] || null;
         break;
+      case '-n':
+      case '--n':
+        opts.n = parseInt(args[++i], 10) || 3;
+        break;
       case '-r': {
         const next = args[i + 1];
         if (next && !next.startsWith('-')) {
@@ -65,6 +72,13 @@ function parseArgs(argv) {
         }
         break;
       }
+      case '--planOnly':
+        opts.planOnly = true;
+        break;
+      case '-i':
+      case '--interactive':
+        opts.interactive = true;
+        break;
       case '--help':
       case '-h':
         showHelp();
@@ -96,54 +110,38 @@ async function main() {
 
   switch (command) {
     case 'run': {
-      const runner = require('../src/runner');
+      const runner = require('../src/core/runner');
       await runner.run(opts);
       break;
     }
     case 'setup': {
-      const setup = require('../src/setup');
+      const setup = require('../src/commands/setup');
       await setup.setup();
       break;
     }
     case 'init': {
-      const { init } = require('../src/init');
+      const { init } = require('../src/core/init');
       await init();
       break;
     }
-    case 'add': {
-      const fs = require('fs');
-      const nodePath = require('path');
-      let instruction = positional[0] || '';
-      if (opts.readFile) {
-        const reqPath = nodePath.resolve(opts.readFile);
-        if (!fs.existsSync(reqPath)) {
-          console.error(`文件不存在: ${reqPath}`);
-          process.exit(1);
-        }
-        instruction = fs.readFileSync(reqPath, 'utf8');
-        console.log(`已读取需求文件: ${opts.readFile}`);
-      }
-      if (!instruction) {
-        console.error('用法: claude-coder add "任务描述"  或  claude-coder add -r [requirements.md]');
-        process.exit(1);
-      }
-      const runner = require('../src/runner');
-      await runner.add(instruction, opts);
+    case 'plan': {
+      const { run: planRun } = require('../src/core/plan');
+      const input = positional[0] || '';
+      await planRun(input, opts);
       break;
     }
-    case 'auth': {
-      const { auth } = require('../src/auth');
-      await auth(positional[0] || null);
+    case 'simplify': {
+      const { simplify } = require('../src/core/simplify');
+      await simplify(positional[0] || null, { n: opts.n });
       break;
     }
-    case 'validate': {
-      const validator = require('../src/validator');
-      const result = await validator.validate();
-      process.exit(result.fatal ? 1 : 0);
+    case 'auth': {
+      const { auth } = require('../src/commands/auth');
+      await auth(positional[0] || null);
       break;
     }
     case 'status': {
-      const tasks = require('../src/tasks');
+      const tasks = require('../src/common/tasks');
       tasks.showStatus();
       break;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-coder",
-  "version": "1.7.1",
+  "version": "1.8.1",
   "description": "Claude Coder — Autonomous coding agent harness powered by Claude Code SDK. Scan, plan, code, validate, git-commit in a loop.",
   "bin": {
     "claude-coder": "bin/cli.js"
@@ -8,9 +8,11 @@
   "files": [
     "bin/",
     "src/",
-    "prompts/",
     "templates/"
   ],
+  "scripts": {
+    "test": "node test/complete.test.js && node test/integration.test.js && node test/flow.test.js"
+  },
   "keywords": [
     "claude-coder",
     "claude",
@@ -43,5 +45,8 @@
   },
   "optionalDependencies": {
     "playwright": "^1.58.2"
+  },
+  "devDependencies": {
+    "@anthropic-ai/claude-agent-sdk": "^0.2.71"
   }
 }

package/src/{auth.js → commands/auth.js}

@@ -4,39 +4,37 @@ const fs = require('fs');
 const os = require('os');
 const path = require('path');
 const { execSync } = require('child_process');
-const { paths, loadConfig, log, getProjectRoot, ensureLoopDir } = require('./config');
+const { loadConfig, log } = require('../common/config');
+const { assets } = require('../common/assets');
+const { appendGitignore } = require('../common/utils');
 
 function updateGitignore(entry) {
-  const gitignorePath = path.join(getProjectRoot(), '.gitignore');
-  let content = '';
-  if (fs.existsSync(gitignorePath)) {
-    content = fs.readFileSync(gitignorePath, 'utf8');
+  if (appendGitignore(assets.projectRoot, entry)) {
+    log('ok', `.gitignore 已添加: ${entry}`);
   }
-  if (content.includes(entry)) return;
-
-  const suffix = content.endsWith('\n') || content === '' ? '' : '\n';
-  fs.appendFileSync(gitignorePath, `${suffix}${entry}\n`, 'utf8');
-  log('ok', `.gitignore 已添加: ${entry}`);
 }
 
-function updateMcpConfig(p, mode) {
+function updateMcpConfig(mcpPath, mode) {
   let mcpConfig = {};
-  if (fs.existsSync(p.mcpConfig)) {
-    try { mcpConfig = JSON.parse(fs.readFileSync(p.mcpConfig, 'utf8')); } catch {}
+  if (fs.existsSync(mcpPath)) {
+    try { mcpConfig = JSON.parse(fs.readFileSync(mcpPath, 'utf8')); } catch {}
   }
 
   if (!mcpConfig.mcpServers) mcpConfig.mcpServers = {};
 
   const args = ['@playwright/mcp@latest'];
+  const projectRoot = assets.projectRoot;
 
   switch (mode) {
     case 'persistent': {
-      const relProfile = path.relative(getProjectRoot(), p.browserProfile).split(path.sep).join('/');
+      const browserProfilePath = assets.path('browserProfile');
+      const relProfile = path.relative(projectRoot, browserProfilePath).split(path.sep).join('/');
       args.push(`--user-data-dir=${relProfile}`);
       break;
     }
     case 'isolated': {
-      const relAuth = path.relative(getProjectRoot(), p.playwrightAuth).split(path.sep).join('/');
+      const playwrightAuthPath = assets.path('playwrightAuth');
+      const relAuth = path.relative(projectRoot, playwrightAuthPath).split(path.sep).join('/');
       args.push('--isolated', `--storage-state=${relAuth}`);
       break;
     }
@@ -46,29 +44,27 @@ function updateMcpConfig(p, mode) {
   }
 
   mcpConfig.mcpServers.playwright = { command: 'npx', args };
-  fs.writeFileSync(p.mcpConfig, JSON.stringify(mcpConfig, null, 2) + '\n', 'utf8');
+  fs.writeFileSync(mcpPath, JSON.stringify(mcpConfig, null, 2) + '\n', 'utf8');
   log('ok', `.mcp.json 已配置 Playwright MCP (${mode} 模式)`);
 }
 
 function enableMcpPlaywrightEnv() {
-  const p = paths();
-  if (!fs.existsSync(p.envFile)) return;
+  const envPath = assets.path('env');
+  if (!envPath || !fs.existsSync(envPath)) return;
 
-  let content = fs.readFileSync(p.envFile, 'utf8');
+  let content = fs.readFileSync(envPath, 'utf8');
   if (/^MCP_PLAYWRIGHT=/m.test(content)) {
     content = content.replace(/^MCP_PLAYWRIGHT=.*/m, 'MCP_PLAYWRIGHT=true');
   } else {
     const suffix = content.endsWith('\n') ? '' : '\n';
     content += `${suffix}MCP_PLAYWRIGHT=true\n`;
   }
-  fs.writeFileSync(p.envFile, content, 'utf8');
+  fs.writeFileSync(envPath, content, 'utf8');
   log('ok', '.claude-coder/.env 已设置 MCP_PLAYWRIGHT=true');
 }
 
-// ── persistent 模式：启动持久化浏览器让用户登录 ──
-
-async function authPersistent(url, p) {
-  const profileDir = p.browserProfile;
+async function authPersistent(url) {
+  const profileDir = assets.path('browserProfile');
   if (!fs.existsSync(profileDir)) fs.mkdirSync(profileDir, { recursive: true });
 
   const lockFile = path.join(profileDir, 'SingletonLock');
@@ -112,17 +108,17 @@ async function authPersistent(url, p) {
   const helperModules = path.join(__dirname, '..', 'node_modules');
   const existingNodePath = process.env.NODE_PATH || '';
   const nodePath = existingNodePath ? `${helperModules}:${existingNodePath}` : helperModules;
+  const projectRoot = assets.projectRoot;
 
   let scriptOk = false;
   try {
     execSync(`node "${tmpScript}"`, {
       stdio: 'inherit',
-      cwd: getProjectRoot(),
+      cwd: projectRoot,
       env: { ...process.env, NODE_PATH: nodePath },
     });
     scriptOk = true;
   } catch {
-    // 浏览器关闭时可能返回非零退出码，只要 profile 目录有内容就认为成功
     const profileFiles = fs.readdirSync(profileDir);
     scriptOk = profileFiles.length > 2;
     if (!scriptOk) {
@@ -136,21 +132,23 @@ async function authPersistent(url, p) {
 
   try { fs.unlinkSync(tmpScript); } catch {}
 
+  const mcpPath = assets.path('mcpConfig');
   log('ok', '登录状态已保存到持久化配置');
-  updateMcpConfig(p, 'persistent');
+  updateMcpConfig(mcpPath, 'persistent');
   updateGitignore('.claude-coder/.runtime/browser-profile');
   enableMcpPlaywrightEnv();
 
   console.log('');
   log('ok', '配置完成！');
-  const relProfile = path.relative(getProjectRoot(), profileDir);
+  const relProfile = path.relative(projectRoot, profileDir);
   log('info', `MCP 使用 persistent 模式 (user-data-dir: ${relProfile})`);
   log('info', '如需更新登录状态，重新运行 claude-coder auth');
 }
 
-// ── isolated 模式：使用 codegen 录制 storage-state ──
+async function authIsolated(url) {
+  const playwrightAuthPath = assets.path('playwrightAuth');
+  const projectRoot = assets.projectRoot;
 
-async function authIsolated(url, p) {
   console.log('操作步骤:');
   console.log('  1. 浏览器将自动打开，请手动完成登录');
   console.log('  2. 登录成功后关闭浏览器窗口');
@@ -160,24 +158,25 @@ async function authIsolated(url, p) {
 
   try {
     execSync(
-      `npx playwright codegen --save-storage="${p.playwrightAuth}" "${url}"`,
-      { stdio: 'inherit', cwd: getProjectRoot() }
+      `npx playwright codegen --save-storage="${playwrightAuthPath}" "${url}"`,
+      { stdio: 'inherit', cwd: projectRoot }
     );
   } catch (err) {
-    if (!fs.existsSync(p.playwrightAuth)) {
+    if (!fs.existsSync(playwrightAuthPath)) {
       log('error', `Playwright 登录状态导出失败: ${err.message}`);
       log('info', '请确保已安装: npx playwright install chromium');
       return;
     }
   }
 
-  if (!fs.existsSync(p.playwrightAuth)) {
+  if (!fs.existsSync(playwrightAuthPath)) {
     log('error', '未检测到导出的登录状态文件');
     return;
   }
 
+  const mcpPath = assets.path('mcpConfig');
   log('ok', '登录状态已保存到 playwright-auth.json');
-  updateMcpConfig(p, 'isolated');
+  updateMcpConfig(mcpPath, 'isolated');
   updateGitignore('.claude-coder/playwright-auth.json');
   enableMcpPlaywrightEnv();
 
@@ -188,9 +187,7 @@ async function authIsolated(url, p) {
   log('info', '如需更新登录状态，重新运行 claude-coder auth');
 }
 
-// ── extension 模式：连接真实浏览器 ──
-
-function authExtension(p) {
+function authExtension() {
   console.log('Extension 模式说明:');
   console.log('');
   console.log('  此模式通过 Chrome 扩展连接到您正在运行的浏览器。');
@@ -203,7 +200,8 @@ function authExtension(p) {
   console.log('  3. 无需额外认证操作，您的浏览器登录态将自动可用');
   console.log('');
 
-  updateMcpConfig(p, 'extension');
+  const mcpPath = assets.path('mcpConfig');
+  updateMcpConfig(mcpPath, 'extension');
   enableMcpPlaywrightEnv();
 
   console.log('');
@@ -212,12 +210,9 @@ function authExtension(p) {
   log('info', '确保 Chrome/Edge 已运行且 Playwright MCP Bridge 扩展已启用');
 }
 
-// ── 主入口 ──
-
 async function auth(url) {
-  ensureLoopDir();
+  assets.ensureDirs();
   const config = loadConfig();
-  const p = paths();
   const mode = config.playwrightMode;
   const targetUrl = url || 'http://localhost:3000';
 
@@ -227,13 +222,13 @@ async function auth(url) {
 
   switch (mode) {
     case 'persistent':
-      await authPersistent(targetUrl, p);
+      await authPersistent(targetUrl);
       break;
     case 'isolated':
-      await authIsolated(targetUrl, p);
+      await authIsolated(targetUrl);
       break;
     case 'extension':
-      authExtension(p);
+      authExtension();
       break;
     default:
       log('error', `未知的 Playwright 模式: ${mode}`);