draftgo-cli 3.0.51 → 3.0.52

package/README.md

@@ -6,7 +6,7 @@
 
 Pages, navigations, documents, and custom services are long-content resources. Custom services use `draftgo checkout custom-services <id>` and a four-file worktree (`service.go`, `go.mod`, `go.sum`, `service.json`). `commit` saves the shared cloud draft, `test` validates or executes it in the DraftGo Runner, and `publish` explicitly promotes a validated draft without interrupting the current live version. Start later work with `refresh`; it stops when local edits exist. Cloud versions are the only history, while local storage keeps only current content and one base.
 
-Small, single-point changes do not need Task overhead. Cross-module, cross-session, or multi-Agent work uses one authoritative `.draftgo/Task/[YYYY-MM-DD]<slug>/Task.md` and `draftgo task create|add|claim|start|complete|block|reopen|accept|finish`. The file keeps the user's original request, the clarified executable requirement, expected effects, scope, checklist, decisions, blockers, and final acceptance together. Legacy `task.yaml + plan.md + items/` tasks remain readable and migrate only through an explicit `draftgo task migrate`. CLI temporary output is registered in `.draftgo/runtime-manifest.json` under `.draftgo/tmp/` or typed `.draftgo/artifacts/`; `draftgo clean` only handles those registered files. UI smoke checks remain single viewport and use `--screenshot never` by default. Supply `on-failure` or `always` only for explicit strong visual verification.
+Small, single-point changes do not need Task overhead. Cross-module, cross-session, or multi-Agent work uses one authoritative `.draftgo/Task/[YYYY-MM-DD]<slug>/Task.md` and `draftgo task create|add|claim|start|complete|block|reopen|accept|finish`. The file keeps the user's original request, the clarified executable requirement, expected effects, scope, checklist, decisions, blockers, and final acceptance together. Legacy `task.yaml + plan.md + items/` tasks remain readable and migrate only through an explicit `draftgo task migrate`. `.draftgo/tmp/` is entirely disposable; user-facing evidence belongs in registered `.draftgo/artifacts/`, and `draftgo clean` removes all tmp plus registered artifacts. UI smoke checks remain single viewport and use `--screenshot never` by default. Supply `on-failure` or `always` only for explicit strong visual verification.
 
 面向 AI 编码工具的 DraftGo 工作台 CLI：分发 DraftGo Skill，通过 MCP 发现和操作实时资源，并为页面、导航和文档提供可校验的 `checkout` / `commit` 工作流。
 
@@ -80,7 +80,7 @@ draftgo connect codex --server https://draftgo.example --token "$DRAFTGO_SAT"
 
 `--server` 始终表示 DraftGo 基础地址。直接连接 MCP endpoint 时使用 `--mcp-url https://draftgo.example/mcp`；CLI 会显式保存 `mcp_url`，若未同时传 `--server`，则从标准 `/mcp` 后缀推导基础地址，避免猜测已有 base URL 的语义。
 
-`connect` 会先验证 SAT、MCP `initialize`、`tools/list` 和关键 `tools/call`，成功后写入项目私有配置 `.draftgo/config.json`，并尝试为指定或自动检测到的宿主执行 MCP setup。它不会 pull 页面、导航、文档或任何其他业务资源。
+`connect` 会先验证 SAT、MCP `initialize`、`tools/list` 和关键 `tools/call`，成功后写入项目私有配置 `.draftgo/config.json`，并尝试为指定或自动检测到的宿主执行 MCP setup。`init` / `connect` 不会预建 Task、lessons、changelog、worktree、conflicts 等运行时内容；这些文件和目录只在对应能力首次使用时按需创建。它不会 pull 页面、导航、文档或任何其他业务资源。
 
 远端暂不可用时，只有显式传入 `--allow-offline` 才会保存配置；恢复后运行 `draftgo mcp test`。使用 `--no-mcp-setup` 可跳过宿主配置。
 
@@ -178,8 +178,7 @@ draftgo context --task frontend --output json
 draftgo checkout pages 42 43
 # 独立资源可并行编辑；同一资源只由一个 Agent 修改
 draftgo check
-draftgo check --remote                  # 交付前按需对比远端版本/hash
-draftgo verify-ui http://localhost:5173       # UI 变更时
+draftgo verify pages 42 --remote --url http://localhost:5173/example
 draftgo diff pages 42
 draftgo diff pages 43
 draftgo commit pages 42 43
@@ -213,13 +212,14 @@ draftgo changelog add "完成文档管理系统及角色权限"
 | `draftgo map` | 并行读取 pages、navigations、docs/articles 元数据，再叠加本地 checkout 状态；`--type` 可限制一种类型。 |
 | `draftgo checkout <pages|nav|docs> <id...>` | 下载完整正文和 base，校验 hash 后原子落盘；`--force` 可显式覆盖已修改的本地正文。 |
 | `draftgo check` | 默认只检查本地 checkout；`--remote` 额外对比 local/base/manifest/remote 的版本和 hash。 |
+| `draftgo verify [<type> <id...>]` | 统一执行静态检查；`--remote` 增加远端比较，`--url` 增加 iframe-aware 浏览器验证。 |
 | `draftgo diff <pages|nav|docs> <id>` | 显示 checkout base 与当前本地正文的差异。 |
 | `draftgo commit <pages|nav|docs> <id...>` | 本地校验后，通过专用 HTTP 上传完整正文并更新 base/manifest。 |
 | `draftgo reconcile <pages|nav|docs> <id...>` | 仅当 local 与经校验的 remote 字节一致时，安全修复落后的 base/manifest 元数据。 |
 | `draftgo conflicts` | 列出未解决冲突；存在冲突时返回非零。`--all` 包括已解决记录。 |
 | `draftgo conflict show <type> <id>` | 显示冲突的 base/local/remote/worktree 路径。 |
 | `draftgo conflict resolve <type> <id>` | 确认 worktree 已合并，把保留的 remote 设为新 base；随后重新 check、diff、commit。 |
-| `draftgo verify-ui <url>` | 使用 Playwright 执行确定性的浏览器 smoke check。 |
+| `draftgo verify-ui <url>` | `verify --url <url> --ui always` 的弃用兼容入口。 |
 
 `pages`、`page`，`nav`、`navigation`、`navigations`，以及 `docs`、`doc`、`article`、`articles`、`docs/articles` 都会规范化到三个支持的正文类型。
 
@@ -316,7 +316,7 @@ checkout 会通过 MCP 获取元数据和专用下载地址，流式写入临时
 1. `draftgo conflict show <type> <id>` 定位三份材料和 worktree 文件。
 2. 在 worktree 文件中人工或借助可靠的三方合并工具完成合并。
 3. `draftgo conflict resolve <type> <id>` 校验 worktree，并把冲突时保存的 remote 版本设为新 base。
-4. 重新运行 `draftgo check`、必要时 `verify-ui`、`draftgo diff`，最后 `draftgo commit`。
+4. 重新运行 `draftgo check`、必要时 `draftgo verify`、`draftgo diff`，最后 `draftgo commit`。
 
 ## map 与 check 输出
 
@@ -332,7 +332,11 @@ checkout 会通过 MCP 获取元数据和专用下载地址，流式写入临时
 }
 ```
 
-`draftgo check --output json` 返回 `{ map, errors, warnings, warningDetails, remote, remote_error, legacy_cache_ignored }`。`--strict` 会把 warnings 也视为失败。默认 `check` 不访问远端；显式使用 `--remote` 时读取每个 checkout 的实时 metadata，并把 `committed_unrecorded` 等可恢复状态指向 `draftgo reconcile`。它始终不会读取旧全量资源索引。
+`draftgo check --output json` 返回结构化的本地、远端和工作区检查结果。它以声明的 charset（默认 UTF-8）严格解码 HTML，并在内存中检查内联 JavaScript，错误直接映射到原 HTML 行列，不生成 `.draftgo/tmp/syntax/*.js`。`--strict` 会把 warnings 也视为失败。默认 `check` 不访问远端；显式使用 `--remote` 时读取实时 metadata，并把 `committed_unrecorded` 等可恢复状态指向 `draftgo reconcile`。
+
+`draftgo verify` 是交付前统一入口。无参数时只运行快速本地 `check`；`--remote` 才联网，`--url` 才启动浏览器。浏览器检查默认使用 `--frame auto`，同时检查顶层页面和可见 iframe，因此 `--selector` 可匹配 `iframe.srcdoc` 中的业务 DOM。`--viewport mobile|desktop|both` 控制目标视口，截图默认关闭。
+
+`.draftgo/tmp/` 是统一临时区，CLI 和 AI 产生的可丢弃中间文件必须位于 `.draftgo/tmp/<owner>/<run-id>/`；AI 自建文件使用 `.draftgo/tmp/ai/<run-id>/`。`draftgo clean --dry-run` 会列出全部 tmp 文件和已注册 artifacts，`draftgo clean --yes` 负责回收并删除空运行目录。需要保留供用户查看的截图或报告应进入 `.draftgo/artifacts/`，而不是 tmp。
 
 ## Skill 与领域约定
 
@@ -364,10 +368,12 @@ checkout 会通过 MCP 获取元数据和专用下载地址，流式写入临时
 - `--mcp-url <url>`：为 connect 显式指定完整 MCP endpoint；标准 `/mcp` 可自动推导基础地址，自定义路径需同时传 `--server`。
 - `--allow-offline` / `--no-mcp-setup`：允许 connect 在 MCP 暂不可用时保存，或跳过宿主配置。
 - `--yes`：跳过支持该选项的交互确认。
-- `--mobile-check auto|always|never`：控制 `verify-ui` 是否执行。
-- `--resource <type:id>`：verify-ui 打开 URL 前对比本地 checkout 与远端已提交版本，并明确报告实际验证来源。
-- `--browser-path <file>`：verify-ui 显式使用浏览器可执行文件；也可设置 `DRAFTGO_BROWSER_PATH`，否则自动查找系统浏览器和 Playwright 缓存。
-- `--token auto|never`：`verify-ui` 默认读取 `.draftgo/config.json`，对与 `server` 同源的地址自动附加 `token=<SAT>`；配置无 SAT、跨源地址或 `never` 模式均不附加。
+- `--ui auto|always|never`：控制 verify 的浏览器验证；默认 auto，只在提供 `--url` 时运行。
+- `--viewport mobile|desktop|both`：控制 verify 的目标视口；不传时使用 `--width/--height` 或 390x844。
+- `--frame auto|top|all|<iframe-selector>`：控制 verify 检查哪些 frame；默认检查顶层与可见 iframe。
+- `--resource <type:id>`：兼容入口使用；推荐直接写 `draftgo verify pages 42 --url ...`。
+- `--browser-path <file>`：verify 显式使用浏览器可执行文件；也可设置 `DRAFTGO_BROWSER_PATH`，否则自动查找系统浏览器和 Playwright 缓存。
+- `--token auto|never`：verify 默认读取 `.draftgo/config.json`，对与 `server` 同源的地址自动附加 `token=<SAT>`；配置无 SAT、跨源地址或 `never` 模式均不附加。
 - `--screenshot on-failure|always|never`：控制 UI 截图。
 - `--delivery local|preview|deploy`：控制 deploy 行为。
 - `--timeout <ms>`：控制 connect、MCP test 或 context 的远端请求超时。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "draftgo-cli",
-  "version": "3.0.51",
+  "version": "3.0.52",
   "description": "Install and manage the DraftGo skill across AI coding agents (Claude Code, Codex, Cursor, Windsurf, Antigravity, Copilot, Gemini, Kiro).",
   "bin": {
     "draftgo": "bin/draftgo.js"

package/resources/skill/SKILL.md

@@ -9,8 +9,8 @@ description: Use this skill to inspect, develop, debug, or deliver a DraftGo app
 - `context` schema 2.0 separates `bundled_references` from `live_project`, `live_resources`, `live_apis`, and complete `live_db_meta`. It is stdout-only by default and has no persistent or delta cache.
 - Custom-service flow: `context --task custom-service` -> `checkout custom-services` -> edit four files -> `commit` cloud draft -> `test` in the server Runner -> `check --remote` -> `publish` -> `refresh`. CLI and admin UI edit the same cloud draft.
 - Do not create Task overhead for a small, single-point change. For cross-module, cross-session, or multi-Agent work, create or resume `.draftgo/Task/[YYYY-MM-DD]<slug>/Task.md`. It is the only task state: preserve both the user's original request and the clarified executable requirement, assign one owner per item/resource, and check an item only with verification evidence. Changelog remains the final delivery record, not a task tracker.
-- Normal UI work uses lightweight single-viewport `verify-ui` with no screenshot. Only explicit visual acceptance or regression diagnosis may pass `--screenshot on-failure|always`.
-- CLI temporary data belongs under registered `.draftgo/tmp/` or `.draftgo/artifacts/`; use `draftgo clean --dry-run` before `draftgo clean --yes`.
+- Normal delivery uses `draftgo verify`; add `--remote` only when remote comparison is required and `--url` only for browser evidence. UI verification is iframe-aware and defaults to one viewport with no screenshot. Only explicit visual acceptance or regression diagnosis may pass `--viewport both` or `--screenshot on-failure|always`.
+- `.draftgo/tmp/` is entirely disposable. CLI data uses `.draftgo/tmp/<command>/<run-id>/`; AI-created scratch files use `.draftgo/tmp/ai/<run-id>/`. User-facing evidence belongs under registered `.draftgo/artifacts/`. Use `draftgo clean --dry-run` before `draftgo clean --yes`.
 
 # DraftGo 开发助手
 
@@ -59,8 +59,8 @@ context 会校验本地 Reference，返回逐字章节、来源、实时项目/
 
 1. MCP 定位 pages/nav/docs 并读取 metadata。
 2. 批量 checkout；在 `.draftgo/worktree/` 按唯一 owner 编辑。
-3. 主 Agent 回读全部修改，统一运行 `draftgo check`；交付前需要核对远端版本时运行 `draftgo check --remote`。
-4. 用 `draftgo diff <type> <id>` 检查 base/local 差异，再按类型运行 `draftgo commit ...`。页面布局或交互变化时在 commit 后用 `draftgo verify-ui <url> --resource <type:id>` 验证远端已提交版本。
+3. 主 Agent 回读全部修改，编辑过程中统一运行一次快速 `draftgo check`。交付前运行 `draftgo verify <type> <id...>`；需要远端证据时加 `--remote`，页面布局或交互变化时加对应 `--url`。
+4. 用 `draftgo diff <type> <id>` 检查 base/local 差异，再按类型运行 `draftgo commit ...`。commit 后需要验证远端页面时运行 `draftgo verify <type> <id> --remote --url <url>`。
 5. 409/412 时停止自动提交，保留 base/local/remote 冲突材料；不得 force、覆盖或自动合并。
 
 完整 manifest、流式传输、哈希和冲突规则见 `references/checkout.md`。
@@ -93,10 +93,10 @@ draftgo changelog add "<完成结果>"
 | 范围 | 最低证据 |
 |---|---|
 | MCP 连接 | 失败时用 `draftgo mcp test` 核对 initialize、tools/list 和关键工具；输出不含 SAT |
-| 页面、导航、文档 | checkout manifest、`draftgo check`、必要的 `verify-ui`、diff、commit 返回版本与哈希 |
+| 页面、导航、文档 | checkout manifest、`draftgo check`、交付前 `draftgo verify`、diff、commit 返回版本与哈希 |
 | 结构化资源 | search/describe 契约、call 结果与回读的权限、字段、错误和副作用 |
 | 自定义服务 | 动态 Route describe、无副作用健康请求或目标行为结果，以及管理员调用审计 |
-| 冲突 | `.draftgo/conflicts/` 的 base/local/remote；解决后重新 check、必要的 verify-ui 和 commit |
+| 冲突 | `.draftgo/conflicts/` 的 base/local/remote；解决后重新 check、必要的 verify 和 commit |
 | 本地底座 | `draftgo local status`、日志和相关 local 测试 |
 
 `draftgo deploy`、`auto-push` 和兼容 `push pages|nav|docs` 只能沿用当前 check/commit 语义，不能恢复旧的全量 push。主 Agent 最终明确区分 Skill 约束、MCP 实时状态和 checkout 正文证据。

package/resources/skill/init/SKILL.md

@@ -21,6 +21,8 @@ description: Install or refresh the DraftGo skill, connect a project to a DraftG
 
 draftgo init 只负责 Skill 安装；draftgo connect 负责保存并验证 server/SAT；draftgo mcp setup 负责宿主配置。不要混用职责。
 
+初始化后 `.draftgo/` 只保留已经写入的 `config.json`。不要预建 Task、lessons、changelog、worktree、conflicts 或其他占位文件和目录；首次实际使用对应能力时再创建。
+
 ## SAT 与配置
 
 - 交互式连接应使用隐藏输入；不要把 SAT 写入宿主配置、Skill 文件、命令行示例或日志。
@@ -33,7 +35,7 @@ draftgo init 只负责 Skill 安装；draftgo connect 负责保存并验证 serv
 - 宿主配置和诊断：draftgo mcp setup/status/test，详见 ../references/mcp.md。
 - 开发上下文：先运行匹配领域的 `draftgo context --task <task> --output json`；context 后仍可按需直接调用 MCP。
 - 远端资源补充定位：MCP project_overview、resource_search、resource_list。
-- 正文编辑：自主设计并批量 checkout，不同资源按唯一 owner 并行修改，由主 Agent 统一运行 check/必要的 verify-ui、diff 和 commit。
+- 正文编辑：自主设计并批量 checkout，不同资源按唯一 owner 并行修改，由主 Agent 统一运行 check、交付前 verify、diff 和 commit。
 - 结构化资源：直接使用 MCP 的 api_search、api_describe、api_call；不 checkout、不生成本地镜像。
 - 完成日志：只有整个任务统一验证且全部 commit/MCP 交付成功后，由主 Agent 执行一次 `draftgo changelog add "<完成结果>"`；验证、冲突或交付失败时不得写入。
 - 管理本地基座：draftgo local start|stop|logs|status；local-dev、local up/down 仍可用。

package/resources/skill/manifest.json

@@ -2,7 +2,7 @@
   "schema_version": "1.0",
   "id": "draftgo",
   "name": "DraftGo 开发助手",
-  "version": "3.0.51",
+  "version": "3.0.52",
   "entry": "SKILL.md",
   "description": "以 context 聚合编排、Skill/reference 原文、MCP 实时发现、长正文 checkout/commit、统一验证和完成日志为边界的 DraftGo 工作流。",
   "license": "MIT",

package/resources/skill/references/checkout.md

@@ -93,12 +93,12 @@ base 已变化时必须拒绝覆盖。
 ## Commit 流程
 
 1. 读取 manifest 指向的 worktree 文件，计算当前字节数和 SHA-256；未变化时返回 `unchanged`。
-2. 按 content_type 执行本地结构检查；页面布局或交互有变化时另外运行 `draftgo verify-ui`。
+2. 按 content_type 执行本地结构和内联脚本检查；页面布局或交互有变化时运行 `draftgo verify <type> <id> --url <url>`。
 3. 通过专用 HTTP 流式上传原始文件，携带 `If-Match`、base version/revision、content_type、长度和 SHA-256。
 4. 完整正文不得作为 MCP tool 参数发送。
 5. 底座确认 hash 和新版本后，CLI 原子更新 `.base` 与 manifest。返回 hash 不一致时不得推进基线。
 
-推荐编辑顺序：主 Agent 执行一次 context -> MCP 按需补充定位 -> Agent 自主设计并批量 checkout -> 独立资源按唯一 owner 并行编辑 -> 主 Agent 汇总回读 -> 统一运行一次 `draftgo check` -> `draftgo diff` -> commit -> 页面变化时用 `draftgo verify-ui <url> --resource <type:id>` 验证远端已提交版本。遇到本地正文已经等于远端、但 base/manifest 落后时，先用 `draftgo check --remote` 确认 `committed_unrecorded`，再运行 `draftgo reconcile`；不要手改 manifest。
+推荐编辑顺序：主 Agent 执行一次 context -> MCP 按需补充定位 -> Agent 自主设计并批量 checkout -> 独立资源按唯一 owner 并行编辑 -> 主 Agent 汇总回读 -> 统一运行一次 `draftgo check` -> `draftgo diff` -> commit -> 页面变化时用 `draftgo verify <type> <id> --remote --url <url>` 验证远端已提交版本。遇到本地正文已经等于远端、但 base/manifest 落后时，先用 `draftgo check --remote` 确认 `committed_unrecorded`，再运行 `draftgo reconcile`；不要手改 manifest。
 
 单个 commit 成功不自动写 changelog。只有整个任务统一验证且全部 commit/MCP 交付成功后，主 Agent 才执行一次 `draftgo changelog add "<完成结果>"`。任何检查失败、409/412 或交付失败都不得写入。
 
@@ -117,7 +117,7 @@ base 已变化时必须拒绝覆盖。
 - `base` 是 checkout 时的内容；`local` 是发生冲突时的本地快照；`remote` 是重新下载并校验的当前远端内容。
 - `conflict.json` 记录三份路径、版本、ETag 和哈希，不嵌入完整正文。
 - Agent 或用户在 worktree local 文件中完成合并；不要手写 HTML 自动合并器，也不要改动保存的三份证据。
-- 合并完成后运行 `draftgo check`、必要时 `draftgo verify-ui`，再执行 `draftgo conflict resolve <type> <id>`。
+- 合并完成后运行 `draftgo check`、必要时 `draftgo verify`，再执行 `draftgo conflict resolve <type> <id>`。
 - resolve 校验 worktree 与 remote，采用 remote 版本作为新的 base，但保留合并后的 worktree；随后运行
   `draftgo diff` 并 `draftgo commit`。
 

package/resources/skill/references/frontend.md

@@ -68,7 +68,7 @@ version: 2.0.0
 - 表格、代码和其他超宽内容应在合理边界内可访问，不能让核心操作因溢出而不可达。
 - 弹窗和抽屉在目标视口内完整可用，长内容有明确滚动边界。
 
-需要浏览器证据时按页面受众和现有断点运行 `draftgo verify-ui <url> --mobile-check auto`；不要机械遍历与任务无关的视口。
+需要浏览器证据时按页面受众和现有断点运行 `draftgo verify <type> <id> --url <url>`；只有验收确实覆盖多端时加 `--viewport both`，不要机械遍历与任务无关的视口。业务 HTML 位于 iframe 时默认 `--frame auto` 会检查顶层和可见 iframe，`--selector` 可直接定位业务 DOM。
 
 ### 导航与系统页边界（强制）
 

package/src/cli.js

@@ -15,6 +15,9 @@ const VALUE_FLAGS = new Set([
   'browser-path',
   'resource',
   'mobile-check',
+  'ui',
+  'frame',
+  'viewport',
   'screenshot',
   'selector',
   'width',

package/src/commandRegistry.js

@@ -13,7 +13,8 @@ const commands = [
   { name: 'clean', run: (dir, args, flags) => require('./commands/clean')(dir, args, flags) },
   { name: 'map', run: (dir, _args, flags) => require('./commands/map')(dir, flags) },
   { name: 'check', run: (dir, args, flags) => require('./commands/check')(dir, args, flags) },
-  { name: 'verify-ui', aliases: ['verifyui'], run: (dir, args, flags) => require('./commands/verifyUi')(dir, args, flags) },
+  { name: 'verify', run: (dir, args, flags) => require('./commands/verify')(dir, args, flags) },
+  { name: 'verify-ui', aliases: ['verifyui'], run: (dir, args, flags) => require('./commands/verifyUiCompat')(dir, args, flags) },
   { name: 'mcp', run: (dir, args, flags) => require('./commands/mcp')(dir, args, flags) },
   { name: 'checkout', run: (dir, args, flags) => require('./commands/checkout')(dir, args, flags) },
   { name: 'refresh', run: (dir, args, flags) => require('./commands/checkout')(dir, args, flags) },

package/src/commands/check.js

@@ -27,7 +27,15 @@ async function check(projectDir, positional = [], flags = {}) {
     log.err('Usage: draftgo check custom-services <id...> [--remote]');
     return 1;
   }
-  const result = analyzeProject(projectDir);
+  const resourceKeys = flags.resourceKeys || null;
+  const result = analyzeProject(projectDir, { resourceKeys });
+  if (resourceKeys) {
+    const manifestKeys = new Set(Object.keys(result.map.checkouts.reduce((entries, entry) => {
+      entries[`${entry.resource_type}:${entry.resource_id}`] = true;
+      return entries;
+    }, {})));
+    for (const key of resourceKeys) if (!manifestKeys.has(key)) result.errors.push(`${key}: resource is not checked out`);
+  }
   const hygiene = workspaceHealth(projectDir);
   hygiene.warnings.forEach((warning) => result.warningDetails.push({ code: warning.code, confidence: 'high', message: `${warning.path}${warning.size ? ` (${warning.size} bytes)` : ''}` }));
   hygiene.warnings.forEach((warning) => result.warnings.push(`${warning.code}: ${warning.path}`));
@@ -35,7 +43,7 @@ async function check(projectDir, positional = [], flags = {}) {
   const customServiceChecks = [];
   const requested = new Set(requestedIds.map(String));
   const serviceEntries = Object.values(serviceManifest.entries)
-    .filter((entry) => !requestedType || requested.has(String(entry.resource_id)));
+    .filter((entry) => !resourceKeys && (!requestedType || requested.has(String(entry.resource_id))));
   if (requestedType) {
     for (const id of requested) {
       if (!serviceEntries.some((entry) => String(entry.resource_id) === id)) {
@@ -56,8 +64,12 @@ async function check(projectDir, positional = [], flags = {}) {
   if (flags.remote) {
     try {
       const [contentRemote, serviceRemote] = await Promise.all([
-        inspectRemoteCheckouts(projectDir),
-        customServices.inspectRemote(projectDir, requestedType ? { ids: [...requested] } : {}),
+        inspectRemoteCheckouts(projectDir, resourceKeys ? {
+          entries: result.map.checkouts.filter((entry) => resourceKeys.includes(`${entry.resource_type}:${entry.resource_id}`)),
+        } : {}),
+        resourceKeys
+          ? Promise.resolve([])
+          : customServices.inspectRemote(projectDir, requestedType ? { ids: [...requested] } : {}),
       ]);
       remote = requestedType
         ? serviceRemote.filter((entry) => requested.has(String(entry.resource_id)))
@@ -87,9 +99,12 @@ async function check(projectDir, positional = [], flags = {}) {
   }
 
   log.title('draftgo check');
-  log.info(`Checked-out pages: ${result.map.pages.length}`);
-  log.info(`Checked-out navigations: ${result.map.navigations.length}`);
-  log.info(`Checked-out docs: ${result.map.docs.length}`);
+  const selectedCount = (type, entries) => resourceKeys
+    ? entries.filter((entry) => resourceKeys.includes(`${type}:${entry.resource_id}`)).length
+    : entries.length;
+  log.info(`Checked-out pages: ${selectedCount('pages', result.map.pages)}`);
+  log.info(`Checked-out navigations: ${selectedCount('navigations', result.map.navigations)}`);
+  log.info(`Checked-out docs: ${selectedCount('docs', result.map.docs)}`);
   log.info(`Checked-out custom services: ${customServiceChecks.length}`);
   log.info(`Workspace: ${hygiene.managed_files} managed, ${hygiene.unknown_files} unknown, ${hygiene.temporary_files} temporary, ${hygiene.artifact_files} artifact file(s)`);
   log.info(`Workspace size: ${hygiene.total_bytes} bytes; reclaimable: ${hygiene.reclaimable_bytes} bytes`);

package/src/commands/clean.js

@@ -23,6 +23,24 @@ function plan(projectDir, flags = {}) {
     const stat = fs.statSync(absolute); if (age && now - stat.mtimeMs < age) continue;
     candidates.push({ ...entry, absolute, size: stat.isFile() ? stat.size : 0, reason: 'runtime_manifest' });
   }
+  const tmp = path.resolve(root, 'tmp');
+  if (fs.existsSync(tmp) && runtime.inside(root, tmp) && (!types.size || types.has('tmp') || types.has('ai'))) {
+    const visitTmp = (current) => {
+      for (const child of fs.readdirSync(current, { withFileTypes: true })) {
+        const absolute = path.join(current, child.name);
+        if (child.isDirectory()) visitTmp(absolute);
+        else if (child.isFile() && !candidates.some((entry) => entry.absolute === absolute)) {
+          const stat = fs.statSync(absolute);
+          if (!age || now - stat.mtimeMs >= age) candidates.push({
+            path: path.relative(root, absolute).replace(/\\/g, '/'), absolute,
+            type: path.relative(tmp, absolute).replace(/\\/g, '/').startsWith('ai/') ? 'ai' : 'tmp',
+            size: stat.size, reason: 'temporary_area',
+          });
+        }
+      }
+    };
+    visitTmp(tmp);
+  }
   if (flags['all-artifacts']) {
     for (const prefix of MANAGED_PREFIXES.filter((item) => item.startsWith('artifacts/'))) {
       const directory = path.resolve(root, prefix); if (!runtime.inside(root, directory) || !fs.existsSync(directory)) continue;
@@ -39,6 +57,14 @@ async function clean(projectDir, _positional, flags = {}) {
   if (!flags.yes || flags['dry-run']) { if (!flags.output) log.dim('Run with --yes to delete this plan.'); return 0; }
   const manifest = runtime.load(projectDir); const removed = new Set();
   for (const entry of result.entries) { if (!runtime.inside(runtime.draftgoRoot(projectDir), entry.absolute)) throw new Error('Clean target escaped .draftgo.'); fs.rmSync(entry.absolute, { force: true }); removed.add(entry.path); }
+  const tmp = path.join(runtime.draftgoRoot(projectDir), 'tmp');
+  if (fs.existsSync(tmp)) {
+    const removeEmpty = (directory) => {
+      for (const child of fs.readdirSync(directory, { withFileTypes: true })) if (child.isDirectory()) removeEmpty(path.join(directory, child.name));
+      if (directory !== tmp && fs.readdirSync(directory).length === 0) fs.rmdirSync(directory);
+    };
+    removeEmpty(tmp);
+  }
   manifest.entries = manifest.entries.filter((entry) => !removed.has(entry.path)); runtime.save(projectDir, manifest);
   if (!flags.output) log.ok(`Deleted ${result.count} managed file(s).`); return 0;
 }

package/src/commands/help.js

@@ -47,6 +47,8 @@ Usage:
   draftgo check [custom-services <id...>]
                                     Validate all checkouts or selected custom services.
                                     --remote also compares remote hash/version.
+  draftgo verify [<type> <id...>]   Run unified static verification; --remote adds
+                                    remote comparison and --url enables UI checks.
   draftgo diff <type> <id>         Show checkout base versus local body.
   draftgo commit <type> <id...>    Validate and upload complete checked-out bodies.
   draftgo refresh <type> <id...>   Safely refresh a clean checkout from the cloud.
@@ -63,9 +65,8 @@ Usage:
   draftgo conflict resolve <type> <id>
                                     Mark a merged worktree file ready against the
                                     preserved remote base; then check/diff/commit.
-  draftgo verify-ui <url>          Run a deterministic browser smoke check.
-                                    Screenshots default to never.
-  draftgo clean [--dry-run|--yes]  Plan or remove registered tmp/artifacts only.
+  draftgo verify-ui <url>          Deprecated alias for verify --url <url> --ui always.
+  draftgo clean [--dry-run|--yes]  Plan or remove all tmp and registered artifacts.
   draftgo task <operation> [...]   Track sustained work in one authoritative Task.md.
                                     Operations: create, list, show, add, claim,
                                     start, complete, block, reopen, accept, finish,
@@ -137,16 +138,20 @@ Important flags:
                            (custom-service test) deny | mock | live; default deny.
   --delivery <mode>        (deploy) local | preview | deploy.
   --dry-run                (push) Show diffs without committing.
-  --mobile-check <mode>    (verify-ui) auto | always | never.
-  --token <mode>           (verify-ui) auto | never; auto appends the configured
+  --ui <mode>              (verify) auto | always | never; auto runs with --url.
+  --remote                 (check/verify) Compare checkout hashes with remote.
+  --viewport <mode>        (verify) mobile | desktop | both.
+  --frame <mode>           (verify) auto | top | all | <iframe-selector>.
+  --mobile-check <mode>    (verify-ui compatibility) auto | always | never.
+  --token <mode>           (verify) auto | never; auto appends the configured
                            SAT to same-origin URLs as the token query parameter.
-  --screenshot <mode>      (verify-ui) on-failure | always | never; default never.
-  --browser <name>         (verify-ui) chromium | chrome | msedge.
-  --browser-path <file>    (verify-ui) Explicit browser executable; environment
+  --screenshot <mode>      (verify) on-failure | always | never; default never.
+  --browser <name>         (verify) chromium | chrome | msedge.
+  --browser-path <file>    (verify) Explicit browser executable; environment
                            fallback: DRAFTGO_BROWSER_PATH.
-  --resource <type:id>     (verify-ui) Compare local and remote content first.
-  --selector <css>         (verify-ui) Require a visible key element.
-  --width/--height <px>    (verify-ui) Override the default 390x844 viewport.
+  --resource <type:id>     (verify compatibility) Assert one remote UI resource.
+  --selector <css>         (verify) Require a visible element in top or iframe DOM.
+  --width/--height <px>    (verify) Override the default 390x844 viewport.
 
 Security:
   .draftgo/config.json stores the server and SAT and is gitignored. Host MCP
@@ -166,6 +171,7 @@ Examples:
   draftgo map --output json
   draftgo checkout pages 42
   draftgo check --strict
+  draftgo verify pages 42 --remote --url http://localhost:5173/example
   draftgo diff pages 42
   draftgo commit pages 42
   draftgo changelog add "Complete document management and role permissions"

package/src/commands/init.js

@@ -4,7 +4,7 @@ const path = require('path');
 const log = require('../logger');
 const { detectTargets } = require('../detect');
 const { resolveTargets, all } = require('../installers');
-const { ensureRuntime, writeInstalledVersion, getPackageVersion } = require('../skill');
+const { ensureRuntime, getPackageVersion } = require('../skill');
 const { exists } = require('../fsx');
 const { ask } = require('../prompt');
 
@@ -65,8 +65,7 @@ async function init(projectDir, positional, flags) {
     log.err(`安装未完成，失败目标：${failures.join(', ')}`);
     return 1;
   }
-  if (installedCount > 0 && skippedCount === 0) writeInstalledVersion(projectDir);
-  if (skippedCount > 0) log.dim('  存在未覆盖目标，未更新全局 skill 版本标记；运行 draftgo update 可统一刷新。');
+  if (skippedCount > 0) log.dim('  存在未覆盖目标；运行 draftgo update 可统一刷新。');
   log.dim(`  CLI 版本：${getPackageVersion()}`);
 
   // 3) Environment check (advisory).

package/src/commands/task.js

@@ -75,7 +75,7 @@ function lines(value, fallback = '- 暂无。') {
 
 function template(task) {
   return `# ${task.title}\n\n`+
-    `- 状态：active\n- 创建时间：${task.created_at}\n- 更新时间：${task.updated_at}\n- 任务负责人：${task.owner}\n\n`+
+    `- 状态：active\n- 创建时间：${task.created_at}\n- 更新时间：${task.updated_at}\n\n`+
     `## 用户原始需求\n\n${task.original_requirement}\n\n`+
     `## 明确后的需求\n\n${task.clarified_requirement}\n\n`+
     `## 预计效果\n\n${lines(task.expected_effect)}\n\n`+
@@ -134,7 +134,7 @@ function parseMarkdown(file, id) {
   const acceptance = parseChecklist(section(body, '最终验收'), true);
   return {
     schema_version: 2, format: 'markdown', id, title, status: metadata(body, '状态') || 'active',
-    created_at: metadata(body, '创建时间'), updated_at: metadata(body, '更新时间'), owner: metadata(body, '任务负责人'),
+    created_at: metadata(body, '创建时间'), updated_at: metadata(body, '更新时间'),
     original_requirement: section(body, '用户原始需求'), clarified_requirement: section(body, '明确后的需求'),
     expected_effect: section(body, '预计效果'), scope: section(body, '本次范围'), out_of_scope: section(body, '不在本次范围'),
     decisions: section(body, '关键决策'), blockers: section(body, '阻塞问题'), items, acceptance,
@@ -191,12 +191,6 @@ function print(flags, value) {
   if (flags.output === 'json') console.log(JSON.stringify(Array.isArray(value) ? value.map(publicTask) : publicTask(value), null, 2));
 }
 function taskActor(flags) { return String(flags.owner || flags.assignee || process.env.DRAFTGO_AGENT_ID || '').trim(); }
-function requireOwner(task, flags, operation) {
-  if (!task.owner) return;
-  const actor = taskActor(flags);
-  if (!actor) throw new Error(`Task ${task.id} ${operation} requires owner identity ${task.owner}.`);
-  if (actor !== task.owner) throw new Error(`Task ${task.id} ${operation} can only be performed by owner ${task.owner}.`);
-}
 function assertModern(task, operation) {
   if (task.format === 'legacy') throw new Error(`Legacy Task ${task.id} is read-only; run task migrate ${task.id} before ${operation}.`);
 }
@@ -245,7 +239,7 @@ function create(projectDir, positional, flags) {
   if (!clarified) throw new Error('task create requires --clarified with the executable requirement.');
   if (!expected) throw new Error('task create requires --expected-effect.');
   const id = uniqueTaskId(projectDir, title, flags); const now = new Date().toISOString();
-  const task = { id, title, created_at: now, updated_at: now, owner: taskActor(flags), original_requirement: original, clarified_requirement: clarified,
+  const task = { id, title, created_at: now, updated_at: now, original_requirement: original, clarified_requirement: clarified,
     expected_effect: expected, scope: field(flags, ['scope']), out_of_scope: field(flags, ['out-of-scope']) };
   fs.mkdirSync(taskDir(projectDir, id), { recursive: true }); atomicWrite(markdownFile(projectDir, id), template(task));
   const loaded = loadTask(projectDir, id); print(flags, loaded); if (flags.output !== 'json') log.ok(`Created task ${id}`); return 0;
@@ -279,7 +273,7 @@ function nextItemId(items) {
 function add(projectDir, taskId, positional, flags) {
   const resolved = resolveTaskId(projectDir, taskId);
   return withLock(projectDir, resolved, (before) => {
-    const task = loadTask(projectDir, resolved); assertModern(task, 'add'); requireOwner(task, flags, 'planning');
+    const task = loadTask(projectDir, resolved); assertModern(task, 'add');
     const title = field(flags, ['title'], positional.join(' ')); const content = field(flags, ['content']); const acceptance = field(flags, ['acceptance']);
     const owner = field(flags, ['assignee'], taskActor(flags));
     if (!title) throw new Error('task add requires a title or --title.');
@@ -343,7 +337,7 @@ function accept(projectDir, taskId, positional, flags) {
   const resolved = resolveTaskId(projectDir, taskId); const title = field(flags, ['item'], positional.join(' '));
   if (!title) throw new Error('task accept requires a final acceptance item title.');
   return withLock(projectDir, resolved, (before) => {
-    const task = loadTask(projectDir, resolved); assertModern(task, 'accept'); requireOwner(task, flags, 'acceptance');
+    const task = loadTask(projectDir, resolved); assertModern(task, 'accept');
     const evidence = field(flags, ['evidence']); if (!evidence) throw new Error('task accept requires --evidence.');
     const body = touch(task, updateAcceptanceBody(task.body, title, true, evidence), 'active'); saveBody(task, body, before);
     const updated = loadTask(projectDir, resolved); print(flags, updated.acceptance.find((entry) => entry.title === title));
@@ -354,7 +348,7 @@ function accept(projectDir, taskId, positional, flags) {
 function finish(projectDir, taskId, flags) {
   const resolved = resolveTaskId(projectDir, taskId);
   return withLock(projectDir, resolved, (before) => {
-    const task = loadTask(projectDir, resolved); assertModern(task, 'finish'); requireOwner(task, flags, 'finish');
+    const task = loadTask(projectDir, resolved); assertModern(task, 'finish');
     if (task.items.some((item) => !item.completed)) throw new Error(`Cannot finish ${task.id}; development items remain incomplete.`);
     const pending = task.acceptance.filter((item) => !item.completed);
     if (pending.length) throw new Error(`Cannot finish ${task.id}; final acceptance remains incomplete: ${pending.map((item) => item.title).join(', ')}.`);
@@ -379,11 +373,12 @@ function migrate(projectDir, taskId, flags) {
     const items = legacyItemDetails(projectDir, task); const now = new Date().toISOString();
     const original = field(flags, ['original'], task.title || resolved); const clarified = field(flags, ['clarified'], original);
     const expected = field(flags, ['expected-effect'], '保留历史任务的目标、进度和验收证据，并使用单文件继续维护。');
-    const modern = { title: task.title || resolved, created_at: task.created_at || now, updated_at: now, owner: task.owner || taskActor(flags), original_requirement: original,
+    const defaultOwner = task.owner || taskActor(flags);
+    const modern = { title: task.title || resolved, created_at: task.created_at || now, updated_at: now, original_requirement: original,
       clarified_requirement: clarified, expected_effect: expected, scope: '', out_of_scope: '' };
     let body = template(modern); const blocks = items.map((item, index) => {
       const id = /^DG-\d{3}$/.test(item.id) ? item.id : `DG-${String(index + 1).padStart(3, '0')}`;
-      const owner = item.owner || modern.owner || 'unassigned'; const evidence = item.evidence.join('; ') || 'Legacy task state migrated.';
+      const owner = item.owner || defaultOwner || 'unassigned'; const evidence = item.evidence.join('; ') || 'Legacy task state migrated.';
       return `- [${item.status === 'completed' ? 'x' : ' '}] ${id} ${item.title}\n  - 内容：从历史 Task 迁移。\n  - 负责人：${owner}\n  - 验收：保留历史工作项状态与证据。\n  - 状态：${item.status || 'pending'}${item.status === 'completed' ? `\n  - 完成结果：${evidence}` : ''}`;
     });
     body = replaceSection(body, '开发清单', blocks.length ? blocks.join('\n\n') : '暂无。');

package/src/commands/verify.js

@@ -0,0 +1,90 @@
+'use strict';
+
+const log = require('../logger');
+const check = require('./check');
+const verifyUi = require('./verifyUi');
+const { canonicalResourceType } = require('../worktree/types');
+
+function mode(value, fallback, flag) {
+  const normalized = String(value == null ? fallback : value).toLowerCase();
+  if (!['auto', 'always', 'never'].includes(normalized)) throw new Error(`${flag} must be auto, always, or never.`);
+  return normalized;
+}
+
+function resources(positional) {
+  if (!positional.length) return [];
+  const [rawType, ...ids] = positional;
+  if (!ids.length) throw new Error('Usage: draftgo verify [<pages|nav|docs> <id...>] [--url <url>]');
+  const resourceType = canonicalResourceType(rawType);
+  return ids.map((resourceId) => ({ resourceType, resourceId: String(resourceId) }));
+}
+
+function viewports(flags) {
+  const value = String(flags.viewport || '').toLowerCase();
+  if (!value) return [{ name: 'custom', width: flags.width, height: flags.height }];
+  if (value === 'mobile') return [{ name: 'mobile', width: 390, height: 844 }];
+  if (value === 'desktop') return [{ name: 'desktop', width: 1440, height: 900 }];
+  if (value === 'both') return [
+    { name: 'mobile', width: 390, height: 844 },
+    { name: 'desktop', width: 1440, height: 900 },
+  ];
+  throw new Error('--viewport must be mobile, desktop, or both.');
+}
+
+async function verify(projectDir, positional = [], flags = {}) {
+  let selected;
+  let uiMode;
+  let remoteMode;
+  try {
+    selected = resources(positional);
+    uiMode = mode(flags.ui, 'auto', '--ui');
+    remoteMode = flags.remote ? 'always' : 'never';
+  } catch (error) {
+    log.err(error.message);
+    return 1;
+  }
+
+  log.title('draftgo verify');
+  const checkCode = await check(projectDir, [], {
+    strict: flags.strict,
+    remote: remoteMode === 'always',
+    resourceKeys: selected.length
+      ? selected.map((entry) => `${entry.resourceType}:${entry.resourceId}`)
+      : null,
+  });
+  if (checkCode !== 0) return checkCode;
+
+  const url = String(flags.url || '').trim();
+  const runUi = uiMode === 'always' || (uiMode === 'auto' && Boolean(url));
+  if (!runUi) {
+    if (uiMode === 'always' && !url) {
+      log.err('--ui always requires --url <http://localhost:port/path>.');
+      return 1;
+    }
+    log.ok('Unified verification passed (UI skipped).');
+    return 0;
+  }
+  if (selected.length > 1) {
+    log.err('One --url can assert at most one resource. Run verify once per route for UI validation.');
+    return 1;
+  }
+
+  let targets;
+  try { targets = viewports(flags); }
+  catch (error) { log.err(error.message); return 1; }
+  for (const viewport of targets) {
+    const uiFlags = { ...flags, url, width: viewport.width, height: viewport.height, 'mobile-check': 'always' };
+    if (remoteMode === 'always' && selected.length === 1 && !uiFlags.resource) {
+      uiFlags.resource = `${selected[0].resourceType}:${selected[0].resourceId}`;
+    }
+    const code = await verifyUi(projectDir, [url], uiFlags);
+    if (code !== 0) return code;
+  }
+  log.ok(`Unified verification passed (${targets.map((item) => item.name).join(', ')}).`);
+  return 0;
+}
+
+module.exports = verify;
+module.exports.mode = mode;
+module.exports.resources = resources;
+module.exports.viewports = viewports;

package/src/commands/verifyUi.js

@@ -163,6 +163,51 @@ function parseResourceSpec(value) {
   return { resourceType: canonicalResourceType(raw.slice(0, separator)), resourceId: raw.slice(separator + 1) };
 }
 
+async function selectFrames(page, mode = 'auto') {
+  const top = page.mainFrame ? page.mainFrame() : page;
+  const selected = [{ frame: top, label: 'top' }];
+  if (mode === 'top') return selected;
+  if (!['auto', 'all'].includes(mode)) {
+    const handle = await page.locator(mode).first().elementHandle().catch(() => null);
+    const frame = handle && await handle.contentFrame().catch(() => null);
+    if (!frame) throw new Error(`Frame not found: ${mode}`);
+    return [{ frame, label: `selector:${mode}` }];
+  }
+  const frames = page.frames ? page.frames() : [];
+  for (let index = 0; index < frames.length; index += 1) {
+    const frame = frames[index];
+    if (frame === top) continue;
+    let visible = true;
+    if (mode === 'auto') {
+      const element = await frame.frameElement().catch(() => null);
+      visible = Boolean(element && await element.isVisible().catch(() => false));
+    }
+    if (visible) selected.push({
+      frame,
+      label: `frame:${frame.name && frame.name() ? frame.name() : index}`,
+    });
+  }
+  return selected;
+}
+
+async function inspectFrame(frame) {
+  return frame.evaluate(() => {
+    const body = document.body;
+    const root = document.documentElement;
+    return {
+      bodyTextLength: body ? (body.innerText || '').trim().length : 0,
+      bodyHeight: body ? body.getBoundingClientRect().height : 0,
+      hasVisibleMedia: body ? Array.from(body.querySelectorAll('img,svg,canvas,video,iframe,input,button')).some((element) => {
+        const rect = element.getBoundingClientRect();
+        return rect.width > 1 && rect.height > 1;
+      }) : false,
+      horizontalOverflow: root.scrollWidth > window.innerWidth + 1,
+      scrollWidth: root.scrollWidth,
+      viewportWidth: window.innerWidth,
+    };
+  });
+}
+
 async function verifyRemoteResource(projectDir, spec) {
   const { resourceType, resourceId } = parseResourceSpec(spec);
   const entry = getEntry(loadManifest(projectDir), resourceType, resourceId);
@@ -257,32 +302,28 @@ async function verifyUi(projectDir, positional, flags = {}) {
 
     const response = await page.goto(url, { waitUntil: 'domcontentloaded', timeout: 30000 });
     if (waitMs) await page.waitForTimeout(waitMs);
-    const state = await page.evaluate(() => {
-      const body = document.body;
-      const root = document.documentElement;
-      return {
-        title: document.title,
-        bodyTextLength: body ? (body.innerText || '').trim().length : 0,
-        bodyHeight: body ? body.getBoundingClientRect().height : 0,
-        hasVisibleMedia: body ? Array.from(body.querySelectorAll('img,svg,canvas,video,iframe,input,button')).some((element) => {
-          const rect = element.getBoundingClientRect();
-          return rect.width > 1 && rect.height > 1;
-        }) : false,
-        horizontalOverflow: root.scrollWidth > window.innerWidth + 1,
-        scrollWidth: root.scrollWidth,
-        viewportWidth: window.innerWidth,
-      };
-    });
+    const frames = await selectFrames(page, String(flags.frame || 'auto'));
+    const states = [];
+    for (const item of frames) states.push({ ...item, state: await inspectFrame(item.frame) });
 
     const issues = [];
     if (response && response.status() >= 400) issues.push(`页面返回 HTTP ${response.status()}`);
-    if (!state.bodyHeight || (!state.bodyTextLength && !state.hasVisibleMedia)) issues.push('页面疑似空白');
-    if (state.horizontalOverflow) issues.push(`页面横向溢出：scrollWidth=${state.scrollWidth}, viewport=${state.viewportWidth}`);
+    if (!states.some(({ state }) => state.bodyHeight && (state.bodyTextLength || state.hasVisibleMedia))) issues.push('页面疑似空白');
+    for (const { label, state } of states) {
+      if (state.horizontalOverflow) issues.push(`${label} 横向溢出：scrollWidth=${state.scrollWidth}, viewport=${state.viewportWidth}`);
+    }
     if (consoleErrors.length) issues.push(`console error ${consoleErrors.length} 条`);
     if (pageErrors.length) issues.push(`page error ${pageErrors.length} 条`);
     if (flags.selector) {
-      const visible = await page.locator(String(flags.selector)).first().isVisible().catch(() => false);
-      if (!visible) issues.push(`关键元素不可见：${flags.selector}`);
+      let match = null;
+      for (const item of frames) {
+        if (await item.frame.locator(String(flags.selector)).first().isVisible().catch(() => false)) {
+          match = item.label;
+          break;
+        }
+      }
+      if (!match) issues.push(`关键元素在已检查 frame 中不可见：${flags.selector}`);
+      else log.info(`Selector ${flags.selector}: visible in ${match}`);
     }
 
     const shouldScreenshot = screenshotMode === 'always' || (screenshotMode === 'on-failure' && issues.length > 0);
@@ -303,7 +344,7 @@ async function verifyUi(projectDir, positional, flags = {}) {
       return 1;
     }
 
-    log.ok(`UI smoke check 通过：${width}x${height}，${decision.reason}`);
+    log.ok(`UI smoke check 通过：${width}x${height}，${frames.length} frame(s)，${decision.reason}`);
     if (screenshotPath) log.info(`截图：${screenshotPath}`);
     return 0;
   } catch (err) {
@@ -324,3 +365,5 @@ module.exports.executableCandidates = executableCandidates;
 module.exports.playwrightCacheCandidates = playwrightCacheCandidates;
 module.exports.parseResourceSpec = parseResourceSpec;
 module.exports.verifyRemoteResource = verifyRemoteResource;
+module.exports.selectFrames = selectFrames;
+module.exports.inspectFrame = inspectFrame;

package/src/commands/verifyUiCompat.js

@@ -0,0 +1,16 @@
+'use strict';
+
+const log = require('../logger');
+const verify = require('./verify');
+
+async function verifyUiCompat(projectDir, positional = [], flags = {}) {
+  const url = String(flags.url || positional[0] || '').trim();
+  log.warn('`draftgo verify-ui` is deprecated; use `draftgo verify --url <url> --ui always`.');
+  return verify(projectDir, [], {
+    ...flags,
+    url,
+    ui: 'always',
+  });
+}
+
+module.exports = verifyUiCompat;

package/src/projectMap.js

@@ -6,6 +6,7 @@ const path = require('path');
 const parse5 = require('parse5');
 const { loadManifest, absolutePath } = require('./worktree/manifest');
 const { mediaType } = require('./worktree/types');
+const { validateInlineScripts } = require('./worktree/inlineScripts');
 
 function normalizeRoute(route) {
   if (!route || typeof route !== 'string') return '';
@@ -121,7 +122,7 @@ function worktreeFiles(projectDir, directory) {
     .map((entry) => path.join(root, entry.name));
 }
 
-function analyzeProject(projectDir) {
+function analyzeProject(projectDir, options = {}) {
   const map = buildProjectMap(projectDir);
   const errors = [];
   const warnings = [];
@@ -132,7 +133,12 @@ function analyzeProject(projectDir) {
   };
   const registered = new Set();
 
-  for (const entry of map.checkouts) {
+  const resourceKeys = options.resourceKeys ? new Set(options.resourceKeys) : null;
+  const selectedCheckouts = resourceKeys
+    ? map.checkouts.filter((entry) => resourceKeys.has(`${entry.resource_type}:${entry.resource_id}`))
+    : map.checkouts;
+
+  for (const entry of selectedCheckouts) {
     let local;
     let base;
     try {
@@ -176,18 +182,24 @@ function analyzeProject(projectDir) {
         const position = issue.line ? ` at ${issue.line}:${issue.column || 1}` : '';
         addWarning('DG-HTML-001', 'high', `${entry.resource_type} ${entry.resource_id}: ${issue.code}${position}.`);
       }
+      for (const issue of validateInlineScripts(source).slice(0, 20)) {
+        errors.push(`${entry.resource_type} ${entry.resource_id}: inline script #${issue.script} `
+          + `(${issue.script_type}) ${issue.message} at ${entry.local_path}:${issue.line}:${issue.column}.`);
+      }
     }
   }
 
-  for (const directory of ['pages', 'navigations', 'docs']) {
-    for (const file of worktreeFiles(projectDir, directory)) {
-      if (!registered.has(path.resolve(file).toLowerCase())) {
-        const relative = path.relative(projectDir, file).replace(/\\/g, '/');
-        addWarning('DG-WORKTREE-ORPHAN', 'high', `Unregistered worktree file: ${relative}.`);
+  if (!resourceKeys) {
+    for (const directory of ['pages', 'navigations', 'docs']) {
+      for (const file of worktreeFiles(projectDir, directory)) {
+        if (!registered.has(path.resolve(file).toLowerCase())) {
+          const relative = path.relative(projectDir, file).replace(/\\/g, '/');
+          addWarning('DG-WORKTREE-ORPHAN', 'high', `Unregistered worktree file: ${relative}.`);
+        }
       }
     }
   }
-  for (const page of map.pages) {
+  for (const page of map.pages.filter((entry) => !resourceKeys || resourceKeys.has(`pages:${entry.resource_id}`))) {
     if (!page.route || page.route === '/' || page.area === 'system') continue;
     const sources = map.routeRefs[normalizeRoute(page.route)] || [];
     if (!sources.some((source) => source.startsWith('navigations:'))) {

package/src/skill.js

@@ -187,15 +187,6 @@ function validateRenderedSkill(assetDir) {
 }
 
 function ensureRuntime(projectDir) {
-  const dg = paths.dgDir(projectDir);
-  ensureDir(dg);
-  for (const sub of ['Task', 'lessons']) {
-    ensureDir(path.join(dg, sub));
-  }
-  const changelog = path.join(dg, 'changelog.md');
-  if (!exists(changelog)) {
-    writeText(changelog, '');
-  }
   appendGitignoreLine(projectDir, '.draftgo/config.json');
   appendGitignoreLine(projectDir, '.draftgo/token');
   appendGitignoreLine(projectDir, '.draftgo/worktree/');

package/src/workspaceHealth.js

@@ -4,7 +4,7 @@ const fs = require('fs');
 const path = require('path');
 const runtime = require('./runtimeFiles');
 
-const PROTECTED_PREFIXES = ['worktree/', 'conflicts/', 'Task/', 'lessons/', 'config.json', 'changelog.md', 'story.yaml', '.version', 'runtime-manifest.json'];
+const PROTECTED_PREFIXES = ['worktree/', 'conflicts/', 'Task/', 'lessons/', 'tmp/', 'config.json', 'changelog.md', 'story.yaml', '.version', 'runtime-manifest.json'];
 function workspaceHealth(projectDir) {
   const root = runtime.draftgoRoot(projectDir); const registered = new Set(runtime.load(projectDir).entries.map((entry) => String(entry.path).replace(/\\/g, '/')));
   const summary = { managed_files: 0, unknown_files: 0, temporary_files: 0, artifact_files: 0, total_bytes: 0, reclaimable_bytes: 0, warnings: [] };
@@ -22,7 +22,7 @@ function workspaceHealth(projectDir) {
       if (managed) summary.managed_files += 1; else summary.unknown_files += 1;
       if (relative.startsWith('tmp/')) summary.temporary_files += 1;
       if (relative.startsWith('artifacts/')) summary.artifact_files += 1;
-      if (registered.has(relative)) summary.reclaimable_bytes += size;
+      if (registered.has(relative) || relative.startsWith('tmp/')) summary.reclaimable_bytes += size;
       if (!managed && (/\.exe$/i.test(relative) || (/^[^/]+\.(go|json)$/i.test(relative) && !['config.json', 'runtime-manifest.json'].includes(relative)))) summary.warnings.push({ code: 'DG-WORKSPACE-UNKNOWN-FILE', path: relative, size });
       if (relative.startsWith('artifacts/') && !registered.has(relative)) summary.warnings.push({ code: 'DG-WORKSPACE-UNREGISTERED-ARTIFACT', path: relative, size });
     }

package/src/worktree/inlineScripts.js

@@ -0,0 +1,99 @@
+'use strict';
+
+const vm = require('vm');
+const { spawnSync } = require('child_process');
+const parse5 = require('parse5');
+
+const DATA_SCRIPT_TYPES = new Set([
+  'application/json',
+  'application/ld+json',
+  'importmap',
+  'speculationrules',
+]);
+
+function attribute(node, name) {
+  const item = (node.attrs || []).find((candidate) => candidate.name.toLowerCase() === name);
+  return item ? item.value : '';
+}
+
+function scriptSource(node) {
+  return (node.childNodes || [])
+    .filter((child) => child.nodeName === '#text')
+    .map((child) => child.value || '')
+    .join('');
+}
+
+function collectInlineScripts(html) {
+  const document = parse5.parse(String(html || ''), { sourceCodeLocationInfo: true });
+  const scripts = [];
+  const visit = (node) => {
+    if (node.tagName === 'script' && !attribute(node, 'src')) {
+      const type = attribute(node, 'type').trim().toLowerCase();
+      if (!DATA_SCRIPT_TYPES.has(type) && (!type || type === 'module' || /(?:java|ecma)script/.test(type))) {
+        const location = node.sourceCodeLocation || {};
+        const startTag = location.startTag || {};
+        scripts.push({
+          index: scripts.length + 1,
+          type: type === 'module' ? 'module' : 'classic',
+          source: scriptSource(node),
+          startLine: startTag.endLine || location.startLine || 1,
+          startColumn: startTag.endCol || 1,
+        });
+      }
+    }
+    for (const child of node.childNodes || []) visit(child);
+    if (node.content) visit(node.content);
+  };
+  visit(document);
+  return scripts;
+}
+
+function syntaxPosition(message) {
+  const line = String(message || '').match(/(?:\[stdin\]|inline-script):(\d+)(?::(\d+))?/);
+  if (line) return { line: Number(line[1]), column: Number(line[2] || 1) };
+  const caretLines = String(message || '').split(/\r?\n/);
+  const caretIndex = caretLines.findIndex((value) => /^\s*\^/.test(value));
+  return { line: null, column: caretIndex > 0 ? caretLines[caretIndex].indexOf('^') + 1 : null };
+}
+
+function conciseMessage(error) {
+  const lines = String(error && (error.stderr || error.message) || error || '').split(/\r?\n/);
+  return lines.find((line) => /^SyntaxError:/.test(line))
+    || lines.find((line) => line.trim() && !/^\s*at\s/.test(line))
+    || 'Invalid JavaScript syntax';
+}
+
+function validateInlineScripts(html) {
+  const issues = [];
+  for (const script of collectInlineScripts(html)) {
+    if (!script.source.trim()) continue;
+    let failure = null;
+    if (script.type === 'module') {
+      const result = spawnSync(process.execPath, ['--check', '--input-type=module'], {
+        input: script.source,
+        encoding: 'utf8',
+        windowsHide: true,
+      });
+      if (result.error || result.status !== 0) failure = { message: result.stderr || result.stdout || result.error.message };
+    } else {
+      try { new vm.Script(script.source, { filename: 'inline-script' }); }
+      catch (error) { failure = error; }
+    }
+    if (!failure) continue;
+    const diagnostic = failure.stack || failure.message;
+    const position = syntaxPosition(diagnostic);
+    issues.push({
+      code: 'DG-JS-001',
+      script: script.index,
+      script_type: script.type,
+      line: position.line ? script.startLine + position.line - 1 : script.startLine,
+      column: position.column
+        ? position.column + (position.line === 1 ? script.startColumn - 1 : 0)
+        : script.startColumn,
+      message: conciseMessage(failure),
+    });
+  }
+  return issues;
+}
+
+module.exports = { DATA_SCRIPT_TYPES, collectInlineScripts, validateInlineScripts };

package/src/worktree/status.js

@@ -101,7 +101,7 @@ async function inspectRemoteCheckouts(projectDir, options = {}) {
   const session = options.backend && typeof options.backend.resolveMetadata === 'function'
     ? { client: options.client || {}, tools: options.tools || [] }
     : await openMetadataSession(config, options);
-  const entries = Object.values(manifest.entries);
+  const entries = options.entries || Object.values(manifest.entries);
   return Promise.all(entries.map(async (entry) => {
     const remote = await backend.resolveMetadata(config, entry.resource_type, entry.resource_id, {
       ...options,