@weotro/dx 0.1.21 → 0.2.0

package/lib/logger.js

@@ -1,239 +1,6 @@
-import { writeFileSync, mkdirSync } from 'node:fs'
-import { join } from 'node:path'
-
-function resolveProjectRoot() {
-  return process.env.DX_PROJECT_ROOT || process.cwd()
+export const logger = {
+  error(message) { process.stderr.write(`dx: ${message}\n`) },
+  warn(message) { process.stderr.write(`dx: ${message}\n`) },
+  info(message) { process.stdout.write(`${message}\n`) },
+  success(message) { process.stdout.write(`${message}\n`) },
 }
-
-export function sanitizeForLog(input) {
-  let text = input == null ? '' : String(input)
-
-  // CLI token args (vercel)
-  text = text.replace(/--token=("[^"]*"|'[^']*'|[^\s]+)/gi, '--token=***')
-  text = text.replace(/--token\s+("[^"]*"|'[^']*'|[^\s]+)/gi, '--token ***')
-
-  // Env style secrets
-  text = text.replace(/\bVERCEL_TOKEN=([^\s]+)/g, 'VERCEL_TOKEN=***')
-  text = text.replace(/\bTELEGRAM_BOT_TOKEN=([^\s]+)/g, 'TELEGRAM_BOT_TOKEN=***')
-  text = text.replace(
-    /\bTELEGRAM_BOT_WEBHOOK_SECRET=([^\s]+)/g,
-    'TELEGRAM_BOT_WEBHOOK_SECRET=***',
-  )
-
-  // Authorization bearer
-  text = text.replace(
-    /Authorization:\s*Bearer\s+([^\s]+)/gi,
-    'Authorization: Bearer ***',
-  )
-
-  // JSON-ish token fields
-  text = text.replace(/"token"\s*:\s*"[^"]*"/gi, '"token":"***"')
-  text = text.replace(
-    /("secret_token"\s*:\s*")([^"]*)(")/gi,
-    '$1***$3',
-  )
-  text = text.replace(/\bsecret_token=([^\s&]+)/gi, 'secret_token=***')
-
-  // Telegram bot token in URLs
-  text = text.replace(
-    /api\.telegram\.org\/bot([^/\s]+)(\/|$)/gi,
-    'api.telegram.org/bot***$2',
-  )
-
-  return text
-}
-
-// 处理输出管道被关闭导致的 EPIPE 错误，避免进程在清理阶段崩溃
-try {
-  const handleBrokenPipe = err => {
-    if (err && (err.code === 'EPIPE' || err.code === 'ERR_STREAM_WRITE_AFTER_END')) {
-      // 静默忽略，允许进程优雅退出
-      try {
-        /* noop */
-      } catch {}
-    }
-  }
-  if (process?.stdout?.on) process.stdout.on('error', handleBrokenPipe)
-  if (process?.stderr?.on) process.stderr.on('error', handleBrokenPipe)
-} catch {
-  /* 安全保护，忽略环境不支持的情况 */
-}
-
-export class Logger {
-  constructor(options = {}) {
-    this.logLevel = options.level || 'info'
-    this.enableFile = options.enableFile || false
-    this.logDir = options.logDir || join(resolveProjectRoot(), 'dx', 'logs')
-
-    if (this.enableFile) {
-      this.ensureLogDir()
-    }
-  }
-
-  // 确保日志目录存在
-  ensureLogDir() {
-    try {
-      mkdirSync(this.logDir, { recursive: true })
-    } catch (error) {
-      // 目录可能已存在，忽略错误
-    }
-  }
-
-  // 格式化时间戳
-  formatTimestamp() {
-    return new Date().toLocaleString('zh-CN')
-  }
-
-  // 基础日志方法
-  info(message, prefix = '🚀') {
-    const safeMessage = sanitizeForLog(message)
-    const output = `${prefix} ${safeMessage}`
-    console.log(output)
-    this.writeLog('info', safeMessage)
-  }
-
-  success(message) {
-    const safeMessage = sanitizeForLog(message)
-    const output = `✅ ${safeMessage}`
-    console.log(output)
-    this.writeLog('success', safeMessage)
-  }
-
-  warn(message) {
-    const safeMessage = sanitizeForLog(message)
-    const output = `⚠️  ${safeMessage}`
-    console.log(output)
-    this.writeLog('warn', safeMessage)
-  }
-
-  error(message) {
-    const safeMessage = sanitizeForLog(message)
-    const output = `❌ ${safeMessage}`
-    console.log(output)
-    this.writeLog('error', safeMessage)
-  }
-
-  debug(message) {
-    if (this.logLevel === 'debug') {
-      const safeMessage = sanitizeForLog(message)
-      const output = `🐛 ${safeMessage}`
-      console.log(output)
-      this.writeLog('debug', safeMessage)
-    }
-  }
-
-  // 步骤显示
-  step(message, stepNumber = null) {
-    const prefix = stepNumber ? `步骤 ${stepNumber}:` : '执行:'
-    const separator = '=================================='
-
-    const safeMessage = sanitizeForLog(message)
-
-    console.log(`\n${separator}`)
-    console.log(`🚀 ${prefix} ${safeMessage}`)
-    console.log(separator)
-
-    this.writeLog('step', `${prefix} ${safeMessage}`)
-  }
-
-  // 进度显示
-  progress(message) {
-    const safeMessage = sanitizeForLog(message)
-    process.stdout.write(`⌛ ${safeMessage}...`)
-    this.writeLog('progress', `开始: ${safeMessage}`)
-  }
-
-  progressDone() {
-    console.log(' 完成')
-    this.writeLog('progress', '完成')
-  }
-
-  // 命令执行日志
-  command(command) {
-    const safeCommand = sanitizeForLog(command)
-    console.log(`💻 执行: ${safeCommand}`)
-    this.writeLog('command', safeCommand)
-  }
-
-  // 分隔符
-  separator() {
-    console.log(`\n${'='.repeat(50)}`)
-  }
-
-  // 表格显示
-  table(data, headers = []) {
-    if (data.length === 0) return
-
-    if (headers.length > 0) {
-      const safeHeaders = headers.map(h => sanitizeForLog(h))
-      console.log(`\n${safeHeaders.join('\t')}`)
-      console.log('-'.repeat(safeHeaders.join('\t').length))
-    }
-
-    data.forEach(row => {
-      if (Array.isArray(row)) {
-        console.log(row.map(cell => sanitizeForLog(cell)).join('\t'))
-      } else {
-        console.log(sanitizeForLog(row))
-      }
-    })
-    console.log()
-  }
-
-  // 端口信息显示
-  ports(portInfo) {
-    console.log('\n📡 服务端口信息:')
-    portInfo.forEach(({ service, port, url }) => {
-      const safeService = sanitizeForLog(service)
-      const safeUrl = url ? sanitizeForLog(url) : ''
-      console.log(`  ${safeService}: http://localhost:${port} ${safeUrl ? `(${safeUrl})` : ''}`)
-    })
-    console.log()
-  }
-
-  // 写入日志文件
-  writeLog(level, message) {
-    if (!this.enableFile) return
-
-    try {
-      const safeMessage = sanitizeForLog(message)
-      const timestamp = this.formatTimestamp()
-      const logLine = `[${timestamp}] [${level.toUpperCase()}] ${safeMessage}\n`
-
-      const logFile = join(this.logDir, `dx-${new Date().toISOString().split('T')[0]}.log`)
-      writeFileSync(logFile, logLine, { flag: 'a', encoding: 'utf8' })
-    } catch (error) {
-      // 写入日志失败时静默处理，避免影响主流程
-    }
-  }
-
-  // 创建子日志器
-  createChild(prefix) {
-    const childLogger = new Logger({
-      level: this.logLevel,
-      enableFile: this.enableFile,
-      logDir: this.logDir,
-    })
-
-    // 重写方法以添加前缀
-    const originalMethods = ['info', 'success', 'warn', 'error', 'debug']
-    originalMethods.forEach(method => {
-      const originalMethod = childLogger[method].bind(childLogger)
-      childLogger[method] = (message, customPrefix) => {
-        const finalPrefix = customPrefix || prefix
-        originalMethod(message, finalPrefix)
-      }
-    })
-
-    return childLogger
-  }
-}
-
-// 导出默认实例
-export const logger = new Logger()
-
-// 导出带文件日志的实例
-export const fileLogger = new Logger({ enableFile: true })
-
-// 导出调试日志实例
-export const debugLogger = new Logger({ level: 'debug', enableFile: true })

package/lib/setup.js

@@ -0,0 +1,72 @@
+import { spawnSync } from 'node:child_process'
+import { readdirSync, lstatSync, mkdirSync, copyFileSync, realpathSync, constants } from 'node:fs'
+import { join, dirname, relative, resolve, sep } from 'node:path'
+
+function git(root, args, allowOutsideRepository = false) {
+  const env = Object.fromEntries(Object.entries(process.env).filter(([key]) => !key.startsWith('GIT_')))
+  const result = spawnSync('git', args, {
+    cwd: root, env: { ...env, LC_ALL: 'C', GIT_OPTIONAL_LOCKS: '0' },
+    encoding: 'utf8', timeout: 10000, maxBuffer: 4 * 1024 * 1024,
+  })
+  if (allowOutsideRepository && result.status === 128 && result.stderr?.includes('not a git repository')) return null
+  if (result.error || result.status !== 0) {
+    throw new Error('基础 setup 无法读取 Git 工作目录；请检查 Git 已安装且当前仓库的 worktree 信息有效。')
+  }
+  return result.stdout
+}
+
+function entryAt(path) {
+  try { return lstatSync(path) } catch (error) {
+    if (error.code === 'ENOENT') return null
+    throw error
+  }
+}
+
+function prepareParent(root, destination) {
+  let directory = root
+  for (const part of relative(root, dirname(destination)).split(sep).filter(Boolean)) {
+    directory = join(directory, part)
+    try { mkdirSync(directory) } catch (error) {
+      if (error.code !== 'EEXIST') throw error
+    }
+    if (!lstatSync(directory).isDirectory()) {
+      throw new Error(`基础 setup 的目标父路径 ${directory} 不是普通目录；请移除路径冲突后重试。`)
+    }
+  }
+}
+
+export function runBaseSetup(projectRoot) {
+  const top = git(projectRoot, ['rev-parse', '--show-toplevel'], true)
+  if (top === null) return
+  const destinationRoot = realpathSync(top.replace(/\r?\n$/, ''))
+  const records = git(projectRoot, ['worktree', 'list', '--porcelain', '-z'])
+    .split('\0\0').filter(Boolean).map(record => record.split('\0'))
+  // Git lists the main worktree first; a bare repository has no source checkout.
+  if (records[0]?.includes('bare')) return
+  const paths = records.map(record => record.find(field => field.startsWith('worktree '))?.slice(9))
+  if (!paths[0]) throw new Error('基础 setup 无法定位主 Git 工作目录；请检查 git worktree list。')
+  const sourceRoot = realpathSync(paths[0])
+  if (sourceRoot === destinationRoot) return
+  const worktrees = new Set(paths.filter(Boolean).map(path => resolve(path)))
+
+  function copyDirectory(directory) {
+    for (const entry of readdirSync(directory, { withFileTypes: true })) {
+      if (entry.name === '.git') continue
+      const source = join(directory, entry.name)
+      if (entry.isDirectory()) {
+        if (!worktrees.has(source)) copyDirectory(source)
+      } else if (entry.isFile() && entry.name.endsWith('.local')) {
+        const destination = join(destinationRoot, relative(sourceRoot, source))
+        prepareParent(destinationRoot, destination)
+        if (entryAt(destination)) continue
+        try { copyFileSync(source, destination, constants.COPYFILE_EXCL) } catch (error) {
+          if (error.code !== 'EEXIST') throw error
+        }
+      }
+    }
+  }
+  try { copyDirectory(sourceRoot) } catch (error) {
+    if (!error.code) throw error
+    throw new Error(`基础 setup 复制 .local 文件失败（${error.code}）；请检查 ${sourceRoot} 与 ${destinationRoot} 的文件类型和权限后重试。`)
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weotro/dx",
-  "version": "0.1.21",
+  "version": "0.2.0",
   "type": "module",
   "license": "MIT",
   "repository": {
@@ -12,13 +12,24 @@
   },
   "homepage": "https://github.com/rangershi/dx#readme",
   "bin": {
-    "dx": "bin/dx.js",
-    "dx-with-version-env": "bin/dx-with-version-env.js"
+    "dx": "bin/dx.js"
   },
   "files": [
-    "bin/",
-    "lib/",
-    "skills/",
+    "bin/dx.js",
+    "lib/logger.js",
+    "lib/version.js",
+    "lib/env.js",
+    "lib/setup.js",
+    "lib/codex-initial.js",
+    "skills",
+    "example/README.md",
+    "example/.env.development",
+    "example/dx/scripts/setup",
+    "example/dx/scripts/start",
+    "example/dx/scripts/build",
+    "example/dx/scripts/test",
+    "example/dx/scripts/db",
+    "example/dx/scripts/deploy",
     "LICENSE",
     "README.md",
     "package.json"
@@ -26,13 +37,9 @@
   "publishConfig": {
     "access": "public"
   },
-  "dependencies": {
-    "strip-json-comments": "^5.0.3",
-    "yaml": "^2.8.1"
-  },
   "devDependencies": {
     "jest": "^29.7.0",
-    "nx": "22.4.4"
+    "yaml": "^2.9.0"
   },
   "scripts": {
     "test": "NODE_OPTIONS=--experimental-vm-modules jest"
@@ -40,6 +47,13 @@
   "engines": {
     "node": ">=20.11.0"
   },
-  "nx": {},
-  "packageManager": "pnpm@10.30.0+sha512.2b5753de015d480eeb88f5b5b61e0051f05b4301808a82ec8b840c9d2adf7748eb352c83f5c1593ca703ff1017295bc3fdd3119abb9686efc96b9fcb18200937"
+  "packageManager": "pnpm@10.30.0+sha512.2b5753de015d480eeb88f5b5b61e0051f05b4301808a82ec8b840c9d2adf7748eb352c83f5c1593ca703ff1017295bc3fdd3119abb9686efc96b9fcb18200937",
+  "os": [
+    "darwin",
+    "linux"
+  ],
+  "dependencies": {
+    "dotenv": "^17.4.2",
+    "dotenv-expand": "^13.0.0"
+  }
 }

package/skills/ask_3th/SKILL.md

@@ -20,6 +20,8 @@ description: 显式调用 ask_3th 或被已授权流程调用时，向第三方
 
 仅在上述路由选择 Claude 时使用当前技能目录的 `scripts/ask_3th.py`；它固定为咨询模式，调用细节与失败状态由 `delegate_3th` 维护。脚本自身不能启动宿主 sub-agent，收到失败状态后由执行本技能的 agent 完成回退。
 
+在 Codex 宿主下默认不传模型参数，由 Claude Code CLI 按当前生效的用户/项目配置及环境变量选择模型。调用方不要补上固定模型 ID；返回中的 `requested_model: null` 表示使用 CLI 默认选择，实际模型未知时不要推测。
+
 ```bash
 python3 "$HOME/.agents/skills/ask_3th/scripts/ask_3th.py" --prompt-file /绝对路径/问题.txt
 ```

package/skills/delegate_3th/SKILL.md

@@ -42,13 +42,15 @@ python3 "$HOME/.agents/skills/delegate_3th/scripts/delegate_3th.py" --prompt-fil
 python3 "$HOME/.agents/skills/delegate_3th/scripts/delegate_3th.py" --mode task --cwd /绝对路径/工作区 --prompt-file /绝对路径/任务.txt
 ```
 
-默认请求 `claude-fable-5-1`。兼容参数 `--start-model` 仅选择本次任务请求的模型，不构成重试链。需要运行验证命令时按已有授权追加具体的 `--allow-command '仓库实际验证命令'`，可重复传入。
+默认不传 `--model`，由 Claude Code CLI 使用该次调用实际生效的用户/项目配置及环境变量选择模型；技能不硬编码模型，也不读取或覆盖模型配置。Codex 宿主下的咨询与执行均遵循此规则，用户调整 Claude Code 默认模型后，后续调用随之生效。
+
+仅在用户明确指定本次任务模型时，使用任务模式的 `--start-model <模型 ID 或别名>`；脚本将其原样传给 Claude 的 `--model`，不限制固定模型名单，也不构成重试链。需要运行验证命令时按已有授权追加具体的 `--allow-command '仓库实际验证命令'`，可重复传入。
 
 执行模式开放 `Read,Glob,Grep,Edit,Write,Bash`，使用 `acceptEdits`，无法获批的工具请求自动拒绝；现有权限规则继续生效，允许命令不是独立沙箱。两种模式关闭 hooks、MCP 和技能，因此任务书必须包含必要项目规则。脚本默认仅执行本地开发；完整交付等超出该边界的任务直接进入 fresh sub-agent，由其承接明确授权。
 
 通过宿主异步工具保留会话 ID 并持续读取结果，至少每 60 秒汇报有意义的进度。`--timeout` 只控制无活动告警，不自动终止任务。脚本通过输出字节和 Git 跟踪及未忽略文件的变化观察活动；忽略目录产物需另查，观测不可用不代表停滞。
 
-脚本 stdout 返回单个 JSON：`ok` 表示咨询已返回，`review_required` 表示任务报告待验收，`fallback_required` 表示立即进入下文回退。脚本只报告失败，启动宿主 sub-agent 和等待结果是本技能执行者的职责。
+脚本 stdout 返回单个 JSON：`ok` 表示咨询已返回，`review_required` 表示任务报告待验收，`fallback_required` 表示立即进入下文回退。`requested_model: null` 表示未覆盖 CLI 模型配置，不能据此声称实际使用了某个模型；显式指定时记录该请求值。脚本只报告失败，启动宿主 sub-agent 和等待结果是本技能执行者的职责。
 
 ### Codex 插件
 

package/skills/delegate_3th/scripts/delegate_3th.py

@@ -13,9 +13,6 @@ import sys
 import time
 
 
-MODELS = ("claude-fable-5-1", "claude-opus-5")
-
-
 def workspace_activity(cwd):
     """记录文件本身的变化，同一脏文件继续编辑也算活动。"""
     if cwd is None:
@@ -83,42 +80,42 @@ def ask(prompt, timeout=120, *, mode="consult", cwd=None, start_model=None, allo
         raise ValueError("代码任务必须指定存在的工作目录")
     if mode == "consult" and (start_model is not None or allow_commands):
         raise ValueError("咨询模式不接受任务专用参数")
-    attempts = []
+    if start_model is not None and (not isinstance(start_model, str) or not start_model.strip()):
+        raise ValueError("显式模型名称不能为空")
     cli = shutil.which("claude")
     if not cli:
         return {"status": "fallback_required", "attempts": [], "reason": "未找到 claude 命令",
                 "next_executor": "fresh_subagent", "partial_work_possible": False}
-    models = (start_model or MODELS[0],)
-    for model in models:
-        if model not in MODELS:
-            raise ValueError("模型不在委派链中")
-        print(f"正在调用 {model}（{mode}）…", file=sys.stderr, flush=True)
-        command = [
-            cli, "--print", "--model", model, "--output-format", "stream-json",
-            "--verbose", "--include-partial-messages",
-            "--strict-mcp-config", "--mcp-config", '{"mcpServers":{}}',
-            "--disable-slash-commands", "--no-session-persistence",
-            "--settings", '{"disableAllHooks":true}',
+    model = start_model
+    print(f"正在调用 {model or 'Claude Code 配置的默认模型'}（{mode}）…", file=sys.stderr, flush=True)
+    command = [
+        cli, "--print", "--output-format", "stream-json",
+        "--verbose", "--include-partial-messages",
+        "--strict-mcp-config", "--mcp-config", '{"mcpServers":{}}',
+        "--disable-slash-commands", "--no-session-persistence",
+        "--settings", '{"disableAllHooks":true}',
+    ]
+    if model is not None:
+        command += ["--model", model]
+    if mode == "consult":
+        command += ["--tools", "", "--system-prompt", "你是决策与问答顾问。根据提供的事实用简体中文回答，说明关键理由和不确定性。仅提供建议。"]
+    else:
+        command += [
+            "--tools", "Read,Glob,Grep,Edit,Write,Bash",
+            "--permission-mode", "acceptEdits", "--permission-prompts", "none",
+            "--append-system-prompt",
+            "你是协作开发者。按任务书实际修改代码并验证。你不是唯一的执行者，保留其他人的改动，遵守分配的文件范围。"
+            "先阅读适用的 AGENTS.md 和 CLAUDE.md；接续任务先检查当前状态，仅完成剩余工作。"
+            "仅执行本地开发和验证，不提交、推送、发布或对外发消息。权限被拒绝时报告具体阻塞，不尝试绕过。"
+            "完成后用简体中文报告变更文件、验证命令及结果、未完成项。",
         ]
-        if mode == "consult":
-            command += ["--tools", "", "--system-prompt", "你是决策与问答顾问。根据提供的事实用简体中文回答，说明关键理由和不确定性。仅提供建议。"]
-        else:
-            command += [
-                "--tools", "Read,Glob,Grep,Edit,Write,Bash",
-                "--permission-mode", "acceptEdits", "--permission-prompts", "none",
-                "--append-system-prompt",
-                "你是协作开发者。按任务书实际修改代码并验证。你不是唯一的执行者，保留其他人的改动，遵守分配的文件范围。"
-                "先阅读适用的 AGENTS.md 和 CLAUDE.md；接续任务先检查当前状态，仅完成剩余工作。"
-                "仅执行本地开发和验证，不提交、推送、发布或对外发消息。权限被拒绝时报告具体阻塞，不尝试绕过。"
-                "完成后用简体中文报告变更文件、验证命令及结果、未完成项。",
-            ]
-            if allow_commands:
-                command += ["--allowedTools", *[f"Bash({item})" for item in allow_commands]]
-        try:
-            process = run_task(command, prompt, timeout, cwd)
-        except OSError as error:
-            attempts.append({"requested_model": model, "reason": f"无法运行 CLI：{type(error).__name__}"})
-            break
+        if allow_commands:
+            command += ["--allowedTools", *[f"Bash({item})" for item in allow_commands]]
+    try:
+        process = run_task(command, prompt, timeout, cwd)
+    except OSError as error:
+        reason = f"无法运行 CLI：{type(error).__name__}"
+    else:
         try:
             payload = {}
             for line in process.stdout.splitlines():
@@ -136,7 +133,7 @@ def ask(prompt, timeout=120, *, mode="consult", cwd=None, start_model=None, allo
                 and isinstance(answer, str) and answer.strip()):
             return {"status": "review_required" if mode == "task" else "ok", "requested_model": model,
                     "permission_denials": len(payload.get("permission_denials") or []),
-                    "answer": answer.strip(), "attempts": attempts}
+                    "answer": answer.strip(), "attempts": []}
         # 原始错误可能包含账户信息，仅输出有界的分类原因。
         diagnostic = (process.stderr + process.stdout).lower()
         if any(word in diagnostic for word in ("quota", "credit", "usage limit", "rate_limit", "rate limit", "429")):
@@ -147,11 +144,8 @@ def ask(prompt, timeout=120, *, mode="consult", cwd=None, start_model=None, allo
             reason = "模型名称无效或当前账户无权访问"
         else:
             reason = f"CLI 未返回有效答案（退出码 {process.returncode}）"
-        attempts.append({"requested_model": model, "reason": reason})
-    result = {"status": "fallback_required", "attempts": attempts,
-              "reason": attempts[-1]["reason"], "next_executor": "fresh_subagent",
-              "partial_work_possible": mode == "task"}
-    return result
+    return {"status": "fallback_required", "attempts": [{"requested_model": model, "reason": reason}],
+            "reason": reason, "next_executor": "fresh_subagent", "partial_work_possible": mode == "task"}
 
 
 def main(argv=None):
@@ -159,7 +153,7 @@ def main(argv=None):
     parser.add_argument("--prompt-file", required=True, type=Path)
     parser.add_argument("--mode", choices=("consult", "task"), default="consult")
     parser.add_argument("--cwd", type=Path)
-    parser.add_argument("--start-model", choices=MODELS)
+    parser.add_argument("--start-model", help="仅任务模式：显式覆盖模型；省略时使用 Claude Code 配置的默认模型")
     parser.add_argument("--allow-command", action="append", default=[])
     parser.add_argument("--timeout", type=float, help="无活动告警阈值（秒），不终止或切换模型")
     args = parser.parse_args(argv)
@@ -171,6 +165,8 @@ def main(argv=None):
         parser.error("任务模式必须通过 --cwd 指定存在的工作目录")
     if args.mode == "consult" and (args.start_model or args.allow_command):
         parser.error("--start-model 和 --allow-command 仅用于任务模式")
+    if args.start_model is not None and not args.start_model.strip():
+        parser.error("--start-model 不能为空；使用默认模型时请省略此参数")
     try:
         prompt = args.prompt_file.read_text(encoding="utf-8")
         if not prompt.strip():

package/skills/delegate_3th/scripts/test_delegate_3th.py

@@ -24,12 +24,13 @@ class AskCCTest(unittest.TestCase):
     def test_cli_entrypoints_do_not_switch_models_after_idle_threshold(self):
         skills = Path(__file__).resolve().parents[2]
         entries = [
-            (skills / "ask_3th/scripts/ask_3th.py", "consult"),
-            (skills / "delegate_3th/scripts/delegate_3th.py", "consult"),
-            (skills / "delegate_3th/scripts/delegate_3th.py", "task"),
+            (skills / "ask_3th/scripts/ask_3th.py", "consult", None),
+            (skills / "delegate_3th/scripts/delegate_3th.py", "consult", None),
+            (skills / "delegate_3th/scripts/delegate_3th.py", "task", None),
+            (skills / "delegate_3th/scripts/delegate_3th.py", "task", "custom-model-alias"),
         ]
-        for entry, mode in entries:
-            with self.subTest(entry=entry, mode=mode), tempfile.TemporaryDirectory() as tmp:
+        for entry, mode, model in entries:
+            with self.subTest(entry=entry, mode=mode, model=model), tempfile.TemporaryDirectory() as tmp:
                 root = Path(tmp)
                 fake_cli = root / "claude"
                 fake_cli.write_text(
@@ -38,7 +39,7 @@ class AskCCTest(unittest.TestCase):
                     "from pathlib import Path\n"
                     "sys.stdin.read()\n"
                     "with Path(os.environ['DELEGATE_TEST_CALLS']).open('a') as log:\n"
-                    " log.write(sys.argv[sys.argv.index('--model') + 1] + '\\n')\n"
+                    " log.write(json.dumps({'args': sys.argv[1:], 'configured': os.environ.get('ANTHROPIC_MODEL')}) + '\\n')\n"
                     "time.sleep(0.2)\n"
                     "print(json.dumps({'type': 'result', 'subtype': 'success', 'result': 'done'}))\n"
                 )
@@ -47,16 +48,29 @@ class AskCCTest(unittest.TestCase):
                 prompt.write_text("test")
                 calls = root / "calls.txt"
                 env = dict(os.environ, PATH=str(root) + os.pathsep + os.environ.get("PATH", ""),
-                           DELEGATE_TEST_CALLS=str(calls))
+                           DELEGATE_TEST_CALLS=str(calls), ANTHROPIC_MODEL="user-configured-model")
                 command = [sys.executable, str(entry), "--prompt-file", str(prompt), "--timeout", "0.05"]
                 if mode == "task":
                     command += ["--mode", "task", "--cwd", tmp]
+                if model is not None:
+                    command += ["--start-model", model]
                 completed = subprocess.run(command, env=env, capture_output=True, text=True, timeout=10)
                 self.assertEqual(completed.returncode, 0, completed.stderr)
                 response = json.loads(completed.stdout)
                 self.assertEqual(response["status"], "review_required" if mode == "task" else "ok")
                 self.assertEqual(response["attempts"], [])
-                self.assertEqual(calls.read_text().splitlines(), [ask_3th.MODELS[0]])
+                self.assertEqual(response["requested_model"], model)
+                invocations = [json.loads(line) for line in calls.read_text().splitlines()]
+                self.assertEqual(len(invocations), 1)
+                invocation = invocations[0]
+                self.assertEqual(invocation["configured"], "user-configured-model")
+                actual_args = invocation["args"]
+                if model is None:
+                    self.assertNotIn("--model", actual_args)
+                else:
+                    self.assertEqual(actual_args[actual_args.index("--model") + 1], model)
+                self.assertNotIn("--setting-sources", actual_args)
+                self.assertNotIn("model", json.loads(actual_args[actual_args.index("--settings") + 1]))
                 self.assertIn("疑似停滞", completed.stderr)
 
     @patch.object(ask_3th.shutil, "which", return_value="/fake/claude")
@@ -65,6 +79,8 @@ class AskCCTest(unittest.TestCase):
             response = ask_3th.ask("修改代码", mode="task", cwd=cwd, allow_commands=["python3 -m unittest"])
         command = run.call_args.args[0]
         self.assertEqual(response["status"], "review_required")
+        self.assertIsNone(response["requested_model"])
+        self.assertNotIn("--model", command)
         self.assertEqual(command[command.index("--permission-mode") + 1], "acceptEdits")
         self.assertIn("Bash(python3 -m unittest)", command)
         self.assertNotIn("bypassPermissions", command)
@@ -87,32 +103,42 @@ class AskCCTest(unittest.TestCase):
     @patch.object(ask_3th.shutil, "which", return_value="/fake/claude")
     def test_explicit_model_failure_requests_fresh_subagent(self, _which):
         with tempfile.TemporaryDirectory() as cwd, patch.object(ask_3th, "run_task", return_value=result("usage limit", True)):
-            response = ask_3th.ask("接续", mode="task", cwd=cwd, start_model="claude-opus-5")
+            response = ask_3th.ask("接续", mode="task", cwd=cwd, start_model="custom-model-alias")
         self.assertEqual(response["status"], "fallback_required")
         self.assertEqual(response["next_executor"], "fresh_subagent")
         self.assertNotIn("next_model", response)
+        self.assertEqual(response["attempts"][0]["requested_model"], "custom-model-alias")
 
     def test_task_requires_explicit_directory(self):
         with self.assertRaises(ValueError):
             ask_3th.ask("修改代码", mode="task")
 
+    def test_empty_model_is_rejected_instead_of_overriding_cli_default(self):
+        with tempfile.TemporaryDirectory() as cwd:
+            for model in ["", " "]:
+                with self.subTest(model=model), self.assertRaises(ValueError):
+                    ask_3th.ask("修改代码", mode="task", cwd=cwd, start_model=model)
+            completed = subprocess.run([
+                sys.executable, str(Path(ask_3th.__file__)), "--mode", "task", "--cwd", cwd,
+                "--prompt-file", str(Path(cwd, "unused.txt")), "--start-model=",
+            ], capture_output=True, text=True, timeout=10)
+            self.assertEqual(completed.returncode, 2)
+            self.assertIn("--start-model 不能为空", completed.stderr)
+
     @patch.object(ask_3th.shutil, "which", return_value="/fake/claude")
     def test_first_failure_requests_fallback_without_second_model(self, _which):
         seen = []
 
         def cli(command, *args):
-            model = command[command.index("--model") + 1]
-            seen.append(model)
-            if model == "claude-fable-5-1":
-                return result("usage limit exceeded", True)
-            if model == "claude-opus-5":
-                return result("OK")
-            return result(f"There's an issue with the selected model ({model}).", True)
+            seen.append(command)
+            return result("usage limit exceeded", True)
 
         with patch.object(ask_3th, "run_task", side_effect=cli):
             response = ask_3th.ask("仅回答 OK")
         self.assertEqual(response["status"], "fallback_required")
-        self.assertEqual(seen, ["claude-fable-5-1"])
+        self.assertEqual(len(seen), 1)
+        self.assertNotIn("--model", seen[0])
+        self.assertIsNone(response["attempts"][0]["requested_model"])
         self.assertEqual(response["next_executor"], "fresh_subagent")
         self.assertEqual(response["reason"], "额度不足或限流")