@agile-team/wl-skills-ui 1.18.0 → 1.19.0

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## [1.19.0] - 2026-10-11
+
+- 区分当前请求、否定动作与历史引用，增加动作模式；解释/规划不自动检查，意图不作为业务写入授权。
+- 公开协议保持 v1 和原有字段，增加带 Schema 的 result.integration、规则身份与包自有只读执行器目录。
+- 编辑器 gateway 展示真实动作与规则回执；补充独立包语料、统一契约和执行边界回归，无兄弟包/Harness 依赖。
+- 触发词迁至独立目录并双向核验，明确 scan 样式检查与 check 接入检查的职责。
+
+
 ## [1.18.0] - 2026-10-11
 
 - 任务路由前校验目标项目自身接入与平台；未接入/移动端零规则零任务写入，不继承父安装。

package/README.md

@@ -510,7 +510,7 @@ npx wl-ui doctor --project . --print-overrides
 
 ## 版本与进一步阅读
 
-当前 v1.18.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 依赖识别。
+当前 v1.19.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)
@@ -532,3 +532,15 @@ npm run pack:dry
 ```
 
 视觉测试基线按操作系统管理；如果本机没有对应平台截图，完整 `test:visual` 会明确报告缺失，不应自动生成并提交一套未经评审的新基线。发布门禁使用跨浏览器计算样式契约 `test:visual:contracts`；真实浏览器兼容契约也可以单独执行 `browser-compat.spec.ts`。
+
+### 当前请求、动作边界与 Harness 集成
+
+任务判定保留原始文本，并将当前请求、历史引用和明确否定分开。自然语言判定覆盖已公开语料与规则，不能承诺任意表述都自动命中；遇到歧义或缺口应补充目标/领域或显式指定本包能力，不能静默选择。编辑前显示真实 `notice`，包括版本、技能、规则、目标、runId、动作与待检查项。
+
+`protocol describe --json` 声明 `task-intent-v1`、`result-core-v1`、`executor-catalog-v1`；`schemas.resultCore` 与五操作 `schemas.results` 可供宿主验证。原有结果字段保留，新增 `result.integration`：项目适用范围、动作模式、规则身份、目标、就绪状态、允许执行器和真实执行/验证状态。`ok` 只表示调用成功。未声明使用的输入字段进入 diagnostics，不会转成授权依据。
+
+`action.mode` 为 explain/plan/inspect/apply/unspecified；解释和规划不自动启动检查。`businessWritesAuthorized=false`，任务意图不能替代业务写入授权。`ruleRefs` 为包自有规则身份（包名、规则 ID、版本、来源、性质），自然语言约束有稳定 ID；原规则名称与列表保留。所有规则的机械/语义验证仍以实际回执为准。
+
+`inventory.executors` 声明本包业务只读检查器、目标与参数 Schema；其适用条件由本包判定。外部适配器须核对同项目、同包、同版本、同 runId 的真实计划、新鲜度与允许动作，指定一个目标，不能扩大范围；支持规则子集的执行器不得选择计划外规则。多目标需拆分调用。五包和 Harness 均为可选组合，不新增兄弟包或 Harness 运行时依赖；卸下适配器后原 CLI/MCP 继续独立使用。
+
+样式规则检查使用 `scan`（支持计划内规则子集）；`check` 只核验接入完整性。技能触发词由本包 `bin/task-triggers.json` 维护并接受目录一致性检查。

package/bin/__tests__/task-intent-cases.json

@@ -0,0 +1,34 @@
+[
+  {
+    "task": "旧需求写过“UI迁移迁移tokens”，本次只审查表单尺寸",
+    "status": "matched",
+    "skills": [
+      "element/el-form"
+    ],
+    "mode": "inspect"
+  },
+  {
+    "task": "不要迁移tokens，只检查现有表单样式",
+    "status": "matched",
+    "skills": [
+      "element/el-form"
+    ],
+    "mode": "inspect"
+  },
+  {
+    "task": "只说明 UI修复 的影响，不执行修改",
+    "status": "matched",
+    "skills": [
+      "ops/fix"
+    ],
+    "mode": "explain"
+  },
+  {
+    "task": "迁移tokens",
+    "status": "matched",
+    "skills": [
+      "ops/migrate"
+    ],
+    "mode": "apply"
+  }
+]

package/bin/__tests__/task-intent-routing.test.mjs

@@ -0,0 +1,41 @@
+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 dirname = import.meta.dirname;
+const repo = path.resolve(dirname, "../..");
+const pkg = JSON.parse(fs.readFileSync(path.join(repo, 'package.json'), 'utf8'));
+const cli = path.join(repo, 'bin/wl-ui.js');
+const cases = JSON.parse(fs.readFileSync(path.join(dirname, 'task-intent-cases.json'), 'utf8'));
+const key = "ui";
+test('当前请求、否定、历史引用与只讨论：公开协议精确回归', () => {
+  const temporary = fs.mkdtempSync(path.join(os.tmpdir(), 'wl-intent-ui-'));
+  const project = path.join(temporary, 'project');fs.mkdirSync(project);
+  const run = args => {
+    const result = spawnSync(process.execPath,[cli,...args],{cwd:project,encoding:'utf8',timeout:30000});
+    assert.equal(result.status,0,result.stderr || result.stdout);return result.stdout;
+  };
+  try {
+    fs.writeFileSync(path.join(project,'package.json'),JSON.stringify({private:true,devDependencies:{[pkg.name]:'*'}}));
+    const scoped = path.join(project,'node_modules/@agile-team');fs.mkdirSync(scoped,{recursive:true});fs.symlinkSync(repo,path.join(scoped,'wl-skills-ui'),'dir');
+    run(['init','--project',project,'--editor','agents-generic','--profile','native-element','--skills-only']);
+    for(const row of cases){
+      if(row.javaProject)fs.writeFileSync(path.join(project,'pom.xml'),'<project><modelVersion>4.0.0</modelVersion><groupId>audit</groupId><artifactId>fixture</artifactId><version>1</version></project>');
+      const file = path.join(temporary,'request.json');
+      fs.writeFileSync(file,JSON.stringify({operation:'route',projectRoot:project,task:row.task,...(row.domain ? {domain:row.domain} : {})}));
+      const envelope = JSON.parse(run(['protocol','request','--input-file',file,'--json']));
+      assert.equal(envelope.ok,true,row.task);const d = envelope.result.decision || envelope.result;
+      assert.equal(d.status,row.status,row.task);assert.deepEqual(d.selectedSkills,row.skills,row.task);
+      if(row.rules)assert.deepEqual(d.requiredRules,row.rules,row.task);
+      assert.equal(d.action.mode,row.mode,row.task);assert.equal(d.action.businessWritesAuthorized,false);
+      if(row.mode === 'explain')assert.equal(d.action.checksAllowed,false);
+      const core = envelope.result.integration;assert.equal(core.packageName,pkg.name);assert.equal(core.packageVersion,pkg.version);
+      assert.equal(core.contractVersion,1);assert.equal(core.runId,null);
+      assert.ok(core.ruleRefs.every(rule => rule.packageName === pkg.name && rule.ruleVersion === pkg.version));
+    }
+    const storage = {kit:'.wl-skills',ui:'.wl-skills-ui',bd:'.wl-skills-bd',design:'.wl-skills-design',test:'.wl-skills-test'}[key];
+    assert.equal(fs.existsSync(path.join(project,storage,'runs')),false,'route 不写任务记录');
+  } finally {fs.rmSync(temporary,{recursive:true,force:true});}
+});

package/bin/__tests__/task-trigger-catalog.test.mjs

@@ -0,0 +1,7 @@
+import test from 'node:test';import assert from 'node:assert/strict';import fs from 'node:fs';
+import {taskCatalog} from '../task-integration.mjs';
+test('触发词清单与本包技能目录双向完整且不含空词',() => {
+ const triggers = JSON.parse(fs.readFileSync(new URL('../task-triggers.json',import.meta.url),'utf8'));const catalog = taskCatalog();
+ assert.deepEqual(Object.keys(triggers).sort(),catalog.map(s => s.id).sort());
+ for(const skill of catalog){assert.ok(skill.triggers.length,skill.id);assert.ok(skill.triggers.every(p => typeof p === 'string' && p.trim()));assert.deepEqual(skill.triggers,triggers[skill.id]);}
+});

package/bin/executors.json

@@ -0,0 +1,48 @@
+[
+  {
+    "id": "scan",
+    "command": [
+      "scan"
+    ],
+    "when": {
+      "checks": [
+        "scan"
+      ]
+    },
+    "parameters": {
+      "type": "object",
+      "required": [
+        "targets"
+      ],
+      "properties": {
+        "targets": {
+          "type": "array",
+          "items": {
+            "type": "string",
+            "minLength": 1,
+            "pattern": "\\S"
+          },
+          "minItems": 1,
+          "maxItems": 1
+        },
+        "rules": {
+          "type": "array",
+          "items": {
+            "type": "string",
+            "pattern": "^R[0-9]{3}$"
+          },
+          "minItems": 1,
+          "uniqueItems": true
+        }
+      },
+      "additionalProperties": false
+    },
+    "sideEffects": {
+      "business": "none",
+      "records": true,
+      "reports": "stdout"
+    },
+    "authorization": "read-only-business-check",
+    "receipt": "package-execution-record-v1"
+  }
+]

package/bin/integration-protocol.cjs

@@ -16,6 +16,7 @@
  */
 
 const PROTOCOL_VERSION = 1;
+const resultCore = require("./integration-result.cjs");
 const SUPPORTED_VERSIONS = [1];
 const ERROR_CODES = ["unsupported-protocol", "unknown-operation", "missing-input", "invalid-input", "internal-error"];
 const OPTIONAL_STRING_FIELDS = ["requestId", "runId", "projectRoot", "skill", "host", "type", "domain", "profile"];
@@ -233,6 +234,7 @@ function validateFieldTypes(input) {
       commands: inventory.commands || [],
       mcpTools: inventory.mcpTools || [],
       loadErrors: inventory.loadErrors || [],
+      executors: config.executors || [],
       note: "业务执行仍走各包原 CLI/MCP；inventory 只声明公开调用映射与入口，不改变执行归属；loadErrors 非空表示目录派生存在异常，不得忽略",
     };
   }
@@ -255,9 +257,11 @@ function validateFieldTypes(input) {
       return {
         ...base(null, null),
         capabilities: config.capabilities || [],
+        features: ["task-intent-v1", "result-core-v1", "executor-catalog-v1"],
         operations: config.operations.map((operation) => ({ ...operation })),
         inventory: buildInventory(config),
-        schemas: { request: requestSchema(config), envelope: envelopeSchema(config.packageName) },
+        schemas: { request: requestSchema(config), envelope: envelopeSchema(config.packageName), resultCore: resultCore.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],
       };
@@ -267,8 +271,13 @@ function validateFieldTypes(input) {
       const { operation, error } = validateRequest(input);
       if (error) return error;
       const diagnostics = [];
+      const supportedFields = new Set(["operation", "protocolVersion", "requestId", ...operation.required, ...(operation.requireAny || []), ...operation.optional]);
+      for (const field of Object.keys(input)) {
+        if (!supportedFields.has(field)) diagnostics.push(`操作 ${operation.id} 未声明使用字段 ${field}；该字段不构成执行或授权依据`);
+      }
       try {
-        const result = runOperation(operation.id, input, diagnostics) ?? {};
+        const original = runOperation(operation.id, input, diagnostics) ?? {};
+        const result = resultCore.projectResult(original, input, config);
         return { ...base(operation.id, input.requestId), ok: true, result, diagnostics };
       } catch (thrown) {
         diagnostics.push(String((thrown && thrown.message) || thrown));

package/bin/integration-result.cjs

@@ -0,0 +1,76 @@
+"use strict";
+
+// Additive, typed core: original package-specific result fields are preserved.
+const path = require("node:path");
+const DECISIONS = ["matched", "baseline", "gap", "ambiguous", "not-applicable", "needs-context"];
+const strings = (items) => Array.isArray(items) ? items.filter((value) => typeof value === "string") : [];
+const nullableString = { type: ["string", "null"] };
+const SCHEMA = {
+  type: "object", additionalProperties: false,
+  required: ["contractVersion", "packageName", "packageVersion", "projectRoot", "runId", "decisionStatus", "scope", "action", "selectedSkills", "ruleRefs", "requiredChecks", "targets", "ready", "executionStatus", "validationStatus", "stale", "planStale", "allowedExecutors"],
+  properties: {
+    contractVersion: { const: 1 }, packageName: { type: "string", minLength: 1 }, packageVersion: { type: "string", minLength: 1 },
+    projectRoot: { type: "string", minLength: 1 }, runId: nullableString,
+    decisionStatus: { enum: [...DECISIONS, null] }, scope: { oneOf: [{type:"null"}, {type:"object",required:["schemaVersion","status","reason","adopted","projectType","inherited"],
+      properties:{schemaVersion:{const:1},status:{enum:["applicable","not-applicable","needs-context"]},reason:{type:"string"},adopted:{type:"boolean"},projectType:{type:"string"},inherited:{const:false}},additionalProperties:true}] },
+    action: { oneOf: [{ type: "null" }, { type: "object", required: ["mode", "checksAllowed", "businessWritesAuthorized", "authorization"],
+      properties: { mode: { enum: ["explain", "inspect", "plan", "apply", "unspecified"] }, checksAllowed: { type: "boolean" }, businessWritesAuthorized: { const: false }, authorization: { type: "string" } }, additionalProperties: false }] },
+    selectedSkills: { type: "array", items: { type: "string" } }, requiredChecks: { type: "array", items: { type: "string" } },
+    targets: { type: "array", items: { type: "string" } }, allowedExecutors: { type: "array", items: { type: "string" } },
+    ruleRefs: { type: "array", items: { type: "object", required: ["packageName", "ruleId", "legacyId", "name", "ruleVersion", "source", "kind", "verification"],
+      properties: { packageName: nullableString, ruleId: { type: "string" }, legacyId: { type: "string" }, name: { type: "string" }, ruleVersion: nullableString, source: nullableString, kind: { type: "string" }, verification: { const: "unverified" } }, additionalProperties: false } },
+    ready: { type: ["boolean", "null"] }, executionStatus: nullableString, validationStatus: nullableString,
+    stale: { type: ["boolean", "null"] }, planStale: { type: ["boolean", "null"] },
+  },
+};
+
+function allowedExecutors(decision, executors) {
+  if (!["matched", "baseline"].includes(decision.status) || !decision.action?.checksAllowed) return [];
+  return executors.filter((executor) => {
+    const when = executor.when || {};
+    return strings(when.skills).some((id) => decision.selectedSkills?.includes(id))
+      || strings(when.checks).some((id) => decision.requiredChecks?.includes(id))
+      || strings(when.rulePrefixes).some((prefix) => decision.requiredRules?.some((id) => id.startsWith(prefix)));
+  }).map((executor) => executor.id);
+}
+
+function resultReadiness(result, decision, status) {
+  if (typeof result.ready === "boolean") return result.ready;
+  if (typeof decision.ready === "boolean") return decision.ready;
+  return status ? ["matched", "baseline"].includes(status) && !(decision.missingInputs || []).length : null;
+}
+
+function executionState(result) {
+  return {
+    runId: result.runId || null,
+    executionStatus: result.executionStatus || null,
+    validationStatus: result.validationStatus || null,
+    stale: typeof result.stale === "boolean" ? result.stale : null,
+    planStale: typeof result.planStale === "boolean" ? result.planStale : null,
+  };
+}
+
+function decisionReadout(decision) {
+  return {action:decision.action || null, selectedSkills:strings(decision.selectedSkills), ruleRefs:decision.ruleRefs || [], requiredChecks:strings(decision.requiredChecks)};
+}
+function targetReadout(result,input) { return strings(result.targets || input.targets || result.notice?.targets); }
+function projectIdentity(scope,result,input) { return path.resolve(scope?.projectRoot || result.projectRoot || result.root || input.projectRoot || process.cwd()); }
+
+function projectResult(result, input, config) {
+  const decision = result.decision || result;
+  const scope = result.currentScope || decision.scope || result.scope || null;
+  const status = DECISIONS.includes(decision.status) ? decision.status : null;
+  const ready = resultReadiness(result, decision, status);
+  return {
+    ...result,
+    integration: {
+      contractVersion: 1, packageName: config.packageName, packageVersion: config.packageVersion,
+      projectRoot: projectIdentity(scope,result,input),
+      ...executionState(result), decisionStatus: status, scope,
+      ...decisionReadout(decision), targets: targetReadout(result,input), ready,
+      allowedExecutors: ready && scope?.status === "applicable" ? allowedExecutors(decision, config.executors || []) : [],
+    },
+  };
+}
+
+module.exports = { SCHEMA, projectResult };

package/bin/protocol-cli.mjs

@@ -16,9 +16,9 @@ const { createProtocol } = require("./integration-protocol.cjs");
 
 const BIN = "wl-ui";
 const OPERATIONS = [
-  { id: "route", summary: "只读任务判定：视觉/样式域技能、约束、歧义与缺口", readOnly: true, required: ["task"], optional: ["targets", "profile", "skill", "projectRoot"], sideEffects: "无写入", mapping: `${BIN} route --text "<task>"` },
-  { id: "explain", summary: "解释本次任务判定（只读，不记录）", readOnly: true, required: ["task"], optional: ["targets", "projectRoot"], sideEffects: "无写入", mapping: `${BIN} explain --text "<task>"` },
-  { id: "task", summary: "判定并持久化任务计划（尚未执行扫描或修复）", readOnly: false, required: ["task"], optional: ["runId", "targets", "profile", "projectRoot"], sideEffects: "写入 .wl-skills-ui/runs/ 下本包任务记录", mapping: `${BIN} task --text "<task>" [--run-id <id>]` },
+  { id: "route", summary: "只读任务判定：视觉/样式域技能、约束、歧义与缺口", readOnly: true, required: ["task"], optional: ["context", "targets", "profile", "skill", "projectRoot"], sideEffects: "无写入", mapping: `${BIN} route --text "<task>"` },
+  { id: "explain", summary: "解释本次任务判定（只读，不记录）", readOnly: true, required: ["task"], optional: ["context", "targets", "projectRoot"], sideEffects: "无写入", mapping: `${BIN} explain --text "<task>"` },
+  { id: "task", summary: "判定并持久化任务计划（尚未执行扫描或修复）", readOnly: false, required: ["task"], optional: ["context", "runId", "targets", "profile", "projectRoot"], sideEffects: "写入 .wl-skills-ui/runs/ 下本包任务记录", mapping: `${BIN} task --text "<task>" [--run-id <id>]` },
   { id: "status", summary: "读取本包执行/校验记录与新鲜度", readOnly: true, required: [], optional: ["runId", "projectRoot"], sideEffects: "无写入", mapping: `${BIN} status [--run-id <id>]` },
   { id: "doctor-host", summary: "宿主入口静态诊断（不证明宿主已加载）", readOnly: true, required: [], optional: ["host", "projectRoot"], sideEffects: "无写入", mapping: `${BIN} doctor-host [--host <host>]` },
 ];
@@ -31,7 +31,7 @@ function buildInventory() {
     { name: "clean", args: "[--project <path>] [--dry-run]", summary: "清理本包安装文件", execution: "programmatic", sideEffects: "删除本包登记文件" },
     { name: "scan", args: "[--project <path>] [--profile <id>]", summary: "R 规则扫描", execution: "programmatic", sideEffects: "无（报告输出）" },
     { name: "audit", args: "[--project <path>]", summary: "审计汇总", execution: "programmatic", sideEffects: "无" },
-    { name: "check", args: "[--project <path>]", summary: "扫描+回执记录", execution: "programmatic", sideEffects: "写 .wl-skills-ui/runs/" },
+    { name: "check", args: "[--project <path>]", summary: "接入完整性检查+回执记录（样式规则使用 scan）", execution: "programmatic", sideEffects: "写 .wl-skills-ui/runs/" },
     { name: "fix", args: "--run-id <id> --rule <id> [--confirm]", summary: "确定性修复（快照/回滚）", execution: "programmatic", sideEffects: "写源文件（确认制+快照回滚）" },
     { name: "snapshot", args: "/ drift / exempt", summary: "漂移基线管理", execution: "programmatic", sideEffects: "写基线文件" },
     { name: "contract", args: "<extract|validate|match>", summary: "ui-contract 提取/校验/匹配", execution: "programmatic", sideEffects: "extract 写契约文件" },
@@ -82,6 +82,7 @@ export const protocol = createProtocol({
   capabilities: capabilitiesDocument.capabilities || [],
   constraints: { projectScope: { config: ".wl-skills-scope.json", schema: "bin/project-scope.schema.json", adoption: "own-manifest-or-direct-dependency-or-explicit-enable", inheritance: "never-across-project-boundaries", excluded: ["mobile", "unadopted-project", "aggregate-workspace"] }, node: (pkg.engines && pkg.engines.node) || null, boundaryVersion: capabilitiesDocument.boundaryVersion || null },
   operations: OPERATIONS,
+  executors: require("./executors.json"),
   inventory: buildInventory(),
 });
 

package/bin/task-gateway.mjs

@@ -11,6 +11,8 @@ For one user task reuse the same \`--run-id\` or \`WL_TASK_RUN_ID\` across insta
 
 先确认目标项目自身的接入证据（本包安装清单、直接依赖或 \`.wl-skills-scope.json\` 显式启用），再判定任务。只在目标已接入且平台适用时读取规则；父目录安装、兄弟包、Vue 文件或触发词不能证明接入。未接入的开源项目不套用规则、不建议自动安装；UniApp/小程序/App/PDA/移动 H5 不适用。跨项目目标分别判定，沿最近项目边界停止，不能越过未接入子项目找父清单。工具返回 \`scope\` 作为静态范围证据，宿主加载仍需实际事件。
 
+动作边界：显示真实回执中的 \`action.mode\`、\`checksAllowed\` 和 \`ruleRefs\`。历史引用与明确禁止的动作不参与技能评分。只解释或只列计划时可以读取相关规范，不能因为命中了生成/修复技能就自动检查或改写业务文件。检查许可仅表示任务动作；业务写入仍遵循用户授权和本包原有流程。非适用项目不加载规范。
+
 多项目工作区先沿目标路径向上找到本包安装清单与项目 AGENTS，切到该项目根再调用工具；不要以聚合工作区根代替 projectRoot，也不要在聚合根安装。不同项目分别保存项目身份，同一用户任务复用 runId。
 
 1. Start each relevant task from its project root with \`node node_modules/@agile-team/wl-skills-ui/bin/wl-ui.js task "<task>" --target <path> --json\`. Before editing, visibly show the returned \`notice\`: actual package/version, decision, Skill or baseline, rule IDs/names, target, runId and unverified checks. Include baseline and gaps. Report missing/unsupported local commands and version drift explicitly. A routing decision does not execute checks.

package/bin/task-integration.mjs

@@ -3,6 +3,7 @@ import { join, relative, resolve, isAbsolute } from "node:path";
 import { parseArgs } from "node:util";
 import core from "./task-observability.cjs";
 import projectScope from "./project-scope.cjs";
+import taskIntent from "./task-intent.cjs";
 import { GATEWAY_PATH } from "./task-gateway.mjs";
 import { resolveProjectProfile } from "../standards/profiles-loader.mjs";
 import { getRules } from "../scanner/rules/index.mjs";
@@ -15,18 +16,7 @@ const POLICY = {
   baselineRules: ["R001", "R006", "R043"], baselineChecks: ["scan"], minimumScore: 1, minimumMargin: 1,
   unsupportedIntents: ["生成图像", "生成图片", "Figma设计稿导出"],
 };
-const TRIGGERS = {
-  "element/el-table": ["表格", "table", "el-table"], "element/el-form": ["表单", "查询表单", "el-form"],
-  "element/el-dialog": ["弹窗", "dialog", "el-dialog"], "element/el-tag": ["标签颜色", "状态标签", "el-tag"],
-  "element/component-family": ["卡片", "页签", "抽屉", "el-tabs", "上传控件"],
-  "runtime/design-tokens": ["设计令牌", "design tokens", "颜色硬编码", "tokens"],
-  "runtime/style-align": ["样式统一", "风格对齐", "样式不生效"], "runtime/migration": ["runtime迁移", "样式迁移"],
-  "ops/scan": ["UI扫描", "UI检查", "样式扫描"], "ops/audit": ["UI审计", "视觉审计"],
-  "ops/fix": ["UI修复", "修复样式", "统一视觉"], "ops/migrate": ["UI迁移", "迁移tokens"],
-  "layouts/list-page": ["列表布局"], "layouts/detail-page": ["详情布局"], "layouts/form-dialog": ["表单弹窗布局"], "layouts/tree-list": ["树列表布局"],
-  "vendors/ag-grid": ["AG Grid", "ag-grid"], "vendors/base-table": ["BaseTable"], "vendors/jh-components": ["jh组件"],
-  "vendors/c-components": ["C组件"], "vendors/custom-wrappers": ["自定义封装组件"], "vendors/unknown-wrapper": ["未知封装组件"],
-};
+const TRIGGERS = JSON.parse(readFileSync(join(root, "bin/task-triggers.json"), "utf8"));
 
 function catalogFiles(dir, result = []) {
   for (const entry of readdirSync(dir, { withFileTypes: true })) {
@@ -62,7 +52,7 @@ export function decideTask(input) {
   const catalog = taskCatalog();
   const decision = core.evaluateTask({ ...input, catalog, policy: POLICY });
   if (input.skill && !catalog.some((skill) => skill.id === input.skill)) return capabilityGap(decision, `本包未发布专项 Skill：${input.skill}`);
-  if (POLICY.unsupportedIntents.some((intent) => String(input.task).includes(intent))) return capabilityGap(decision, "本包没有图像生成或设计稿导出的执行器");
+  if (POLICY.unsupportedIntents.some((intent) => taskIntent.phraseMatches(input.task, intent))) return capabilityGap(decision, "本包没有图像生成或设计稿导出的执行器");
   return decision;
 }
 

package/bin/task-intent.cjs

@@ -0,0 +1,64 @@
+"use strict";
+
+/**
+ * Dependency-free task evidence snapshot. Domain routing remains in each package.
+ * Preserve the prompt; exclude explicit prohibitions and historical clauses from
+ * capability scoring. Intent never substitutes for business write authorization.
+ */
+const HISTORY = /(?:旧(?:需求|文档|任务|方案)|历史(?:需求|任务|记录)|上(?:次|一轮|轮)(?:需求|任务|要求|说)|(?:用户|客户|之前|以前).{0,8}(?:曾|原先)(?:说|要求|提)|曾(?:说|要求|提到)|previous(?:\s+(?:request|task))?|previously|used to|historical)/iu;
+const CURRENT = /(?:本次|这次|此次|现在|当前任务|实际要求|改为|而是|this time|now|instead)/iu;
+const NEGATIVE = /^(?:(?:请|本次|这次|此次|暂时|暂|先|也|并且|且|同时|还)\s*)*(?:不要|不用|无需|禁止|别|不再|不需要|不必|不(?:做|用|画|生成|执行|运行|新增|实现|修改|改写|迁移|创建|编写|修复|自动)|do not\b|don't\b|without\b|skip\b)/iu;
+const APPLY = /生成|绘制|新增|增加|实现|修改|改写|编写|修复|整改|创建|迁移|重构|同步|统一|调整|优化|完善|补充|补[^，。;\n]{0,12}注释|\b(?:generate|draw|create|implement|modify|write|fix|repair|migrate|refactor|adjust|optimize|improve)\b/iu;
+const INSPECT = /检查|校验|验证|审查|审计|扫描|评审|核对|走查|梳理|\b(?:check|validate|verify|inspect|review|audit|scan)\b/iu;
+const DISCUSSION = /(?:(?:只|仅)(?:需要)?(?:分析|讨论|解释|说明|了解|咨询)|(?:先|暂时)(?:分析|讨论|解释|说明)|\b(?:only|just)\s+(?:explain|discuss|describe|analy[sz]e)\b)/iu;
+
+function normalized(text) { return String(text || "").normalize("NFKC").toLowerCase().trim(); }
+
+function analyzeTask(task) {
+  const original = String(task || "").normalize("NFKC");
+  // Current-request markers and contrast conjunctions start a new evidence clause.
+  const clauses = original.replace(/(但(?:是)?|而是|改为|(?:本次|这次|此次|现在)(?=\s*(?:只|仅|请|要|需要|检查|审查|生成|修改|补充)))/gu, "\n$1")
+    .split(/[，,。；;!?！？\n]+/u).map((part) => part.trim()).filter(Boolean);
+  const excluded = [];
+  const active = [];
+  for (const raw of clauses) {
+    const clause = raw.replace(/^(?:但是|但|而是|改为)\s*/u, "").trim();
+    if (HISTORY.test(clause) && !CURRENT.test(clause)) {
+      excluded.push({ kind: "historical", text: clause });
+    } else if (NEGATIVE.test(clause)) {
+      excluded.push({ kind: "prohibited", text: clause });
+    } else active.push(clause);
+  }
+  const activeText = active.join("，");
+  return {schemaVersion:1,activeText,excluded,action:actionEvidence(activeText,excluded)};
+}
+
+function actionEvidence(activeText, excluded) {
+  const discussion = DISCUSSION.test(activeText);
+  const mode = discussion ? "explain" : /(?:只|仅|先)?(?:列|制定|提供|给出|做)(?:一个|一份)?[^，。;\n]{0,40}计划|\bplan\b/iu.test(activeText) ? "plan"
+    : APPLY.test(activeText) ? "apply" : INSPECT.test(activeText) ? "inspect"
+      : /解释|说明|讨论|咨询|\b(?:explain|discuss|describe)\b/iu.test(activeText) ? "explain" : "unspecified";
+  const genericStop = excluded.some((item) => item.kind === "prohibited" && /(?:暂|先|不要|不)(?:自动)?(?:执行|运行)(?:任何|所有)?(?:工具|命令|检查|校验)?\s*$|\b(?:do not|don't|skip)\s+(?:execute|run)\s+(?:(?:any|all)\s+)?(?:tools?|commands?|checks?)\s*$/iu.test(item.text));
+  return {
+    mode, checksAllowed: !genericStop && ["inspect", "apply"].includes(mode), businessWritesAuthorized: false,
+      authorization: "intent-is-not-business-write-authorization",
+  };
+}
+
+function phraseMatches(text, phrase) {
+  const haystack = normalized(analyzeTask(text).activeText);
+  const needle = normalized(phrase);
+  if (!needle) return false;
+  let at = haystack.indexOf(needle);
+  while (at !== -1) {
+    const before = haystack.slice(Math.max(0, at - 32), at);
+    const boundary = !/^[a-z0-9_.+-]+$/iu.test(needle)
+      || !/[a-z0-9_-]/iu.test((haystack[at - 1] || "") + (haystack[at + needle.length] || ""));
+    const negated = /(?:不要|不用|无需|禁止|别|不做|不|do not|don't|without)\s*(?:生成|创建|做|画|绘制|进行|设计|用|使用|执行|运行)?\s*$/iu.test(before);
+    if (boundary && !negated) return true;
+    at = haystack.indexOf(needle, at + needle.length);
+  }
+  return false;
+}
+
+module.exports = { analyzeTask, phraseMatches };

package/bin/task-observability.cjs

@@ -5,6 +5,7 @@ const fs = require("node:fs");
 const path = require("node:path");
 const crypto = require("node:crypto");
 const projectScope = require("./project-scope.cjs");
+const taskIntent = require("./task-intent.cjs");
 
 const RECORD_VERSION = 1;
 const STORAGE = {
@@ -48,18 +49,7 @@ function digest(value) {
 }
 
 function phraseMatches(text, phrase) {
-  const needle = normalized(phrase);
-  if (!needle) return false;
-  let index = text.indexOf(needle);
-  while (index !== -1) {
-    const before = text.slice(Math.max(0, index - 16), index);
-    const after = text[index + needle.length] || "";
-    const boundary = !/^[a-z0-9_-]+$/i.test(needle) || !/[a-z0-9_-]/i.test((text[index - 1] || "") + after);
-    const negated = /(?:不要|不用|无需|禁止|别|不是|不做|不|do not|don't|without)\s*$/i.test(before);
-    if (boundary && !negated) return true;
-    index = text.indexOf(needle, index + needle.length);
-  }
-  return false;
+  return taskIntent.phraseMatches(text, phrase);
 }
 
 function matches(text, words) {
@@ -84,7 +74,7 @@ function targetRelevance(targets, policy) {
 
 function taskSignals(options) {
   const policy = options.policy || {};
-  const text = normalized(options.task);
+  const text = normalized(taskIntent.analyzeTask(options.task).activeText);
   const context = options.context || {};
   const contextText = `${text} ${strings(options.targets).join(" ")} ${strings(context.signals).join(" ")}`;
   const relevant = matches(text, policy.domainKeywords).length > 0 || targetRelevance(options.targets, policy) || context.domainRelevant === true;
@@ -138,7 +128,8 @@ function evaluateTask(options = {}) {
   const signals = taskSignals(options);
   const candidates = (options.catalog || []).map((skill) => scoreSkill(skill, signals.text, signals.contextText))
     .filter((skill) => skill.score > 0).sort((left, right) => right.score - left.score || left.id.localeCompare(right.id));
-  return selectDecision(candidates, signals, options) || fallbackDecision(candidates, signals, options);
+  const result = selectDecision(candidates, signals, options) || fallbackDecision(candidates, signals, options);
+  return { ...result, taskEvidence: taskIntent.analyzeTask(options.task), action: taskIntent.analyzeTask(options.task).action };
 }
 
 function assertRunId(value) {
@@ -565,10 +556,22 @@ function noticeScope(record, options, item) {
     unverified: strings(item.unverified || ["host-discovery", "model-read-canonical-files", "planned-actions-not-executed"]) };
 }
 function noticeReason(item) { return safeText(item.reason || strings(item.reasons).join("；")); }
-function attachNotice(record, options = {}) {
+function prepareNoticeDecision(record,options) {
   const item = record.decision || record;
   record.packageName ||= options.packageName;
   record.packageVersion ||= options.packageVersion;
+  item.action ||= taskIntent.analyzeTask(record.task || item.task || "").action;
+  const details = new Map((item.ruleDetails || []).map((entry) => [entry.id, entry]));
+  item.ruleRefs ||= strings([...strings(item.requiredRules), ...details.keys()]).map((id) => {
+    const detail = details.get(id) || {};
+    return { packageName: record.packageName || null, ruleId: /^[a-zA-Z0-9_.:-]+$/.test(id) ? id : `constraint:${digest(id).slice(0, 16)}`,
+      legacyId: id, name: detail.name || id, ruleVersion: record.packageVersion || null,
+      source: detail.source || null, kind: detail.kind || "guidance", verification: "unverified" };
+  });
+  return item;
+}
+function attachNotice(record, options = {}) {
+  const item = prepareNoticeDecision(record,options);
   record.notice = {
     schemaVersion: 1, packageName: record.packageName || null, packageVersion: record.packageVersion || null,
     projectRoot: noticeProjectRoot(record, options), runId: record.runId || null, decision: item.status || "unverified",
@@ -576,6 +579,7 @@ function attachNotice(record, options = {}) {
     reason: noticeReason(item), missingInputs: strings(item.missingInputs),
     gaps: (item.gaps || []).map((gap) => ({ reason: safeText(gap.reason), suggestion: safeText(gap.suggestion) })),
     ...noticeScope(record, options, item), displayEvidence: "unverified",
+    action: item.action, ruleRefs: item.ruleRefs,
   };
   return record;
 }
@@ -594,7 +598,7 @@ function formatDecision(record) {
   const notice = record.notice || attachNotice({ ...record }).notice;
   const label = { baseline: "基础约束", ambiguous: "候选需确认", gap: "规则缺口", "not-applicable": "不适用", "needs-context": "缺少上下文" }[notice.decision] || "待判定";
   const identity = notice.packageName ? `${notice.packageName.replace("@agile-team/wl-skills-", "")}@${notice.packageVersion || "未知"}；` : "";
-  return `[WL ${notice.decision}] ${identity}${notice.skills.join("、") || label}；${notice.reason}` + `\n适用规则：${noticeRuleText(notice)}；范围：${notice.targets.slice(0, 3).join("、") || "未指定目标，检查范围待确认"}` + noticePlanText(notice) + noticeGapText(notice);
+  return `[WL ${notice.decision}] ${identity}${notice.skills.join("、") || label}；${notice.reason}` + `\n动作=${notice.action.mode}；允许自动检查=${notice.action.checksAllowed}；业务写入遵循原授权契约` + `\n适用规则：${noticeRuleText(notice)}；范围：${notice.targets.slice(0, 3).join("、") || "未指定目标，检查范围待确认"}` + noticePlanText(notice) + noticeGapText(notice);
 }
 
 function formatStatus(status) {

package/bin/task-triggers.json

@@ -0,0 +1,93 @@
+{
+  "element/el-table": [
+    "表格",
+    "table",
+    "el-table"
+  ],
+  "element/el-form": [
+    "表单",
+    "查询表单",
+    "el-form"
+  ],
+  "element/el-dialog": [
+    "弹窗",
+    "dialog",
+    "el-dialog"
+  ],
+  "element/el-tag": [
+    "标签颜色",
+    "状态标签",
+    "el-tag"
+  ],
+  "element/component-family": [
+    "卡片",
+    "页签",
+    "抽屉",
+    "el-tabs",
+    "上传控件"
+  ],
+  "runtime/design-tokens": [
+    "设计令牌",
+    "design tokens",
+    "颜色硬编码",
+    "tokens"
+  ],
+  "runtime/style-align": [
+    "样式统一",
+    "风格对齐",
+    "样式不生效"
+  ],
+  "runtime/migration": [
+    "runtime迁移",
+    "样式迁移"
+  ],
+  "ops/scan": [
+    "UI扫描",
+    "UI检查",
+    "样式扫描"
+  ],
+  "ops/audit": [
+    "UI审计",
+    "视觉审计"
+  ],
+  "ops/fix": [
+    "UI修复",
+    "修复样式",
+    "统一视觉"
+  ],
+  "ops/migrate": [
+    "UI迁移",
+    "迁移tokens"
+  ],
+  "layouts/list-page": [
+    "列表布局"
+  ],
+  "layouts/detail-page": [
+    "详情布局"
+  ],
+  "layouts/form-dialog": [
+    "表单弹窗布局"
+  ],
+  "layouts/tree-list": [
+    "树列表布局"
+  ],
+  "vendors/ag-grid": [
+    "AG Grid",
+    "ag-grid"
+  ],
+  "vendors/base-table": [
+    "BaseTable"
+  ],
+  "vendors/jh-components": [
+    "jh组件"
+  ],
+  "vendors/c-components": [
+    "C组件"
+  ],
+  "vendors/custom-wrappers": [
+    "自定义封装组件"
+  ],
+  "vendors/unknown-wrapper": [
+    "未知封装组件"
+  ]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agile-team/wl-skills-ui",
-  "version": "1.18.0",
+  "version": "1.19.0",
   "description": "企业级 UI 风格对齐框架 — Vue + Element Plus 双模式、任务路由与真实检查回执（tokens / element / vendors / layouts / runtime / scanner / fixer / skills）",
   "type": "module",
   "main": "./es/index.js",