@agile-team/wl-skills-ui 1.20.1 → 1.21.0

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## [1.21.0] — 2026-10-11
+
+- 协议参数校验运行依赖固定升级 Ajv 8.20.0，消除 GHSA-2g4f-4pwh-qvx6 已知版本风险；保留共享 Schema 与未受影响的依赖版本。
+- 定向修复 fast-uri 与开发工具传递依赖的已知公告；开发验证 Vue 链更新为 3.5.42 并保留生产 peer 范围，tmp 兼容性独立验证，主 CI 增加运行依赖审计门禁。
+- CI 兼容矩阵先冻结安装依赖并生成运行产物，再打包候选；验证与发布工作流显式固定 pnpm 版本，避免全新 checkout 缺少构建或包管理器版本。
+- 增加 executor-invoke-v1 结构化检查入口，复用本包原执行器并保留旧五操作。
+- 完整参数 Schema、任务准入和路径边界校验；共享快照来源及离线防漂移门禁。
+- 更新独立维护、Harness 兼容与持续验收说明。
+
+- 公开协议新增 `executor-invoke-v1` 与结构化 `execute`；UI 在包内维护 scan 参数映射，复用原 scanner CLI 和同 runId 回执，无兄弟包或 Harness 运行时依赖。
+- 执行前核对本项目有效计划、动作许可、目标及规则子集与参数 Schema；非法输入、计划外范围、解释、过期和禁用请求不启动检查。业务失败保留真实非零退出，调用成功不冒充验证通过。
+- execute 省略 rules 时只执行计划内 R 规则；CLI/MCP 的 only/skip 在扫描前选择实际回调，SFC_PARSE 保持独立且不可隐藏。
+- 原 scanner/修复器读取 Vue 叶子前核验实际项目根，拒绝目录内外部文件链接；保留本项目内部合法链接。
+- 异步执行直接复用 scanner，避免同步包装器形成二次子进程；协议等待检查结束，复用公共输出预算与进程树取消，并增加真实 R001 成功/违规及拒绝零记录回归。
+
 ## [1.20.1] - 2026-10-11
 
 - 修复 task 在版本漂移后旧顶层 status/ready 与嵌套 decision、notice、公开协议准入不一致；从校正后的记录生成旧字段，gap 始终 ready=false。

package/README.md

@@ -2,7 +2,7 @@
 
 > 项目范围：只对目标自身已接入且平台适用的项目判定规则；父工作区安装不启用子项目。移动端与未接入开源项目不套用。详见 [精准触发与范围配置](docs/project-scope.md)。
 
-**企业级 UI 一致性与 AI 精确治理工具包 v1.20.1** — 面向 Vue 3 + Element Plus 的设计令牌、能力 Profile、样式皮肤、页面骨架、运行时能力、静态扫描、确定性修复、AI Skill、MCP 与脱敏 UI 模板契约。
+**企业级 UI 一致性与 AI 精确治理工具包 v1.21.0** — 面向 Vue 3 + Element Plus 的设计令牌、能力 Profile、样式皮肤、页面骨架、运行时能力、静态扫描、确定性修复、AI Skill、MCP 与脱敏 UI 模板契约。
 
 它把“视觉统一、问题识别、机械修复、项目适配和样例沉淀”拆成可验证、可组合的工程能力。脚本、规则和 MCP 先完成确定性工作，AI 只处理业务语义与人工决策，从而减少重复读源码、上下文 token 和误修改。
 
@@ -108,20 +108,41 @@ CLI、安装器和 MCP 无需安装其他 wl-skills 包或统一客户端即可
 
 ## 公开集成协议 v1
 
-供 harness、客户端或其他编排层以统一 JSON 入口调用本包判定与状态能力（业务执行仍走本包 CLI/MCP，不因协议新增兄弟包依赖）。
+供 harness、客户端或其他编排层以统一 JSON 入口判定、查询并调用本包声明的业务只读检查器。业务执行复用本包原 CLI，参数映射由本包维护；不新增兄弟包或 Harness 运行时依赖。
 
 ```bash
-wl-ui protocol describe --json                      # 能力目录、五操作映射、请求/响应 Schema、错误码
+wl-ui protocol describe --json                      # 能力目录、六操作映射、请求/响应 Schema、错误码
 wl-ui protocol request --input-file request.json --json
 ```
 
-- 操作：`route` / `explain`（只读判定）、`task`（判定并持久化计划，尚未执行）、`status`（回查本包执行回执）、`doctor-host`（宿主入口静态诊断）。
-- 请求字段：`protocolVersion`(1)、`operation`、`requestId`、`runId`、`projectRoot`、`task`、`targets`、`skill`、`host`+ `profile`。
-- 统一信封：`{ ok, result | error, diagnostics }`；机器结果与诊断分离；非法输入在触达执行器前判 `invalid-input`，不写入任何记录。
-- 错误码：`unsupported-protocol` / `unknown-operation` / `missing-input` / `invalid-input` / `internal-error`；请求失败（exit 2）时 stdout 仍为可解析 JSON 信封。
+- 操作：`route` / `explain`（只读判定）、`task`（判定并持久化计划，尚未执行）、`status`（回查本包执行回执）、`doctor-host`（宿主入口静态诊断）、`execute`（按有效计划调用本包声明的业务只读检查器）。
+- 判定与查询请求字段：`protocolVersion`(1)、`operation`、`requestId`、`runId`、`projectRoot`、`task`、`targets`、`skill`、`host`+ `profile`。
+- 统一信封：`{ ok, result | error, diagnostics }`；机器结果与诊断分离；非法输入在触达执行器前拒绝（基础请求为 `invalid-input`，执行参数为 `invalid-executor-input`），不写入任何记录。
+- 基础错误码：`unsupported-protocol` / `unknown-operation` / `missing-input` / `invalid-input` / `internal-error`；执行请求另区分计划、授权、范围与参数拒绝，完整错误码见 `describe.errorCodes`。请求失败（exit 2）时 stdout 仍为可解析 JSON 信封。
 - **`ok=true` 只表示协议调用成功，不代表业务验证通过**；业务状态以 `result` 内 `validationStatus` / `executionStatus` 为准（仅计划时为 `unverified` / `not-executed`）。
-- 副作用：仅 `task` 写入本包自己的 runs 目录（见 describe 中各操作 `sideEffects`）；其余操作只读。
-- 协议实现为本包内置的同源快照 `integration-protocol.cjs`，五包一致；跨包一致性由 conformance `integration-protocol.check.cjs` 验收。
+- 副作用：`task` 保存计划，`execute` 复用原执行器写本包自己的 runs 回执并输出报告；均不通过本接口修改业务文件。其他操作只读，见 describe 中各操作 `sideEffects`。
+- 协议实现为本包内置的同源快照 `integration-protocol.cjs`，当前源码分发一致性由 conformance 验收。各包独立保留自己的快照与版本；已发布版本按协议、feature 和 Schema 判断兼容，不要求每次同步发版。
+
+### 稳定执行入口
+
+先用 `task` 创建当前项目的计划，核对 `result.integration.allowedExecutors`，再通过同一个 `protocol request` 发送：
+
+```json
+{
+  "protocolVersion": 1,
+  "operation": "execute",
+  "projectRoot": "/absolute/path/to/adopted-pc-project",
+  "runId": "task-returned-run-id",
+  "executorId": "scan",
+  "parameters": {"targets": ["src/views/example/index.vue"], "rules": ["R001"]}
+}
+```
+
+`projectRoot`、`runId`、`executorId`、`parameters` 必填；执行目标放在 `parameters.targets`，不接受顶层 `targets`。UI 的 `rules` 只接受本次计划内的规则子集；省略时执行当前计划的 R 规则，不扩大到全量规则。SFC 解析检查独立执行且不能被隐藏。未知执行器、非法参数、计划外目标/规则、未接入或不适用项目、禁止检查、过期或版本漂移的计划在启动业务 CLI 前拒绝。当前本包执行器为 `scan`；以 `describe.inventory.executors` 的实际目录与 Schema 为准。
+
+返回 `result.execution` 的真实 `exitCode`、`signal`、stdout/stderr，并重新读取同 runId 的包内状态形成 `result.integration`。`ok=true` 表示调用已完成，即使业务检查退出非零仍保留真实失败；宿主须查看执行与验证状态、实际检查文件和未验证项。输出有界，取消会终止本次业务 CLI 及其进程树。协议不代替真实宿主加载、模型读取或界面展示证据。
+
+适配器只发送执行器 ID 与结构化参数，无需维护本包 CLI argv。增加检查器时由本包更新目录、Schema 与原 CLI 映射；兼容接口下其他包与 Harness 不必同步发版。原 CLI/MCP 继续可独立使用。
 
 ## 能力地图
 
@@ -512,7 +533,7 @@ npx wl-ui doctor --project . --print-overrides
 
 ## 版本与进一步阅读
 
-当前 v1.20.1：公开集成协议 describe/request 统一信封（能力清单与路由语料经真实打包产物验证）、输入校验收口与 MCP 目录对齐真实 tools/list。v1.15.0：任务判定、真实执行/验证回执、实际检查范围和过期检测；Codex 原生薄入口按需加载 canonical Skill。确定性路由覆盖已发布目录与显式缺口，不保证识别所有自然语言。v1.14.0：明确独立能力边界，安装、更新、清理按本包贡献保护用户及其他包内容；共享文件采用单文件原子替换，支持历史路由与 `.clinerules` 目录迁移。v1.13.2：R044 审查多列表单超宽标签，R040 识别自定义 `stepper`，均供人工复核。v1.13.0：新增 `native-jh-ag` Profile、显式 Profile 兼容承诺与联邦 AG 依赖识别。
+当前 v1.21.0：公开集成协议 describe/request 统一信封（能力清单与路由语料经真实打包产物验证）、输入校验收口与 MCP 目录对齐真实 tools/list。v1.15.0：任务判定、真实执行/验证回执、实际检查范围和过期检测；Codex 原生薄入口按需加载 canonical Skill。确定性路由覆盖已发布目录与显式缺口，不保证识别所有自然语言。v1.14.0：明确独立能力边界，安装、更新、清理按本包贡献保护用户及其他包内容；共享文件采用单文件原子替换，支持历史路由与 `.clinerules` 目录迁移。v1.13.2：R044 审查多列表单超宽标签，R040 识别自定义 `stepper`，均供人工复核。v1.13.0：新增 `native-jh-ag` Profile、显式 Profile 兼容承诺与联邦 AG 依赖识别。
 
 - [版本摘要](docs/version-history.md)
 - [完整 Changelog](CHANGELOG.md)
@@ -539,13 +560,13 @@ npm run pack:dry
 
 任务判定保留原始文本，并将当前请求、历史引用和明确否定分开。自然语言判定覆盖已公开语料与规则，不能承诺任意表述都自动命中；遇到歧义或缺口应补充目标/领域或显式指定本包能力，不能静默选择。编辑前显示真实 `notice`，包括版本、技能、规则、目标、runId、动作与待检查项。
 
-`protocol describe --json` 声明 `task-intent-v1`、`result-core-v1`、`executor-catalog-v1`；`schemas.resultCore` 与五操作 `schemas.results` 可供宿主验证。原有结果字段保留，新增 `result.integration`：项目适用范围、动作模式、规则身份、目标、就绪状态、允许执行器和真实执行/验证状态。`ok` 只表示调用成功。未声明使用的输入字段进入 diagnostics，不会转成授权依据。
+`protocol describe --json` 声明 `task-intent-v1`、`result-core-v1`、`executor-catalog-v1`、`executor-invoke-v1`；`schemas.resultCore` 与六操作 `schemas.results` 可供宿主验证。原有结果字段保留，新增 `result.integration`：项目适用范围、动作模式、规则身份、目标、就绪状态、允许执行器和真实执行/验证状态。`ok` 只表示调用成功。判定与查询的未声明字段进入 diagnostics，不会转成授权依据；execute 的额外字段按 Schema 拒绝。
 
 `action.mode` 为 explain/plan/inspect/apply/unspecified；解释和规划不自动启动检查。`businessWritesAuthorized=false`，任务意图不能替代业务写入授权。`ruleRefs` 为包自有规则身份（包名、规则 ID、版本、来源、性质），自然语言约束有稳定 ID；原规则名称与列表保留。所有规则的机械/语义验证仍以实际回执为准。
 
-`inventory.executors` 声明本包业务只读检查器、目标与参数 Schema；其适用条件由本包判定。外部适配器须核对同项目、同包、同版本、同 runId 的真实计划、新鲜度与允许动作，指定一个目标，不能扩大范围；支持规则子集的执行器不得选择计划外规则。多目标需拆分调用。五包和 Harness 均为可选组合，不新增兄弟包或 Harness 运行时依赖；卸下适配器后原 CLI/MCP 继续独立使用。
+`inventory.executors` 声明本包业务只读检查器、目标与参数 Schema；其适用条件由本包判定。外部适配器须核对同项目、同包、同版本、同 runId 的真实计划、新鲜度与允许动作，指定一个目标，不能扩大范围；支持规则子集的执行器不得选择计划外规则。当前执行入口一次只接受与本包计划一致的一个目标；多目标应先拆分计划，再逐个执行。五包和 Harness 均为可选组合，不新增兄弟包或 Harness 运行时依赖；卸下适配器后原 CLI/MCP 继续独立使用。
 
-样式规则检查使用 `scan`（支持计划内规则子集）；`check` 只核验接入完整性。技能触发词由本包 `bin/task-triggers.json` 维护并接受目录一致性检查。
+样式规则检查使用 `scan`（支持计划内规则子集；`--only/--skip` 在扫描前选择实际规则回调）；`check` 只核验接入完整性。技能触发词由本包 `bin/task-triggers.json` 维护并接受目录一致性检查。
 
 `scan/audit/fix` 的未知参数、重复值选项、空值、多余位置参数和不存在的规则选择器在检查或写入前拒绝，机读输出返回 `invalid-input`，不会形成成功检查记录。CLI 与 MCP 共用注册规则选择器，支持单个 ID、逗号列表与三位编号范围（例如 `R031-R037`）；用 `wl-ui rules list` 核对实际规则。Vue 解析错误仍不能被 `--only/--skip` 隐藏。`wl-ui scan --help` 只输出帮助，不启动扫描。
 
@@ -554,3 +575,5 @@ npm run pack:dry
 编辑前展示实际 `notice` 的包版本、判定、动作、技能/规则、目标、runId、待检查项与版本对齐信息；解释/规划和明确禁止检查时不自动执行检查。`runtime=mismatch/invalid` 或 `planStale=true` 必须先同步本包或重新判定。只读 `inspect` 输入变化后重新 `task`；`apply` 完成正常业务修改后可用同 runId 做实际复扫，但规则、配置或版本变化仍需重新判定。
 
 单包只读取自身公开能力；多包复用同 runId 并各存各的证据。`matched/ready/ok=true` 仅说明判定或调用成功，是否完成以实际 `executionStatus/validationStatus/checkedFiles` 为准。未接入或不适用的项目不借父目录规则；宿主发现、模型读取、反馈展示没有真实证据时继续标记未验证。
+
+维护边界、结构化执行和防漂移验收：[维护契约](docs/maintenance-contract.md)。

package/bin/__tests__/dependency-security.test.mjs

@@ -0,0 +1,78 @@
+import assert from 'node:assert/strict'
+import { mkdtempSync, writeFileSync, existsSync, readdirSync, rmSync } from 'node:fs'
+import { createRequire } from 'node:module'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import test from 'node:test'
+
+// Commitizen and cz-customizable still use external-editor 3.x. Verify the
+// patched tmp dependency against their real sync, callback and cleanup APIs.
+const require = createRequire(import.meta.url)
+const commitizenRequire = createRequire(require.resolve('commitizen'))
+const inquirerRequire = createRequire(commitizenRequire.resolve('inquirer'))
+const editorEntry = inquirerRequire.resolve('external-editor')
+const editorRequire = createRequire(editorEntry)
+const { ExternalEditor, editAsync } = editorRequire(editorEntry)
+const tmp = editorRequire('tmp')
+
+function fixture() {
+  const root = mkdtempSync(join(tmpdir(), 'wl-ui-editor-api-'))
+  const editor = join(root, 'editor.cjs')
+  writeFileSync(editor, "require('node:fs').writeFileSync(process.argv[2], 'edited value', 'utf8')\n")
+  return { root, editor, cleanup: () => rmSync(root, { recursive: true, force: true }) }
+}
+
+test('patched tmp keeps external-editor sync creation, editing and cleanup', () => {
+  const f = fixture()
+  try {
+    assert.equal(editorRequire('tmp/package.json').version, '0.2.7')
+    const editor = new ExternalEditor('initial value', { dir: f.root, prefix: 'input-' })
+    editor.editor = { bin: process.execPath, args: [f.editor] }
+    assert.equal(existsSync(editor.tempFile), true)
+    assert.equal(editor.run(), 'edited value')
+    assert.equal(editor.lastExitStatus, 0)
+    editor.cleanup()
+    assert.equal(existsSync(editor.tempFile), false)
+  } finally {
+    f.cleanup()
+  }
+})
+
+test('patched tmp keeps external-editor async callback and automatic cleanup', async () => {
+  const f = fixture()
+  const previousVisual = process.env.VISUAL
+  try {
+    process.env.VISUAL = `${process.execPath} ${f.editor}`
+    const value = await new Promise((resolve, reject) => {
+      editAsync('initial value', (error, result) => error ? reject(error) : resolve(result), {
+        dir: f.root,
+        prefix: 'input-',
+      })
+    })
+    assert.equal(value, 'edited value')
+    assert.deepEqual(readdirSync(f.root), ['editor.cjs'])
+  } finally {
+    if (previousVisual === undefined) delete process.env.VISUAL
+    else process.env.VISUAL = previousVisual
+    f.cleanup()
+  }
+})
+
+test('patched tmp file callback retains idempotent cleanup within the fixture', async () => {
+  const f = fixture()
+  try {
+    const result = await new Promise((resolve, reject) => {
+      tmp.file({ dir: f.root, discardDescriptor: true }, (error, name, fd, cleanup) => {
+        if (error) reject(error)
+        else resolve({ name, fd, cleanup })
+      })
+    })
+    assert.equal(existsSync(result.name), true)
+    assert.equal(result.fd, undefined)
+    await new Promise((resolve, reject) => result.cleanup(error => error ? reject(error) : resolve()))
+    result.cleanup()
+    assert.equal(existsSync(result.name), false)
+  } finally {
+    f.cleanup()
+  }
+})

package/bin/__tests__/protocol-cli.test.mjs

@@ -22,12 +22,13 @@ function tempRoot() {
   return root;
 }
 
-test("describe 返回协议版本、能力目录与五个统一操作", () => {
+test("describe 返回协议版本、能力目录与六个统一操作", () => {
   const described = protocol.describe();
   assert.equal(described.protocolVersion, 1);
   assert.equal(described.package, pkg.name);
   assert.ok(Array.isArray(described.capabilities) && described.capabilities.length > 0);
-  assert.deepEqual(described.operations.map((operation) => operation.id), ["route", "explain", "task", "status", "doctor-host"]);
+  assert.deepEqual(described.operations.map((operation) => operation.id), ["route", "explain", "task", "status", "doctor-host", "execute"]);
+  assert.ok(described.features.includes("executor-invoke-v1"));
   assert.ok(described.errorCodes.includes("unsupported-protocol"));
 });
 

package/bin/__tests__/protocol-execute.test.mjs

@@ -0,0 +1,168 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+
+const repo = path.resolve(import.meta.dirname, "../..");
+const pkg = JSON.parse(fs.readFileSync(path.join(repo, "package.json"), "utf8"));
+const cli = path.join(repo, "bin/wl-ui.js");
+const selected = "src/views/Selected/index.vue";
+
+function fixture(callback) {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "wl-ui-public-execute-"));
+  try {
+    fs.writeFileSync(path.join(root, "package.json"), JSON.stringify({ private: true, devDependencies: { [pkg.name]: pkg.version, vue: "^3.4.0" } }));
+    fs.mkdirSync(path.join(root, "node_modules/@agile-team"), { recursive: true });
+    fs.symlinkSync(repo, path.join(root, "node_modules", pkg.name), "dir");
+    fs.mkdirSync(path.dirname(path.join(root, selected)), { recursive: true });
+    fs.writeFileSync(path.join(root, selected), '<template><el-table><el-table-column prop="name" align="center"/></el-table></template>\n');
+    const installed = spawnSync(process.execPath, [cli, "init", "--editor", "all", "--profile", "native-element"], { cwd: root, encoding: "utf8", timeout: 30000 });
+    assert.equal(installed.status, 0, installed.stderr || installed.stdout);
+    callback(root);
+  } finally { fs.rmSync(root, { recursive: true, force: true }); }
+}
+
+function request(root, input) {
+  const file = path.join(root, "request.json");
+  fs.writeFileSync(file, JSON.stringify({ projectRoot: root, ...input }));
+  const called = spawnSync(process.execPath, [cli, "protocol", "request", "--input-file", file, "--json"], { cwd: root, encoding: "utf8", timeout: 30000 });
+  assert.equal(called.signal, null, called.stderr);
+  return { ...JSON.parse(called.stdout), cliExitCode: called.status };
+}
+
+function plan(root, runId, task = "检查当前 Vue 代码") {
+  const planned = request(root, { operation: "task", task, runId, targets: [selected] });
+  assert.equal(planned.ok, true);
+  return planned.result;
+}
+
+function execute(root, runId, extra = {}) {
+  return request(root, { operation: "execute", runId, executorId: "scan", parameters: { targets: [selected], rules: ["R001"] }, ...extra });
+}
+
+test("公开 execute 复用原 scan：规则子集与真实失败保留，同 runId 状态回查", () => fixture(root => {
+  const source = fs.readFileSync(path.join(root, selected));
+  assert.ok(plan(root, "passed").integration.allowedExecutors.includes("scan"));
+  const passed = execute(root, "passed");
+  assert.equal(passed.ok, true, JSON.stringify(passed));
+  assert.equal(passed.cliExitCode, 0);
+  assert.equal(passed.result.execution.exitCode, 0);
+  assert.equal(passed.result.execution.signal, null);
+  assert.equal(passed.result.integration.runId, "passed");
+  assert.equal(passed.result.integration.executionStatus, "completed");
+  assert.deepEqual(fs.readFileSync(path.join(root, selected)), source);
+  const report = JSON.parse(passed.result.execution.stdout);
+  assert.equal(report.summary.fileCount, 1);
+  assert.equal(report.issues.length, 0);
+  const status = request(root, { operation: "status", runId: "passed" });
+  assert.equal(status.result.integration.executionStatus, passed.result.integration.executionStatus);
+  assert.equal(status.result.tools[0].tool, "scan");
+  assert.deepEqual(status.result.tools[0].checkedFiles.map(file => file.path), [selected]);
+  assert.deepEqual(status.result.tools[0].summary.rules.map(rule => rule.id), ["R001"]);
+  fs.writeFileSync(path.join(root, selected), '<template><el-table><el-table-column prop="name"/></el-table></template>\n');
+  plan(root, "failed");
+  const failed = execute(root, "failed");
+  assert.equal(failed.ok, true, JSON.stringify(failed));
+  assert.equal(failed.result.execution.exitCode, 1);
+  assert.equal(failed.result.integration.executionStatus, "failed");
+  assert.equal(failed.result.integration.validationStatus, "failed");
+  assert.ok(JSON.parse(failed.result.execution.stdout).issues.some(issue => issue.rule === "R001"));
+}));
+
+test("execute 省略 rules 沿用计划 R 子集，不调用或显示计划外 R038", () => fixture(root => {
+  fs.writeFileSync(path.join(root, selected), '<template><el-table><el-table-column prop="name" align="center"/></el-table><el-button>新增</el-button></template>\n');
+  const planned = plan(root, "default-plan-rules");
+  const expected = planned.integration.ruleRefs.map(rule => rule.legacyId).filter(id => /^R\d{3}$/.test(id)).sort();
+  assert.ok(expected.includes("R001"));
+  assert.equal(expected.includes("R038"), false);
+  const called = execute(root, "default-plan-rules", { parameters: { targets: [selected] } });
+  assert.equal(called.ok, true, JSON.stringify(called));
+  assert.equal(called.result.execution.exitCode, 0);
+  const report = JSON.parse(called.result.execution.stdout);
+  assert.equal(report.issues.some(issue => issue.rule === "R038"), false);
+  assert.deepEqual(called.result.tools[0].summary.rules.map(rule => rule.id).sort(), expected);
+  assert.equal(called.result.tools[0].checks.some(check => check.id === "R038"), false);
+}));
+
+test("execute 未知执行器、计划外规则/目标与额外字段在原 scanner 前拒绝，计划不变", () => fixture(root => {
+  const planned = plan(root, "rejected");
+  const planFile = path.join(root, planned.recordPath);
+  const files = fs.readdirSync(path.dirname(planFile));
+  const before = fs.readFileSync(planFile);
+  const cases = [
+    [{ executorId: "unknown" }, "unsupported-executor"],
+    [{ parameters: { targets: [] } }, "invalid-executor-input"],
+    [{ parameters: { targets: [selected], rules: ["R999"] } }, "rule-mismatch"],
+    [{ parameters: { targets: [selected], rules: ["R038"] } }, "rule-mismatch"],
+    [{ parameters: { targets: ["src/views/Other/index.vue"] } }, "target-mismatch"],
+    [{ parameters: { targets: [selected], command: "fix" } }, "invalid-executor-input"],
+    [{ targets: [selected] }, "invalid-executor-input"],
+  ];
+  for (const [input, code] of cases) {
+    const rejected = execute(root, "rejected", input);
+    assert.equal(rejected.ok, false, JSON.stringify(input));
+    assert.equal(rejected.cliExitCode, 2);
+    assert.equal(rejected.error.code, code);
+    assert.deepEqual(fs.readFileSync(planFile), before);
+    assert.deepEqual(fs.readdirSync(path.dirname(planFile)), files);
+    assert.equal(request(root, { operation: "status", runId: "rejected" }).result.executionStatus, "not-executed");
+  }
+}));
+
+test("execute 需要本项目有效检查计划：解释、过期、禁用与未知 runId 均拒绝", () => fixture(root => {
+  plan(root, "explain", "解释当前 Vue 样式，不要检查");
+  assert.equal(execute(root, "explain").ok, false);
+  plan(root, "stale");
+  fs.appendFileSync(path.join(root, selected), "<!-- changed after inspect -->\n");
+  assert.equal(execute(root, "stale").ok, false);
+  assert.equal(request(root, { operation: "status", runId: "stale" }).result.executionStatus, "not-executed");
+  plan(root, "disabled");
+  fs.writeFileSync(path.join(root, ".wl-skills-scope.json"), JSON.stringify({ schemaVersion: 1, projectType: "pc", packages: { ui: false } }));
+  assert.equal(execute(root, "disabled").ok, false);
+  assert.equal(execute(root, "unknown-run").ok, false);
+  assert.equal(fs.existsSync(path.join(root, ".wl-skills-ui/runs/unknown-run")), false);
+}));
+
+test("公开 execute 在原 scanner 前拒绝目录中越界的 Vue 叶子，任务回执零新增", () => fixture(root => {
+  const outsideRoot = fs.mkdtempSync(path.join(os.tmpdir(), "wl-ui-external-source-"));
+  try {
+    const external = path.join(outsideRoot, "Outside.vue");
+    const source = '<template><el-table-column prop="external"/></template>';
+    fs.writeFileSync(external, source);
+    fs.symlinkSync(external, path.join(root, "src/views/Selected/Outside.vue"));
+    const target = "src/views/Selected";
+    const planned = request(root, { operation: "task", task: "检查当前 Vue 代码", targets: [target], runId: "external-leaf" });
+    assert.equal(planned.ok, true);
+    const record = path.join(root, planned.result.recordPath);
+    const bytes = fs.readFileSync(record);
+    const files = fs.readdirSync(path.dirname(record));
+    const rejected = execute(root, "external-leaf", { parameters: { targets: [target] } });
+    assert.equal(rejected.ok, false, JSON.stringify(rejected));
+    assert.equal(rejected.error.code, "invalid-executor-input");
+    assert.deepEqual(fs.readFileSync(record), bytes);
+    assert.deepEqual(fs.readdirSync(path.dirname(record)), files);
+    assert.equal(fs.readFileSync(external, "utf8"), source);
+  } finally { fs.rmSync(outsideRoot, { recursive: true, force: true }); }
+}));
+
+test("复制项目不能重用原根任务计划：status 过期、execute 身份拒绝且零新回执", () => fixture(root => {
+  const planned = plan(root, "copied-plan");
+  const copy = fs.mkdtempSync(path.join(os.tmpdir(), "wl-ui-copied-project-"));
+  try {
+    fs.cpSync(root, copy, { recursive: true, verbatimSymlinks: true });
+    const record = path.join(copy, planned.recordPath);
+    const bytes = fs.readFileSync(record);
+    const files = fs.readdirSync(path.dirname(record));
+    const status = request(copy, { operation: "status", runId: "copied-plan" });
+    assert.equal(status.result.planStale, true);
+    assert.equal(status.result.ready, false);
+    assert.equal(status.result.integration.ready, false);
+    const rejected = execute(copy, "copied-plan");
+    assert.equal(rejected.ok, false);
+    assert.equal(rejected.error.code, "identity-mismatch");
+    assert.deepEqual(fs.readFileSync(record), bytes);
+    assert.deepEqual(fs.readdirSync(path.dirname(record)), files);
+  } finally { fs.rmSync(copy, { recursive: true, force: true }); }
+}));

package/bin/executor-cli.mjs

@@ -0,0 +1,13 @@
+import path from "node:path";
+import processCore from "./executor-process.cjs";
+
+// 复用原 scanner CLI，避免 wl-ui 包装器的同步二次子进程。
+// 规则与参数归本包维护；共享协议先验证计划、规则子集与目标范围。
+export function invokeExecutor({ executor, parameters, projectRoot, runId, plan }) {
+  if (executor.id !== "scan") throw new Error(`UI 未实现执行器：${executor.id}`);
+  const rules = parameters.rules || plan.ruleRefs.map(rule => rule.legacyId).filter(id => /^R\d{3}$/.test(id));
+  if (!rules.length) throw new Error("当前计划没有可执行的 UI R 规则，不能默认扩大扫描范围");
+  const args = ["scan", "--project", projectRoot, `--target=${parameters.targets[0]}`, "--run-id", runId, "--output", "json", "--fail-on-error"];
+  args.push("--only", rules.join(","));
+  return processCore.invokeCli({ cli: path.resolve(import.meta.dirname, "../scanner/index.mjs"), args, projectRoot });
+}

package/bin/executor-invoke.cjs

@@ -0,0 +1,129 @@
+"use strict";
+
+/** Public execution admission. Package schemas and recorded decisions remain the facts. */
+const fs = require("node:fs");
+const path = require("node:path");
+const Ajv2020 = require("ajv/dist/2020");
+const ajv = new Ajv2020({ allErrors: true, strict: true, allowUnionTypes: true, addUsedSchema: false });
+const cache = new Map();
+const STRING = { type: "string", minLength: 1, pattern: "\\S" };
+const REQUEST_SCHEMA = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  type: "object", additionalProperties: false,
+  required: ["operation", "projectRoot", "runId", "executorId", "parameters"],
+  properties: {
+    operation: { const: "execute" }, protocolVersion: { const: 1 }, requestId: STRING,
+    projectRoot: STRING, runId: { ...STRING, pattern: "^[a-zA-Z0-9][a-zA-Z0-9_.-]{0,127}$" }, executorId: STRING,
+    parameters: { type: "object" },
+  },
+};
+const OPERATION = {
+  id: "execute", summary: "通过稳定结构化入口执行本包允许的业务只读检查器",
+  readOnly: false, required: ["projectRoot", "runId", "executorId", "parameters"], optional: [],
+  sideEffects: "业务只读；按执行器声明写本包任务记录或检查报告", mapping: "protocol request operation=execute (executor-invoke-v1)",
+};
+class ExecutionError extends Error {
+  constructor(code, message) { super(message); this.code = code; }
+}
+function refuse(code, message) { throw new ExecutionError(code, message); }
+function validateSchema(schema, value) {
+  const key = JSON.stringify(schema);
+  let validate = cache.get(key);
+  try {
+    if (!validate) {
+      validate = ajv.compile(schema);
+      if (cache.size >= 64) cache.clear();
+      cache.set(key, validate);
+    }
+  } catch (error) { refuse("unsupported-contract", `不能解释执行参数 Schema：${error.message}`); }
+  if (!validate(value)) refuse("invalid-executor-input", ajv.errorsText(validate.errors, { separator: "; " }));
+}
+function realTarget(root, target) {
+  const full = path.resolve(root, target);
+  if (full !== root && !full.startsWith(root + path.sep)) refuse("invalid-executor-input", "执行目标越出项目根");
+  let existing = full;
+  while (!fs.existsSync(existing)) {
+    const parent = path.dirname(existing);
+    if (parent === existing) refuse("invalid-executor-input", "执行目标没有可核验祖先");
+    existing = parent;
+  }
+  const real = fs.realpathSync(existing);
+  if (real !== root && !real.startsWith(root + path.sep)) refuse("invalid-executor-input", "执行目标符号链接越出项目根");
+  if (!fs.existsSync(full)) return;
+  inspectTargetTree(root, full);
+}
+function inspectTargetTree(root, full) {
+  const ignored = new Set(["node_modules", ".git", ".wl-skills", ".wl-skills-ui", ".wl-skills-bd", ".wl-skills-design", ".wl-skills-test", "test-reports", "dist", "build", "target", "coverage"]);
+  const visited = new Set(), queue = [full];
+  let entries = 0;
+  while (queue.length) {
+    const current = queue.pop();
+    if (++entries > 50000) refuse("unsupported-executor-range", "范围超过路径预检预算，请缩小目标");
+    const resolved = fs.realpathSync(current);
+    if (resolved !== root && !resolved.startsWith(root + path.sep)) refuse("invalid-executor-input", "目录内部符号链接越出项目根");
+    if (!fs.statSync(current).isDirectory() || visited.has(resolved)) continue;
+    visited.add(resolved);
+    for (const name of fs.readdirSync(current)) if (!ignored.has(name)) queue.push(path.join(current, name));
+  }
+}
+function identifyPlan(config, input, status, root) {
+  const core = status.integration;
+  let recordedRoot;
+  try { recordedRoot = core?.projectRoot && fs.realpathSync(core.projectRoot); }
+  catch { refuse("identity-mismatch", "计划项目根无法核验"); }
+  if (!core || core.packageName !== config.packageName || core.packageVersion !== config.packageVersion
+      || recordedRoot !== root || core.runId !== input.runId) refuse("identity-mismatch", "任务身份、项目或包版本不一致");
+  const plan = (status.records || []).filter(record => record.kind === "task-decision").at(-1);
+  assertLatestPlan(config, input, plan, root);
+  return { core, plan };
+}
+function assertLatestPlan(config, input, plan, root) {
+  if (!plan || plan.runId !== input.runId || plan.packageName !== config.packageName || plan.packageVersion !== config.packageVersion) refuse("missing-plan", "没有本包同 runId 的真实任务计划");
+  assertPlanRoot(plan, root);
+}
+function assertPlanRoot(plan, root) {
+  const recorded = plan.decision?.scope?.projectRoot || plan.notice?.projectRoot;
+  let resolved;
+  try { resolved = typeof recorded === "string" && fs.realpathSync(recorded); }
+  catch { refuse("identity-mismatch", "任务计划原项目根无法核验，请重新建立任务"); }
+  if (resolved !== root) refuse("identity-mismatch", "任务计划属于另一项目或缺少原项目身份，请重新建立任务");
+}
+function assertReady(config, core) {
+  if (core.scope?.status !== "applicable" || core.scope.adopted !== true) refuse("not-applicable", "项目未接入或不适用本包");
+  assertCatalog(config);
+  if (!["matched", "baseline"].includes(core.decisionStatus) || core.ready !== true) refuse("unresolved-plan", "计划存在缺口、歧义或待确认输入");
+  if (core.action?.checksAllowed !== true) refuse("action-not-allowed", "本任务没有允许检查");
+}
+function assertCatalog(config) {
+  if (config.inventory?.loadErrors?.length) refuse("catalog-load-error", `能力目录加载异常：${config.inventory.loadErrors.join("; ")}`);
+}
+function allowsRecheck(status, core) {
+  return core.action?.mode === "apply" && core.planStale === false && status.outdatedChecker === false
+    && !["invalid", "mismatch"].includes(core.runtime?.status);
+}
+function assertFresh(status, core, plan) {
+  const tools = (status.records || []).filter(record => record.kind === "tool-finished");
+  const replanned = tools.length > 0 && tools.every(record => record.recordedAt < plan.recordedAt);
+  const recheck = allowsRecheck(status, core);
+  if (core.planStale !== false || core.stale !== false && !replanned && !recheck) refuse("stale-plan", "计划或检查证据过期，需重新判定");
+  if (["invalid", "mismatch"].includes(core.runtime?.status)) refuse("identity-mismatch", "安装资产、本地依赖与运行版本未对齐");
+}
+function selectExecutor(config, input, core) {
+  const executor = config.executors.find(item => item.id === input.executorId);
+  if (!executor || executor.sideEffects?.business !== "none" || executor.authorization !== "read-only-business-check") refuse("unsupported-executor", "执行器不存在或不是业务只读检查器");
+  if (!core.allowedExecutors.includes(input.executorId)) refuse("executor-not-allowed", "计划未允许此执行器");
+  return executor;
+}
+function admit(config, input, status) {
+  const root = fs.realpathSync(input.projectRoot);
+  const { core, plan } = identifyPlan(config, input, status, root);
+  assertReady(config, core);
+  assertFresh(status, core, plan);
+  const executor = selectExecutor(config, input, core);
+  validateSchema(executor.parameters, input.parameters);
+  if (JSON.stringify(input.parameters.targets) !== JSON.stringify(core.targets)) refuse("target-mismatch", "执行目标必须与计划一致");
+  for (const target of input.parameters.targets) realTarget(root, target);
+  if (input.parameters.rules?.some(id => !core.ruleRefs.some(rule => rule.legacyId === id))) refuse("rule-mismatch", "规则超出任务计划");
+  return { executor, parameters: input.parameters, projectRoot: root, runId: input.runId };
+}
+module.exports = { REQUEST_SCHEMA, OPERATION, ExecutionError, validateSchema, admit, realTarget };

package/bin/executor-process.cjs

@@ -0,0 +1,51 @@
+"use strict";
+
+/** Reuse the package's original CLI without shell evaluation or orphaned cancellation. */
+const { spawn } = require("node:child_process");
+function invokeCli({ cli, args, projectRoot, maxOutputBytes = 4 * 1024 * 1024 }) {
+  if (!Number.isInteger(maxOutputBytes) || maxOutputBytes < 1 || maxOutputBytes > 64 * 1024 * 1024) throw new Error("执行器输出预算非法");
+  return new Promise((resolve, reject) => {
+    const grouped = process.platform !== "win32";
+    const child = spawn(process.execPath, [cli, ...args], { cwd: projectRoot, detached: grouped, stdio: ["ignore", "pipe", "pipe"] });
+    const stdout = [], stderr = [];
+    let bytes = 0, cancelled = false, limited = false;
+    const killTree = () => {
+      if (!child.pid) return;
+      if (grouped) { try { process.kill(-child.pid, "SIGKILL"); } catch (error) { if (error.code !== "ESRCH") child.kill("SIGKILL"); } }
+      else {
+        const { spawnSync } = require("node:child_process");
+        spawnSync("taskkill", ["/PID", String(child.pid), "/T", "/F"], { timeout: 5000, stdio: "ignore" });
+        child.kill("SIGKILL");
+      }
+    };
+    const stop = () => {
+      cancelled = true;
+      // Cancellation must clean descendants before an outer host can force-kill this CLI.
+      killTree();
+    };
+    const onTerm = () => stop("SIGTERM");
+    const onInt = () => stop("SIGINT");
+    process.on("SIGTERM", onTerm); process.on("SIGINT", onInt);
+    const cleanup = () => {
+      process.removeListener("SIGTERM", onTerm); process.removeListener("SIGINT", onInt);
+    };
+    const collect = (chunk, channel) => {
+      const retained = chunk.subarray(0, Math.max(0, maxOutputBytes - bytes));
+      if (channel === "stdout") stdout.push(retained); else stderr.push(retained);
+      bytes += chunk.length;
+      if (bytes > maxOutputBytes && !limited) { limited = true; stop("SIGTERM"); }
+    };
+    child.stdout.on("data", chunk => collect(chunk, "stdout"));
+    child.stderr.on("data", chunk => collect(chunk, "stderr"));
+    child.once("error", error => {
+      cleanup(); error.code = "executor-start-failed"; error.processId = child.pid; reject(error);
+    });
+    child.once("exit", killTree);
+    child.once("close", (exitCode, signal) => {
+      cleanup();
+      if (limited) { const error = new Error("执行器输出超出预算，已终止，不能宣称检查完成"); error.code = "executor-output-limit"; error.processId = child.pid; reject(error); }
+      else resolve({ exitCode, signal, processId: child.pid, stdout: Buffer.concat(stdout).toString("utf8"), stderr: Buffer.concat(stderr).toString("utf8"), outputTruncated: false, cancelled });
+    });
+  });
+}
+module.exports = { invokeCli };

package/bin/executors.json

@@ -26,6 +26,7 @@
           "maxItems": 1
         },
         "rules": {
+          "description": "省略时执行当前计划的本包 R 规则；显式值只允许计划内子集。SFC 解析检查独立执行且不能被隐藏。",
           "type": "array",
           "items": {
             "type": "string",

package/bin/integration-protocol.cjs

@@ -12,13 +12,18 @@
  * - request：所有字段在执行前完成类型校验；非法输入返回 invalid-input，不触发执行器、
  *   不写入任何记录。非法的 operation/requestId 不回显到信封（保持 string|null）。
  * - 信封结构互斥：ok=true 必有 result 且无 error；ok=false 必有 error 且无 result。
- * - 本协议只统一判定、解释、任务记录、状态查询与宿主诊断；业务执行仍走各包原有 CLI/MCP。
+ * - executor-invoke-v1 增加结构化只读检查入口，复用包内原执行器；旧五操作保持兼容。
  */
 
 const PROTOCOL_VERSION = 1;
 const resultCore = require("./integration-result.cjs");
+const execution = require("./executor-invoke.cjs");
+const observability = require("./task-observability.cjs");
 const SUPPORTED_VERSIONS = [1];
-const ERROR_CODES = ["unsupported-protocol", "unknown-operation", "missing-input", "invalid-input", "internal-error"];
+const ERROR_CODES = ["unsupported-protocol", "unknown-operation", "missing-input", "invalid-input", "internal-error",
+  "unsupported-contract", "invalid-executor-input", "identity-mismatch", "missing-plan", "not-applicable", "catalog-load-error",
+  "unresolved-plan", "action-not-allowed", "stale-plan", "unsupported-executor", "executor-not-allowed", "target-mismatch", "rule-mismatch",
+  "unsupported-executor-range", "executor-start-failed", "executor-output-limit"];
 const OPTIONAL_STRING_FIELDS = ["requestId", "runId", "projectRoot", "skill", "host", "type", "domain", "profile"];
 
 const STRING_FIELD_SCHEMA = { type: "string", minLength: 1, pattern: "\\S" };
@@ -101,8 +106,10 @@ function requestSchema(config) {
       domain: STRING_FIELD_SCHEMA,
       profile: STRING_FIELD_SCHEMA,
       context: CONTEXT_FIELD_SCHEMA,
+      executorId: STRING_FIELD_SCHEMA,
+      parameters: { type: "object" },
     },
-    ...(conditional.length > 0 ? { allOf: conditional } : {}),
+    allOf: [...conditional, { if: { properties: { operation: { const: "execute" } }, required: ["operation"] }, then: execution.REQUEST_SCHEMA }],
   };
 }
 
@@ -131,6 +138,10 @@ function assertValidConfig(config) {
 
 function createProtocol(config) {
   assertValidConfig(config);
+  config = { ...config, operations: [...config.operations] };
+  const executionSupported = Array.isArray(config.executors) && config.executors.length > 0;
+  if (executionSupported) config.operations.push({ ...execution.OPERATION, mapping: `${config.bin || "<package-bin>"} ${execution.OPERATION.mapping}` });
+  assertValidConfig(config);
 
   function base(operation, requestId) {
     return {
@@ -235,7 +246,7 @@ function validateFieldTypes(input) {
       mcpTools: inventory.mcpTools || [],
       loadErrors: inventory.loadErrors || [],
       executors: config.executors || [],
-      note: "业务执行仍走各包原 CLI/MCP；inventory 只声明公开调用映射与入口，不改变执行归属；loadErrors 非空表示目录派生存在异常，不得忽略",
+      note: "结构化 execute 复用本包原执行器；inventory 声明公开调用映射，不改变业务归属；loadErrors 非空阻止自动执行，需修复目录诊断",
     };
   }
 
@@ -248,6 +259,19 @@ function validateFieldTypes(input) {
     };
   }
 
+  async function invokeAndClose(input, admitted, before, original, invoke) {
+    const previousEventIds = new Set((original.records || []).map(record => record.eventId));
+    const interruptionOptions = { projectRoot: admitted.projectRoot, runId: input.runId, packageName: config.packageName, packageVersion: config.packageVersion };
+    let receipt;
+    try { receipt = await invoke({ ...admitted, plan: before.integration }); }
+    catch (error) {
+      observability.finishInterruptedExecutions(interruptionOptions, previousEventIds, error.processId, error.code || "executor-interrupted");
+      throw error;
+    }
+    if (receipt.cancelled || receipt.exitCode !== 0) observability.finishInterruptedExecutions(interruptionOptions, previousEventIds, receipt.processId, receipt.cancelled ? "executor-cancelled" : "executor-interrupted");
+    return receipt;
+  }
+
   return {
     PROTOCOL_VERSION,
     SUPPORTED_VERSIONS,
@@ -257,10 +281,12 @@ function validateFieldTypes(input) {
       return {
         ...base(null, null),
         capabilities: config.capabilities || [],
-        features: ["task-intent-v1", "result-core-v1", "executor-catalog-v1"],
+        support: require("./shared-support-manifest.json"),
+        features: ["task-intent-v1", "result-core-v1", "executor-catalog-v1", ...(executionSupported ? ["executor-invoke-v1"] : [])],
         operations: config.operations.map((operation) => ({ ...operation })),
         inventory: buildInventory(config),
         schemas: { request: requestSchema(config), envelope: envelopeSchema(config.packageName), resultCore: resultCore.SCHEMA,
+          ...(executionSupported ? { execute: execution.REQUEST_SCHEMA } : {}),
           results: Object.fromEntries(config.operations.map((operation) => [operation.id, { type: "object", required: ["integration"], properties: { integration: resultCore.SCHEMA }, additionalProperties: true }])) },
         constraints: buildConstraints(config),
         errorCodes: [...ERROR_CODES],
@@ -270,6 +296,7 @@ function validateFieldTypes(input) {
     request(input, runOperation) {
       const { operation, error } = validateRequest(input);
       if (error) return error;
+      if (operation.id === "execute") return fail(operation.id, input.requestId, "invalid-input", "execute 必须通过异步 requestExecute 接线调用");
       const diagnostics = [];
       const supportedFields = new Set(["operation", "protocolVersion", "requestId", ...operation.required, ...(operation.requireAny || []), ...operation.optional]);
       for (const field of Object.keys(input)) {
@@ -286,6 +313,24 @@ function validateFieldTypes(input) {
         return envelope;
       }
     },
+
+    async requestExecute(input, { readStatus, invoke }) {
+      const checked = validateRequest(input);
+      if (checked.error) return checked.error;
+      if (checked.operation.id !== "execute") return fail(input.operation, input.requestId, "invalid-input", "requestExecute 仅处理 execute 操作");
+      try {
+        execution.validateSchema(execution.REQUEST_SCHEMA, input);
+        const original = await readStatus(input.projectRoot, input.runId);
+        const before = resultCore.projectResult(original, input, config);
+        const admitted = execution.admit(config, input, before);
+        const receipt = await invokeAndClose(input, admitted, before, original, invoke);
+        const after = await readStatus(admitted.projectRoot, input.runId);
+        return { ...base("execute", input.requestId), ok: true,
+          result: { ...resultCore.projectResult(after, input, config), executorId: input.executorId, execution: receipt }, diagnostics: [] };
+      } catch (error) {
+        return fail("execute", input.requestId, ERROR_CODES.includes(error.code) ? error.code : "internal-error", error.message || "执行接口异常");
+      }
+    },
   };
 }
 

package/bin/protocol-cli.mjs

@@ -8,6 +8,7 @@ import { readFileSync } from "node:fs";
 import path from "node:path";
 import { createRequire } from "node:module";
 import { runTaskAction, taskCatalog } from "./task-integration.mjs";
+import { invokeExecutor } from "./executor-cli.mjs";
 
 const require = createRequire(import.meta.url);
 const pkg = require("../package.json");
@@ -77,6 +78,7 @@ function buildInventory() {
 }
 
 export const protocol = createProtocol({
+  bin: BIN,
   packageName: pkg.name,
   packageVersion: pkg.version,
   capabilities: capabilitiesDocument.capabilities || [],
@@ -103,7 +105,14 @@ function envelopeError(code, message, field) {
   return { protocolVersion: 1, package: pkg.name, packageVersion: pkg.version, operation: null, requestId: null, ok: false, error: { code, message, ...(field ? { field } : {}) }, diagnostics: [] };
 }
 
-export function runCli(argv) {
+async function requestEnvelope(input) {
+  if (input && input.operation === "execute") {
+    return protocol.requestExecute(input, { readStatus: (root, runId) => runOperation("status", { projectRoot: root, runId }), invoke: invokeExecutor });
+  }
+  return protocol.request(input, runOperation);
+}
+
+export async function runCli(argv) {
   const sub = argv[0];
   if (sub === "describe") {
     console.log(JSON.stringify(protocol.describe(), null, 2));
@@ -124,7 +133,7 @@ export function runCli(argv) {
       console.log(JSON.stringify(envelopeError("invalid-input", message, "input-file"), null, 2));
       return 2;
     }
-    const envelope = protocol.request(input, runOperation);
+    const envelope = await requestEnvelope(input);
     console.log(JSON.stringify(envelope, null, 2));
     return envelope.ok ? 0 : 2;
   }

package/bin/shared-support-check.cjs

@@ -0,0 +1,40 @@
+"use strict";
+/** Packaged snapshots verify themselves offline, without sibling checkouts. */
+const fs = require("node:fs");
+const path = require("node:path");
+const crypto = require("node:crypto");
+const digest = bytes => crypto.createHash("sha256").update(bytes).digest("hex");
+function validateManifest(manifest) {
+  if (manifest.schemaVersion !== 1 || !manifest.files || Object.keys(manifest.files).length < 10) throw new Error("共享快照清单结构不完整");
+  if (manifest.sourceRevision !== `sha256:${digest(JSON.stringify({ files: manifest.files, developmentFiles: manifest.developmentFiles }))}`) throw new Error("共享快照源 revision 与清单不一致");
+}
+function verifyRuntime(directory, files) {
+  for (const [name, expected] of Object.entries(files)) {
+    if (path.basename(name) !== name || !/^[a-f0-9]{64}$/.test(expected)) throw new Error("非法共享快照文件清单");
+    if (digest(fs.readFileSync(path.join(directory, name))) !== expected) throw new Error(`共享快照漂移：${name}`);
+  }
+}
+function verifyDevelopment(directory, files) {
+  let developmentFilesChecked = 0;
+  for (const [name, expected] of Object.entries(files || {})) {
+    if (name !== "scripts/compatibility-check.cjs" || !/^[a-f0-9]{64}$/.test(expected)) throw new Error("非法开发验收脚本清单");
+    const file = path.resolve(directory, "..", name);
+    // Runtime archives need no development script; repositories verify any distributed copy.
+    if (!fs.existsSync(file)) continue;
+    if (digest(fs.readFileSync(file)) !== expected) throw new Error(`开发验收脚本漂移：${name}`);
+    developmentFilesChecked++;
+  }
+  return developmentFilesChecked;
+}
+function verifySupport(directory = __dirname) {
+  const manifest = JSON.parse(fs.readFileSync(path.join(directory, "shared-support-manifest.json"), "utf8"));
+  validateManifest(manifest);
+  verifyRuntime(directory, manifest.files);
+  const developmentFilesChecked = verifyDevelopment(directory, manifest.developmentFiles);
+  return { ok: true, sourceRevision: manifest.sourceRevision, contracts: manifest.contracts, files: Object.keys(manifest.files).length, developmentFilesChecked };
+}
+if (require.main === module) {
+  try { console.log(JSON.stringify(verifySupport())); }
+  catch (error) { console.error(JSON.stringify({ ok: false, error: error.message })); process.exitCode = 1; }
+}
+module.exports = { verifySupport };

package/bin/shared-support-manifest.json

@@ -0,0 +1,25 @@
+{
+  "schemaVersion": 1,
+  "source": "conformance/support",
+  "sourceRevision": "sha256:01fd34623e8641d867d4f95eb4ef115ebc2be8900b3589736d9b0b01aff214e0",
+  "contracts": {
+    "protocol": 1,
+    "resultCore": 1,
+    "executorInvoke": 1
+  },
+  "files": {
+    "task-observability.cjs": "5a042f28604e5bff3f9c20ad0f69c225bfafc336c35bc95e49cc8311712d0376",
+    "task-observability.schema.json": "fd66fd710d529fadf1a523b9e57a8380bc5f3edfc9eb93479e55b3744fef55de",
+    "integration-protocol.cjs": "6856d674526121010bbc5a0348306f9f3374819ec3cb6bb75eb8f305484d535c",
+    "project-scope.cjs": "bf3d4448407ceb84bb33576438f65fce342477a975dcfcfde1963d47af7282c0",
+    "project-scope.schema.json": "05512ab16189a7beaafc12d6a85ebd1b4784f1c199888fff68d556becb15f42f",
+    "task-intent.cjs": "b603a5115fd9d2718b5d4edc7459c5b9c23eb9a95a0cd1089a242fd0e77e787a",
+    "integration-result.cjs": "56370e200bb78c7ec0ad577dcc76e28490f271d9cc78bfaa314dbd863fd0b57c",
+    "executor-invoke.cjs": "e06c71317f80e3c0647aa0c46ecc89a44f0b621a2b6320353e526f754f33104e",
+    "executor-process.cjs": "cceff60e2896947becbd86a364c96b94c4dab7c47a1bd90e6d4837a442e543ce",
+    "shared-support-check.cjs": "a3a6fae30ae93f8dbd0f6cab3f871cc0f61a6611a72c9c8d330423ab3f66dc66"
+  },
+  "developmentFiles": {
+    "scripts/compatibility-check.cjs": "3053e99c94f7af332791d4dede70c92b6937d1a0dc1a6caf1a14f514ee32dde2"
+  }
+}

package/bin/task-observability.cjs

@@ -316,7 +316,7 @@ function startTask(options) {
 
 function beginExecution(options) {
   const metadata = runMetadata(options);
-  const record = { ...baseRecord(metadata, "tool-started"), tool: safeText(options.tool, 128), targets: strings(options.targets), executionStatus: "started", validationStatus: "unverified", inputSnapshot: captureSnapshot(options), ruleSnapshot: contextSnapshot(options, "ruleFiles"), configSnapshot: contextSnapshot(options, "configFiles") };
+  const record = { ...baseRecord(metadata, "tool-started"), producer: { pid: process.pid }, tool: safeText(options.tool, 128), targets: strings(options.targets), executionStatus: "started", validationStatus: "unverified", inputSnapshot: captureSnapshot(options), ruleSnapshot: contextSnapshot(options, "ruleFiles"), configSnapshot: contextSnapshot(options, "configFiles") };
   record.recordPath = appendRecord(options, record);
   return { options: { ...options, runId: metadata.runId }, metadata, startedAt: Date.now(), record };
 }
@@ -395,6 +395,21 @@ async function withExecution(options, fn) {
   }
 }
 
+// Record a transport interruption only for starts created by this invocation.
+// No rule, file coverage or successful business result is inferred.
+function finishInterruptedExecutions(options, previousEventIds, processId, errorCode) {
+  if (!Number.isInteger(processId) || processId <= 0) return 0;
+  const records = allRecords(options).filter(record => record.runId === options.runId);
+  const finished = new Set(records.filter(record => record.kind === "tool-finished").map(record => record.executionId));
+  const pending = records.filter(record => record.kind === "tool-started" && record.producer?.pid === processId && !previousEventIds.has(record.eventId) && !finished.has(record.eventId));
+  for (const record of pending) {
+    const metadata = { packageName: options.packageName, packageVersion: options.packageVersion, runId: options.runId };
+    finishExecution({ options: { ...options, targets: record.targets }, metadata, record, startedAt: Date.parse(record.recordedAt) },
+      { exitCode: 1, validationStatus: "unverified", checks: [], checkedFiles: [], errorCode, summary: { source: "execution-transport", interrupted: true } });
+  }
+  return pending.length;
+}
+
 function readRecord(file, expectedPackage) {
   const data = JSON.parse(fs.readFileSync(file, "utf8"));
   if (data.recordVersion !== RECORD_VERSION || data.packageName !== expectedPackage) throw new Error("Unknown or foreign WL execution record");
@@ -476,7 +491,16 @@ function validationContext(plan, tools, options) {
   return { validationStatus: summarizeValidation(verifiers, pending, stale, unresolvedDecision || scopeGaps.length > 0 || executionOrderUnverified), pendingChecks: pending, stale, outdatedChecker, planStale, scopeGaps, unresolvedDecision, executionOrderUnverified,runtime };
 }
 
+function planRootFresh(plan, options) {
+  const recordedRoot = plan.decision.scope?.projectRoot || plan.notice?.projectRoot;
+  if (recordedRoot) {
+    try { if (fs.realpathSync(recordedRoot) !== fs.realpathSync(options.projectRoot || process.cwd())) return false; }
+    catch { return false; }
+  }
+  return true;
+}
 function planInputsFresh(plan, options) {
+  if (!planRootFresh(plan, options)) return false;
   if(plan.decision.action?.mode === 'inspect' && !snapshotsFresh([plan.inputSnapshot],options))return false;
   if (!snapshotsFresh([plan.ruleSnapshot, plan.configSnapshot], options)) return false;
   if (!plan.decision.scope?.fingerprint) return true;
@@ -695,4 +719,4 @@ function aggregateStatus(statuses) {
   return { recordVersion: RECORD_VERSION, runId: runIds.length === 1 ? runIds[0] : null, correlated: runIds.length === 1, packages: valid, mixedRuns: runIds.length > 1, hasFailure: valid.some((status) => status.validationStatus === "failed"), gaps: valid.flatMap((status) => status.gaps || []) };
 }
 
-module.exports = { RECORD_VERSION, STORAGE, evaluateTask, startTask, beginExecution, finishExecution, withExecution, captureSnapshot, readStatus, listGaps, doctorHost, inspectRuntime, attachNotice, formatDecision, formatStatus, aggregateStatus };
+module.exports = { RECORD_VERSION, STORAGE, evaluateTask, startTask, beginExecution, finishExecution, finishInterruptedExecutions, withExecution, captureSnapshot, readStatus, listGaps, doctorHost, inspectRuntime, attachNotice, formatDecision, formatStatus, aggregateStatus };

package/bin/wl-ui.js

@@ -97,7 +97,7 @@ if (rawArgs.length > 0 && SUBCOMMANDS.has(rawArgs[0])) {
 // 非 init 子命令：直接委托给 scanner/index.mjs
 if (subcommand === "protocol") {
   const { runCli } = await import("./protocol-cli.mjs");
-  process.exitCode = runCli(rawArgs);
+  process.exitCode = await runCli(rawArgs);
 } else if (["task", "route", "explain", "status", "doctor-host"].includes(subcommand)) {
   const { taskCli } = await import("./task-integration.mjs");
   taskCli(subcommand, rawArgs);

package/docs/maintenance-contract.md

@@ -0,0 +1,46 @@
+# 独立包与 Harness 的维护契约
+
+业务规则、Skill、模板、检查器和参数语义由本包维护。Harness 通过公开 `protocol` 调用，不复制这些实现。本包不依赖 Harness，也不要求安装兄弟包；PC 接入、移动端排除和项目边界判断仍以本包真实 scope 判定为准。
+
+## 稳定结构化执行入口
+
+先用 `protocol request` 的 `task` 创建计划，再读取 `status.result.integration` 中的 `allowedExecutors`、`targets`、`ruleRefs`、准入和新鲜度。选定已允许的执行器后请求：
+
+```json
+{
+  "protocolVersion": 1,
+  "operation": "execute",
+  "projectRoot": "/absolute/project",
+  "runId": "same-task-id",
+  "executorId": "从本包允许目录选择",
+  "parameters": { "targets": ["使用计划返回的实际目标"] }
+}
+```
+
+能力以本地 `protocol describe --json` 为准，特性为 `executor-invoke-v1`；参数遵守对应 `inventory.executors[].parameters` 的完整 JSON Schema。不能省略 projectRoot/runId，不能任意扩大目标、规则或执行权限。能力目录加载异常、缺口、歧义、只讨论任务、过期计划和版本不一致会拒绝执行。
+
+`ok=true` 表示结构化调用完成，不代表检查通过。`result.execution` 保留原执行器 exitCode、signal 和有界 stdout/stderr；真正业务验证结论来自 `result.integration`、实际工具回执与未验证项。业务只读检查可以写本包任务记录和报告。
+
+原 CLI 与结构化入口复用同一个原检查器。本包内部 CLI 参数调整只需修改本包映射；新版 Harness 不保存这些旗标。未提供此特性的旧包仍可独立使用原 CLI，宿主可以在明确提示 legacy 的情况下使用旧受控映射。
+
+## 版本、快照与自动监督
+
+- `npm run support:check` 依据本包自带的 sourceRevision、契约版本和 SHA256 清单离线检查共享核心，不要求兄弟源码。公共源修复统一分发，禁止人工单独编辑快照。
+- 公共开发工具支持 `support:sync -- --packages <keys> --check` 与按选定包分发；只读检查不能修改文件。来源 revision 相同表示同源内容，不要求五包每次同步发版。
+- `npm run compatibility:check` 对本包候选真实 tarball 做发布基线普通升级与已发布兄弟包共存验证；仅开发验收使用这些兄弟包，不构成运行依赖。
+- 五包本包 CI 执行快照检查及本包门禁；兼容 CI 保存产物和验收证据。Harness 自身另有已发布包与候选 SDK 验收。工作流配置与远端执行回执分开记录。
+- 本包主 CI 的 Ubuntu Node 22 分支执行 `pnpm audit --prod --audit-level=moderate`，监督锁定运行依赖的已知公告；该门禁不等同于任意输入都安全。
+- 完整开发依赖审计另行保留回执。当前 `braces@3.0.3` 的 GHSA-vfj7-8cjw-p6xm 属 Sass、lint 与提交工具的 glob 解析链；官方公告尚无已发布修复，不能把 registry 中不存在的 3.0.4 当作补丁，也不宣称完整开发图零告警。
+- 开发图另保留 `esbuild@0.27.7` 的低风险 GHSA-g7r4-m6w7-qqqr：公告针对 Windows 上 esbuild 自有 `servedir` 服务器；当前 tsup/Vite 构建使用编译 API，不启用该服务器。修复要求 0.28.1，超出现父依赖的 0.27 范围，本轮不以强制跨范围 override 替代兼容验证；未取得真实 Windows CI 回执前，不扩大平台验证结论。
+- 包版本、协议版本、公共快照 revision、SDK 版本分别管理。版本不同允许存在；破坏性公开契约变化须声明版本和兼容迁移。
+
+宿主可见回执应显示包及实际版本、技能/规则、目标、runId、准入与缺口、执行结果及证据新鲜度。宿主是否发现、读取或遵守规则必须有相应宿主证据，静态入口存在和模型自报不能代替。
+
+## 单包能力保留
+
+卸载 Harness 不改变本包 CLI/MCP、Skill 和检查器。未安装或未接入的兄弟项目不继承规则。公共契约检查不强制业务项目安装全部五包，也不会自动追随 npm latest。
+
+
+取消与路径证据：POSIX 执行器拥有独立进程组，取消立即终止其进程树；只对本次子进程实际新写且未结束的开始记录补执行失败、验证未验证、零规则通过/零检查文件的终态。并行同 runId 的其他进程记录不被代写。UTF8 输出按完整字节解码，stdout/stderr共用4MiB预算；预算超限不能成为成功。Windows进程树处理有实现，真实Windows执行须由CI另行采证。
+
+计划绑定原项目的真实路径；复制或移动项目后旧计划失效，需要重新建立任务。目录内外部符号链接不能扩大检查范围。快照清单同时记录可分发兼容脚本的哈希：源码中存在此脚本时离线验证其内容；运行时tarball可以不包含开发验收脚本，不因此依赖兄弟源码。实际编辑器加载、模型读取与远端CI运行记录仍由对应宿主提供。

package/docs/task-observability.md

@@ -25,3 +25,13 @@ UI scan 记录规则真实回调次数及 SFC_PARSE 错误；解析错误不受
 当前 CLI 检查回执覆盖 scan / audit / check / fix / all 与 Vite 依赖检查，本包 MCP 记录实际调用；其他 CLI snapshot / drift / exempt / contract / 脚手架保留既有产物与日志，不自动等同于 UI 源码检查。未由执行器报告实际文件的操作，其检查范围明确未知；不能用输入目录快照或成功退出补造文件覆盖。
 
 规则选择器来自实际注册表；未知 ID、格式错误和无界范围在扫描前拒绝。CLI 的未知参数、重复值选项、空值与额外位置参数同样不会启动检查或写入回执；JSON/summary/compact-v2 输出返回 `invalid-input` 与 `not-executed`。MCP 的错误调用返回 `isError=true` 与真实失败记录，保留同 runId，`checkedFiles` 与源码检查为空。已注册的规则选择和语法错误检查继续按原有契约执行。
+
+## 稳定协议执行
+
+编排层先调用 `protocol request` 的 `task`，再发送 `operation: "execute"`、当前项目绝对 `projectRoot`、同一 `runId`、`executorId: "scan"` 与 `parameters.targets`。UI 的 `rules` 只接受本次计划内的规则子集；省略时执行当前计划的 R 规则，不扩大到全量规则。SFC 解析检查独立执行且不能被隐藏。请求的执行器必须在当前状态的 `integration.allowedExecutors` 内；目标不能扩大，参数按目录 Schema 校验。解释、规划、禁止检查、未接入/移动项目、缺口、计划过期与已知版本漂移不会启动执行器。
+
+执行接线只保留本包参数映射，复用原 scan CLI，不复制规则或检查器。业务文件只读，原执行器仍写本包真实回执；返回 `result.execution` 和重新回查的 `result.integration`。调用 `ok=true` 不等于检查通过，非零退出、取消信号、实际文件和未验证项须如实展示。稳定接口使本包新版本不要求适配器或兄弟包同步修改；宿主/模型的实际读取和展示仍需独立证据。
+
+`--only/--skip` 在扫描前选择实际规则回调，CLI 与 MCP 使用同一选择器；回执的 ruleExecutions 只记录实际选中的规则。它们不只是过滤问题展示；SFC_PARSE 仍独立验证，不能被规则选择隐藏。
+
+原 scanner 与修复器在读取 Vue 文件前核验实际路径属于本项目；目录目标中的外部符号链接叶子也明确拒绝，不能静默跳过后称检查通过。本项目内合法文件链接继续可读；公开 execute 在启动原 CLI 前另做目标边界预检。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agile-team/wl-skills-ui",
-  "version": "1.20.1",
+  "version": "1.21.0",
   "description": "企业级 UI 风格对齐框架 — Vue + Element Plus 双模式、任务路由与真实检查回执（tokens / element / vendors / layouts / runtime / scanner / fixer / skills）",
   "type": "module",
   "main": "./es/index.js",
@@ -76,12 +76,14 @@
     "lint": "eslint . --cache --cache-location .eslintcache --max-warnings 0",
     "typecheck": "tsc -p tsconfig.check.json",
     "verify:package": "node scripts/verify-package.mjs",
-    "verify": "npm run lint && npm run typecheck && npm run test:coverage && npm run check:scss && npm run check:compat && npm run docs:check && npm run build && npm run verify:package",
+    "verify": "npm run support:check && npm run lint && npm run typecheck && npm run test:coverage && npm run check:scss && npm run check:compat && npm run docs:check && npm run build && npm run verify:package",
     "pack:dry": "npm pack --dry-run --ignore-scripts",
     "release:check": "npm run verify && npm run test:visual:contracts && npm run pack:dry",
-    "prepublishOnly": "npm run release:check",
+    "prepublishOnly": "npm run support:check && npm run release:check",
     "test:coverage": "node --test --experimental-test-coverage --test-coverage-exclude=bin/vendor/** --test-coverage-lines=70 --test-coverage-branches=65 --test-coverage-functions=70 scanner/__tests__/*.test.mjs runtime/__tests__/*.test.mjs bin/__tests__/*.test.mjs",
-    "benchmark:runtime": "node scripts/benchmark-observer-hub.mjs"
+    "benchmark:runtime": "node scripts/benchmark-observer-hub.mjs",
+    "support:check": "node bin/shared-support-check.cjs",
+    "compatibility:check": "node scripts/compatibility-check.cjs"
   },
   "files": [
     "dist",
@@ -171,5 +173,8 @@
     "{bin,mcp,runtime,scanner,scripts,standards}/**/*.{js,mjs,ts,mts,tsx,vue}": [
       "eslint --fix --no-cache"
     ]
+  },
+  "dependencies": {
+    "ajv": "8.20.0"
   }
 }

package/scanner/engine.mjs

@@ -1,5 +1,5 @@
-import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
-import { join, relative, resolve } from "node:path";
+import { existsSync, readFileSync, readdirSync, realpathSync, statSync } from "node:fs";
+import { dirname, join, relative, resolve, sep } from "node:path";
 import { getRules, normalizeIssue } from "./rules/index.mjs";
 import {
   createCoverageCollector,
@@ -10,7 +10,7 @@ import { loadExemptConfig } from "./exempt.mjs";
 import { collectChangedVueFiles } from "./changed.mjs";
 import { parseVueSfc, SFC_PARSER_MODES } from "./sfc-parser.mjs";
 import { resolveProjectProfile } from "../standards/profiles-loader.mjs";
-import { expandRuleSelector } from "./rule-selector.mjs";
+import { expandRuleSelector, selectRuleCallbacks } from "./rule-selector.mjs";
 
 export function expandRuleRange(input = "") {
   return input === "" ? new Set() : expandRuleSelector(input, getRules().map(rule => rule.id));
@@ -20,9 +20,12 @@ export function expandRuleRange(input = "") {
  * 递归收集 .vue 文件（目录名排序稳定遍历；target 为单个 .vue 文件时直接返回）。
  * 扫描与修复共用，保证两边看到同一文件集合。
  */
-export function* walkVue(target, excludes) {
+export function* walkVue(target, excludes, projectRoot) {
   if (!existsSync(target)) throw new Error(`扫描目标不存在：${target}`);
-  if (statSync(target).isFile()) {
+  const file = statSync(target).isFile();
+  const root = realpathSync(resolve(projectRoot || (file ? dirname(target) : target)));
+  assertVueBoundary(root, target);
+  if (file) {
     if (target.endsWith(".vue")) yield target;
     return;
   }
@@ -32,13 +35,19 @@ export function* walkVue(target, excludes) {
   for (const entry of entries) {
     const full = join(target, entry.name);
     if (entry.isDirectory()) {
-      if (!excludes.includes(entry.name)) yield* walkVue(full, excludes);
+      if (!excludes.includes(entry.name)) yield* walkVue(full, excludes, root);
     } else if (entry.name.endsWith(".vue")) {
+      assertVueBoundary(root, full);
       yield full;
     }
   }
 }
 
+function assertVueBoundary(root, file) {
+  const actual = realpathSync(file);
+  if (actual !== root && !actual.startsWith(root + sep)) throw new Error(`Vue 文件或目录必须位于项目根目录内（含符号链接）：${file}`);
+}
+
 function executeRule(rule, method, text, relPath, offset, executions) {
   const issues = rule[method](text, relPath, offset).map(normalizeIssue);
   const record = executions.get(rule.id);
@@ -73,7 +82,7 @@ export function scanFiles({
   const checkedFiles = [];
   const executions = new Map(rules.map((rule) => [rule.id, { id: rule.id, calls: 0, issues: 0, errors: 0 }]));
 
-  for (const filePath of walkVue(targetDir, excludeDirs)) {
+  for (const filePath of walkVue(targetDir, excludeDirs, projectRoot)) {
     if (fileFilter && !fileFilter.has(resolve(filePath))) continue;
     fileCount++;
     const content = readFileSync(filePath, "utf8");
@@ -193,7 +202,7 @@ export function scanProject(options = {}) {
     mode: options.mode,
   });
   const profile = profileResolution.profile;
-  const rules = getRules({ profile: profile.id });
+  const rules = selectRuleCallbacks(getRules({ profile: profile.id }), options, getRules().map(rule => rule.id));
   let fileFilter = null;
   let changed = { requested: false, fallback: false };
   if (options.changedOnly || options.changed) {

package/scanner/fix.mjs

@@ -371,8 +371,9 @@ export function runFix({
   let totalFiles = 0;
 
   // 第一遍：收集所有需要改动的文件及其内容
+  const root = projectRoot || resolve(target, "..");
   const pending = [];
-  for (const filePath of walkVue(target, exclude)) {
+  for (const filePath of walkVue(target, exclude, root)) {
     totalFiles++;
     const original = readFileSync(filePath, "utf8");
     let content = original;
@@ -414,7 +415,6 @@ export function runFix({
   }
 
   pending.sort((a, b) => a.filePath.localeCompare(b.filePath));
-  const root = projectRoot || resolve(target, "..");
   const planHash = createHash("sha256")
     .update(
       JSON.stringify({

package/scanner/index.mjs

@@ -28,7 +28,7 @@
 import { readFileSync, readdirSync, writeFileSync } from "node:fs";
 import { join, resolve, relative } from "node:path";
 import { parseScannerInput } from "./cli-input.mjs";
-import { expandRuleSelector } from "./rule-selector.mjs";
+import { expandRuleSelector, selectRuleCallbacks } from "./rule-selector.mjs";
 import { getRules } from "./rules/index.mjs";
 import { generateReport } from "./report.mjs";
 import { checkIntegration } from "./integration.mjs";
@@ -136,7 +136,7 @@ if (!["error", "full"].includes(values["changed-fallback"])) {
   process.exit(1);
 }
 const activeProfile = profileResolution.profile;
-const rules = getRules({ profile: activeProfile.id });
+const rules = selectRuleCallbacks(getRules({ profile: activeProfile.id }), values, REGISTERED_RULES);
 
 function resolveTarget(projectRoot, target) {
   return resolve(projectRoot, target || "src");

package/scanner/rule-selector.mjs

@@ -15,3 +15,10 @@ export function expandRuleSelector(input, registered) {
   if (missing.length) throw new Error(`不存在或格式无效的规则：${missing.join("、") || "空规则"}；请用 wl-ui rules list 核对规则 ID`);
   return selected;
 }
+
+/** Select callbacks before scanning; output filtering alone is not rule scope. */
+export function selectRuleCallbacks(rules, { only, skip } = {}, registered = rules.map(rule => rule.id)) {
+  const allow = only ? expandRuleSelector(only, registered) : null;
+  const deny = skip ? expandRuleSelector(skip, registered) : new Set();
+  return rules.filter(rule => (!allow || allow.has(rule.id)) && !deny.has(rule.id));
+}