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

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## [1.18.0] - 2026-10-11
+
+- 任务路由前校验目标项目自身接入与平台；未接入/移动端零规则零任务写入，不继承父安装。
+- 最近项目边界与跨项目拆分、独立包禁用、严格范围Schema、notice/doctor/status范围与过期证据。
+- 原生及编辑器入口收窄适用描述；补充单包、移动端、开源未接入、工作区、异常配置和Maven模块回归。
+
 All notable changes to **@agile-team/wl-skills-ui** will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).

package/README.md

@@ -1,5 +1,7 @@
 # @agile-team/wl-skills-ui
 
+> 项目范围：只对目标自身已接入且平台适用的项目判定规则；父工作区安装不启用子项目。移动端与未接入开源项目不套用。详见 [精准触发与范围配置](docs/project-scope.md)。
+
 **企业级 UI 一致性与 AI 精确治理工具包 v1.17.0** — 面向 Vue 3 + Element Plus 的设计令牌、能力 Profile、样式皮肤、页面骨架、运行时能力、静态扫描、确定性修复、AI Skill、MCP 与脱敏 UI 模板契约。
 
 它把“视觉统一、问题识别、机械修复、项目适配和样例沉淀”拆成可验证、可组合的工程能力。脚本、规则和 MCP 先完成确定性工作，AI 只处理业务语义与人工决策，从而减少重复读源码、上下文 token 和误修改。
@@ -508,7 +510,7 @@ npx wl-ui doctor --project . --print-overrides
 
 ## 版本与进一步阅读
 
-当前 v1.17.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.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 依赖识别。
 
 - [版本摘要](docs/version-history.md)
 - [完整 Changelog](CHANGELOG.md)

package/SKILL.md

@@ -1,11 +1,15 @@
 ---
 name: wl-skills-ui
 description: |
+  Only for PC Vue admin projects that adopted wl-skills-ui; excludes mobile and unadopted projects.
   Audit and align Vue 3 + Element Plus enterprise UI projects with deterministic
   scanning, profile-aware fixes, design tokens, vendor adapters, and runtime guards.
   Use for UI consistency, legacy skin migration, rule diagnostics, or safe UI fixes.
 ---
 
+先确认目标项目自身的接入证据（本包安装清单、直接依赖或 `.wl-skills-scope.json` 显式启用），再判定任务。只在目标已接入且平台适用时读取规则；父目录安装、兄弟包、Vue 文件或触发词不能证明接入。未接入的开源项目不套用规则、不建议自动安装；UniApp/小程序/App/PDA/移动 H5 不适用。跨项目目标分别判定，沿最近项目边界停止，不能越过未接入子项目找父清单。工具返回 `scope` 作为静态范围证据，宿主加载仍需实际事件。
+
+
 # wl-skills-ui
 
 Use deterministic project facts before reading or editing business source. Rules,

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

@@ -3,7 +3,7 @@
  */
 import { test } from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync } from "node:fs";
+import fs, { mkdtempSync } from "node:fs";
 import { tmpdir } from "node:os";
 import path from "node:path";
 import { spawnSync } from "node:child_process";
@@ -17,7 +17,9 @@ const pkg = require("../../package.json");
 const BIN = path.join(here, "..", "wl-ui.js");
 
 function tempRoot() {
-  return mkdtempSync(path.join(tmpdir(), "wl-ui-protocol-"));
+  const root = mkdtempSync(path.join(tmpdir(), "wl-ui-protocol-"));
+  fs.writeFileSync(path.join(root, "package.json"), JSON.stringify({ devDependencies: { "@agile-team/wl-skills-ui": "*" } }));
+  return root;
 }
 
 test("describe 返回协议版本、能力目录与五个统一操作", () => {

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

@@ -3,14 +3,16 @@
  */
 import { test } from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync } from "node:fs";
+import fs, { mkdtempSync } from "node:fs";
 import { tmpdir } from "node:os";
 import path from "node:path";
 
 const { protocol, runOperation } = await import("../protocol-cli.mjs");
 
 function tempRoot() {
-  return mkdtempSync(path.join(tmpdir(), "wl-ui-evidence-"));
+  const root = mkdtempSync(path.join(tmpdir(), "wl-ui-evidence-"));
+  fs.writeFileSync(path.join(root, "package.json"), JSON.stringify({ devDependencies: { "@agile-team/wl-skills-ui": "*" } }));
+  return root;
 }
 
 test("status 严格回查同一 runId：字段精确、不兜底", () => {

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

@@ -4,7 +4,7 @@
  */
 import { test, before } from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, rmSync } from "node:fs";
+import fs, { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import path from "node:path";
 import { spawnSync } from "node:child_process";
@@ -22,6 +22,7 @@ function tempRoot() {
 }
 
 function routeAt(projectRoot, task) {
+  if (!fs.existsSync(path.join(projectRoot, "package.json"))) fs.writeFileSync(path.join(projectRoot, "package.json"), JSON.stringify({ devDependencies: { "@agile-team/wl-skills-ui": "*" } }));
   return protocol.request({ operation: "route", projectRoot, task }, runOperation);
 }
 
@@ -40,7 +41,7 @@ for (const item of cases) {
   const expectedBare = item.skill ? "gap" : item.status;
   const expectedInstalled = item.installedStatus || (item.skill ? "matched" : item.status);
 
-  test(`未安装：「${item.task}」→ ${expectedBare}${item.skill ? ` + ${item.skill}` : ""}`, () => {
+  test(`已声明接入但未初始化：「${item.task}」→ ${expectedBare}${item.skill ? ` + ${item.skill}` : ""}`, () => {
     const envelope = routeAt(tempRoot(), item.task);
     assert.equal(envelope.ok, true);
     const decision = envelope.result.decision || envelope.result;

package/bin/project-scope.cjs

@@ -0,0 +1,198 @@
+"use strict";
+
+// Independent snapshot: project adoption is checked before skill intent or writes.
+const fs = require("node:fs");
+const path = require("node:path");
+const crypto = require("node:crypto");
+const CONFIG = ".wl-skills-scope.json";
+const MANIFESTS = {
+  kit: ".wl-skills-manifest.json", ui: ".wl-skills-ui-manifest.json",
+  bd: ".wl-skills-bd-manifest.json", design: ".wl-skills-design/state.json", test: ".wl-skills-test/manifest.json",
+};
+const TYPES = new Set(["pc", "backend", "documents", "testing", "mobile", "workspace", "unknown"]);
+
+function inside(root, target) {
+  const rel = path.relative(root, target);
+  return !path.isAbsolute(rel) && rel !== ".." && !rel.startsWith(`..${path.sep}`);
+}
+
+// Resolve missing paths through their nearest existing ancestor, including symlinks.
+function realTarget(target) {
+  if (fs.existsSync(target)) return fs.realpathSync(target);
+  const parent = path.dirname(target);
+  if (parent === target) throw new Error("Cannot resolve target ancestor");
+  return path.join(realTarget(parent), path.basename(target));
+}
+
+function readJson(root, relative) {
+  const file = path.join(root, relative);
+  if (!fs.existsSync(file)) return { present: false, value: null };
+  try {
+    if (!inside(root, fs.realpathSync(file))) throw new Error("metadata path escapes project");
+    const value = JSON.parse(fs.readFileSync(file, "utf8"));
+    if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("expected object");
+    return { present: true, value };
+  } catch (error) { return { present: true, value: null, error: `${relative}: ${error.message}` }; }
+}
+
+function boundary(root, fallback) {
+  const markers = ["package.json", ".git", CONFIG, ...Object.values(MANIFESTS)];
+  // A Java project's Maven modules share its adoption; a nested independent repo still stops lookup.
+  if (root === fallback || !fs.existsSync(path.join(fallback, "pom.xml"))) markers.push("pom.xml");
+  return markers.some((file) => fs.existsSync(path.join(root, file)));
+}
+
+function nearestRoot(target, fallback) {
+  let dir = fs.existsSync(target) && fs.statSync(target).isDirectory() ? target : path.dirname(target);
+  while (inside(fallback, dir)) {
+    if (boundary(dir, fallback) || dir === fallback) return dir;
+    dir = path.dirname(dir);
+  }
+  return null;
+}
+
+function targetRoots(root, targets) {
+  const resolved = targets.map((target) => realTarget(path.resolve(root, target)));
+  if (resolved.some((target) => !inside(root, target))) return { error: "target-outside-authorized-project", roots: [], resolved };
+  return { roots: [...new Set(resolved.map((target) => nearestRoot(target, root)))], resolved };
+}
+
+function scopeConfig(root) {
+  const config = readJson(root, CONFIG);
+  if (!config.present || config.error) return config;
+  const { value } = config;
+  const allowed = ["schemaVersion", "projectType", "packages"];
+  if (value.schemaVersion !== 1 || !TYPES.has(value.projectType) || Object.keys(value).some((key) => !allowed.includes(key)) || !validPackageSwitches(value.packages)) {
+    return { ...config, error: `${CONFIG}: invalid schemaVersion/projectType/packages` };
+  }
+  return config;
+}
+
+function validPackageSwitches(packages) {
+  if (packages === undefined) return true;
+  return Boolean(packages && typeof packages === "object" && !Array.isArray(packages) && Object.entries(packages).every(([key, enabled]) => Object.hasOwn(MANIFESTS, key) && typeof enabled === "boolean"));
+}
+
+function mobileEvidence(root, pkg) {
+  const deps = Object.keys({ ...pkg.dependencies, ...pkg.devDependencies });
+  const mobile = deps.filter((name) => /^@dcloudio\/uni(?:-|$)|^@tarojs\/|^react-native$|^expo$|^@ionic\/|^@capacitor\//.test(name));
+  if (fs.existsSync(path.join(root, "pages.json")) && fs.existsSync(path.join(root, "manifest.json"))) mobile.push("pages.json+manifest.json");
+  return mobile;
+}
+
+function adoption(root, key, packageName, pkg, config) {
+  const manifest = readJson(root, MANIFESTS[key]);
+  validateAdoptionManifest(manifest, key, packageName);
+  const declared = [pkg.dependencies, pkg.devDependencies, pkg.optionalDependencies].some((deps) => deps?.[packageName]);
+  const explicit = config.value?.packages?.[key] === true;
+  const installed = manifest.present && !manifest.error;
+  return { adopted: explicit || declared || installed, sources: [
+    ...(explicit ? [`${CONFIG}:packages.${key}`] : []), ...(declared ? ["package.json:direct-dependency"] : []),
+    ...(installed ? [MANIFESTS[key]] : []),
+  ], error: manifest.error || null };
+}
+
+function validateAdoptionManifest(manifest, key, packageName) {
+  if (!manifest.present || manifest.error) return;
+  const { value } = manifest;
+  if (typeof value.version !== "string" || !value.version.trim() || value.package && value.package !== packageName) manifest.error = `${MANIFESTS[key]}: invalid package/version`;
+}
+
+function verdict(status, reason, extra = {}) {
+  return { schemaVersion: 1, status, reason, adopted: false, projectType: "unknown", evidence: [], inherited: false, ...extra };
+}
+
+function inspectProject(root, key, packageName) {
+  const config = scopeConfig(root);
+  const packageFile = readJson(root, "package.json");
+  if (config.error || packageFile.error) return verdict("needs-context", "invalid-project-metadata", { diagnostics: [config.error || packageFile.error] });
+  const pkg = packageFile.value || {};
+  if (!["dependencies", "devDependencies", "optionalDependencies"].every((field) => validDependencies(pkg[field]))) {
+    return verdict("needs-context", "invalid-project-metadata", { diagnostics: ["package.json: dependency declarations must be nonempty strings"] });
+  }
+  const exclusion = platformExclusion(root, key, pkg, config);
+  if (exclusion) return exclusion;
+  const own = adoption(root, key, packageName, pkg, config);
+  if (own.error) return verdict("needs-context", "invalid-package-adoption", { diagnostics: [own.error] });
+  if (!own.adopted) return verdict("not-applicable", "package-not-adopted-in-target-project");
+  return adoptedScope(root, key, pkg, config, own);
+}
+
+function validDependencies(deps) {
+  if (deps === undefined) return true;
+  return Boolean(deps && typeof deps === "object" && !Array.isArray(deps) && Object.values(deps).every((value) => typeof value === "string" && value.trim()));
+}
+
+function platformExclusion(root, key, pkg, config) {
+  const mobile = mobileEvidence(root, pkg);
+  const type = config.value?.projectType;
+  if (mobile.length || type === "mobile") return verdict("not-applicable", "mobile-project-excluded", { projectType: "mobile", evidence: mobile.length ? mobile : [CONFIG] });
+  if (type === "workspace") return verdict("not-applicable", "aggregate-workspace-is-not-project", { projectType: type, evidence: [CONFIG] });
+  if (config.value?.packages?.[key] === false) return verdict("not-applicable", "package-explicitly-disabled", { projectType: type || "unknown", evidence: [CONFIG] });
+  return null;
+}
+
+function unsupportedFrontend(root, key, pkg, type) {
+  if (!["kit", "ui"].includes(key)) return false;
+  if (type && type !== "pc") return "pc-frontend-package-excluded";
+  const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+  return !deps.vue && (deps.react || deps.svelte || deps["@angular/core"] || fs.existsSync(path.join(root, "pom.xml"))) ? "unsupported-project-framework" : false;
+}
+
+function defaultType(key) { return { kit: "pc", ui: "pc", bd: "backend", design: "documents", test: "testing" }[key]; }
+
+function scopeFingerprint(root, key) {
+  const metadata = [CONFIG, "package.json", "pom.xml", MANIFESTS[key], "pages.json", "manifest.json"].map((file) => {
+    const full = path.join(root, file);
+    if (!fs.existsSync(full)) return [file, "missing"];
+    if (!inside(root, fs.realpathSync(full))) return [file, "external-metadata"];
+    try { return [file, crypto.createHash("sha256").update(fs.readFileSync(full)).digest("hex")]; }
+    catch (error) { return [file, `unreadable:${error.code}`]; }
+  });
+  return crypto.createHash("sha256").update(JSON.stringify(metadata)).digest("hex");
+}
+
+function adoptedScope(root, key, pkg, config, own) {
+  const type = config.value?.projectType;
+  if (type === "unknown") return verdict("needs-context", "project-platform-needs-context", { adopted: true, evidence: own.sources });
+  const unsupported = unsupportedFrontend(root, key, pkg, type);
+  if (unsupported) return verdict("not-applicable", unsupported, { adopted: true, projectType: type || "unknown", evidence: ["package.json/pom.xml", ...own.sources] });
+  return verdict("applicable", "target-project-explicitly-adopted-package", {
+    adopted: true, projectType: type || defaultType(key),
+    typeEvidence: type ? "explicit-config" : "adoption-default-not-host-observed", evidence: own.sources,
+  });
+}
+
+/** Parent installation, Vue files and keyword matches are never adoption evidence. */
+function resolveScope({ projectRoot, packageName, targets = [] }) {
+  const root = fs.realpathSync(path.resolve(projectRoot || process.cwd()));
+  const key = packageName.replace("@agile-team/wl-skills-", "");
+  if (!Object.hasOwn(MANIFESTS, key)) throw new Error("Unknown WL package");
+  const located = targetRoots(root, targets.filter((item) => typeof item === "string" && item.trim()));
+  if (located.error || located.roots.length > 1) return { projectRoot: root, targets, scope: verdict("needs-context", located.error || "multiple-project-targets-split-required", { projectRoots: located.roots }) };
+  const actualRoot = located.roots[0] || root;
+  const actualTargets = located.resolved.map((target) => path.relative(actualRoot, target).split(path.sep).join("/") || ".");
+  return { projectRoot: actualRoot, targets: actualTargets, scope: { ...inspectProject(actualRoot, key, packageName), projectRoot: actualRoot, fingerprint: scopeFingerprint(actualRoot, key) } };
+}
+
+function excludedDecision(scope) {
+  const messages = {
+    "mobile-project-excluded": "目标为移动端/UniApp/小程序项目，不适用本轮WL项目约束",
+    "aggregate-workspace-is-not-project": "目标是聚合工作区，请指定实际已接入项目",
+    "package-explicitly-disabled": "目标项目已明确禁用本包",
+    "package-not-adopted-in-target-project": "目标项目未接入本包，不继承父目录或兄弟项目的安装",
+    "pc-frontend-package-excluded": "目标项目不是已接入的PC前端，PC规范不适用",
+    "unsupported-project-framework": "目标技术栈不是本包支持的Vue管理端，不套用PC Vue规范",
+    "multiple-project-targets-split-required": "目标跨越多个项目，请按项目分别判定并复用任务runId",
+    "target-outside-authorized-project": "目标超出当前授权项目边界，请从实际目标项目根调用",
+    "project-platform-needs-context": "项目已接入但平台未确认，请确认PC/后端/文档/测试或移动端范围",
+  };
+  const reason = messages[scope.reason] || "项目范围元数据无效，需要核对后再应用规则";
+  return { recordVersion: 1, status: scope.status, applicable: scope.status === "needs-context" ? null : false,
+    reason, reasons: [reason], scope, selectedSkills: [], candidates: [], baselineRules: [], requiredRules: [],
+    ruleDetails: [], requiredChecks: [], requiredFiles: [], missingInputs: scope.status === "needs-context" ? ["有效的目标项目范围"] : [],
+    gaps: [], constraints: [], ready: false, executionStatus: "not-executed", validationStatus: "unverified",
+    selectionEvidence: "project-scope-before-intent", hostDiscovery: "unverified", contentLoaded: "unverified", unverified: ["host-discovery", "model-read-canonical-files"] };
+}
+
+module.exports = { CONFIG, MANIFESTS, resolveScope, excludedDecision };

package/bin/project-scope.schema.json

@@ -0,0 +1,48 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "urn:wl-skills:project-scope:1",
+  "title": "Explicit WL project scope and per-package adoption",
+  "type": "object",
+  "required": [
+    "schemaVersion",
+    "projectType"
+  ],
+  "additionalProperties": false,
+  "properties": {
+    "schemaVersion": {
+      "const": 1
+    },
+    "projectType": {
+      "enum": [
+        "pc",
+        "backend",
+        "documents",
+        "testing",
+        "mobile",
+        "workspace",
+        "unknown"
+      ]
+    },
+    "packages": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "kit": {
+          "type": "boolean"
+        },
+        "ui": {
+          "type": "boolean"
+        },
+        "bd": {
+          "type": "boolean"
+        },
+        "design": {
+          "type": "boolean"
+        },
+        "test": {
+          "type": "boolean"
+        }
+      }
+    }
+  }
+}

package/bin/protocol-cli.mjs

@@ -80,7 +80,7 @@ export const protocol = createProtocol({
   packageName: pkg.name,
   packageVersion: pkg.version,
   capabilities: capabilitiesDocument.capabilities || [],
-  constraints: { node: (pkg.engines && pkg.engines.node) || null, boundaryVersion: capabilitiesDocument.boundaryVersion || null },
+  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,
   inventory: buildInventory(),
 });

package/bin/task-gateway.mjs

@@ -3,12 +3,14 @@ export const GATEWAY_PATH = ".agents/skills/wl-skills-ui/SKILL.md";
 export function taskGateway() {
   return `---
 name: wl-skills-ui
-description: Vue and Element Plus UI consistency, design tokens, styles, component layout and visual rule checks. Decide the applicable UI workflow and verify actual source files using local package tools.
+description: Only for adopted PC Vue/Web admin projects; excludes mobile and unadopted projects. Vue and Element Plus UI consistency, design tokens, styles, component layout and visual rule checks. Decide the applicable UI workflow and verify actual source files using local package tools.
 ---
 
 # wl-skills-ui task gateway
 For one user task reuse the same \`--run-id\` or \`WL_TASK_RUN_ID\` across installed applicable packages. Do not install unused sibling packages or create unrelated IDs.
 
+先确认目标项目自身的接入证据（本包安装清单、直接依赖或 \`.wl-skills-scope.json\` 显式启用），再判定任务。只在目标已接入且平台适用时读取规则；父目录安装、兄弟包、Vue 文件或触发词不能证明接入。未接入的开源项目不套用规则、不建议自动安装；UniApp/小程序/App/PDA/移动 H5 不适用。跨项目目标分别判定，沿最近项目边界停止，不能越过未接入子项目找父清单。工具返回 \`scope\` 作为静态范围证据，宿主加载仍需实际事件。
+
 多项目工作区先沿目标路径向上找到本包安装清单与项目 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

@@ -2,6 +2,7 @@ import { readFileSync, readdirSync, existsSync, realpathSync } from "node:fs";
 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 { GATEWAY_PATH } from "./task-gateway.mjs";
 import { resolveProjectProfile } from "../standards/profiles-loader.mjs";
 import { getRules } from "../scanner/rules/index.mjs";
@@ -70,14 +71,16 @@ function capabilityGap(decision, reason) {
 }
 
 export function runTaskAction(action, input = {}) {
-  const opts = taskOptions(input.projectRoot || process.env.WL_PROJECT_ROOT || process.cwd(), { runId: input.runId, targets: input.targets || [] });
+  const resolved = projectScope.resolveScope({ projectRoot: input.projectRoot || process.env.WL_PROJECT_ROOT || process.cwd(), packageName: pkg.name, targets: input.targets || [] });
+  const opts = taskOptions(resolved.projectRoot, { runId: input.runId, targets: resolved.targets });
   if (action === "status") return core.readStatus(opts);
   if (action === "doctor-host") return hostDiagnostic({ ...opts, host: input.host || "unknown" });
+  if (resolved.scope.status !== "applicable") return core.attachNotice(projectScope.excludedDecision(resolved.scope), opts);
   const profile = resolveProjectProfile({ projectRoot: opts.projectRoot, profile: input.profile }).profile;
-  const routed = decideTask({ task: input.task || "", targets: opts.targets, skill: input.skill });
+  const routed = decideTask({ task: input.task || "", targets: opts.targets, skill: input.skill, context: input.context });
   const applicable = getRules({ profile: profile.id });
   const enabled = new Set(applicable.map((rule) => rule.id));
-  const decision = { ...routed, profile: profile.id, applicableConstraints: routed.applicable === true ? [...enabled] : [] };
+  const decision = { ...routed, scope: resolved.scope, profile: profile.id, applicableConstraints: routed.applicable === true ? [...enabled] : [] };
   decision.baselineRules = decision.baselineRules.filter((id) => enabled.has(id));
   decision.requiredRules = decision.requiredRules.filter((id) => enabled.has(id));
   decision.ruleDetails = applicable.filter((rule) => decision.requiredRules.includes(rule.id)).map((rule) => ({ id: rule.id, name: rule.title, source: `node_modules/${pkg.name}/standards/rules.json` }));

package/bin/task-observability.cjs

@@ -4,6 +4,7 @@
 const fs = require("node:fs");
 const path = require("node:path");
 const crypto = require("node:crypto");
+const projectScope = require("./project-scope.cjs");
 
 const RECORD_VERSION = 1;
 const STORAGE = {
@@ -418,7 +419,7 @@ function statusForRecords(records, options) {
 function validationContext(plan, tools, options) {
   const pending = pendingChecks(plan, tools);
   const outdatedChecker = Boolean(options.packageVersion) && [...tools, ...plan ? [plan] : []].some((record) => record.packageVersion !== options.packageVersion);
-  const planStale = Boolean(plan) && !snapshotsFresh([plan.ruleSnapshot, plan.configSnapshot], options);
+  const planStale = Boolean(plan) && !planInputsFresh(plan, options);
   const stale = outdatedChecker || planStale || tools.some((record) => isFresh(record, options) === false);
   const verifiers = tools.filter((record) => record.checks.length || record.validationStatus !== "unverified");
   const scopeGaps = uncoveredScope(plan, verifiers, options);
@@ -427,6 +428,13 @@ function validationContext(plan, tools, options) {
   return { validationStatus: summarizeValidation(verifiers, pending, stale, unresolvedDecision || scopeGaps.length > 0 || executionOrderUnverified), pendingChecks: pending, stale, outdatedChecker, planStale, scopeGaps, unresolvedDecision, executionOrderUnverified };
 }
 
+function planInputsFresh(plan, options) {
+  if (!snapshotsFresh([plan.ruleSnapshot, plan.configSnapshot], options)) return false;
+  if (!plan.decision.scope?.fingerprint) return true;
+  const current = projectScope.resolveScope({ projectRoot: options.projectRoot, packageName: options.packageName });
+  return current.scope.fingerprint === plan.decision.scope.fingerprint;
+}
+
 function uncoveredScope(plan, tools, options) {
   if (!plan) return [];
   const root = fs.realpathSync(path.resolve(options.projectRoot || process.cwd()));
@@ -477,7 +485,7 @@ function executionOrder(record) {
 function readStatus(options) {
   const records = allRecords(options);
   const runId = options.runId || records.at(-1)?.runId;
-  return statusForRecords(records.filter((record) => record.runId === runId), options);
+  return { ...statusForRecords(records.filter((record) => record.runId === runId), options), currentScope: projectScope.resolveScope({ projectRoot: options.projectRoot, packageName: options.packageName }).scope };
 }
 
 function listGaps(options) {
@@ -501,6 +509,7 @@ function inspectHostFile(root, relative, maximum) {
 
 function doctorHost(options) {
   const root = fs.realpathSync(path.resolve(options.projectRoot || process.cwd()));
+  const { scope } = projectScope.resolveScope({ projectRoot: root, packageName: options.packageName });
   const maximum = options.maxInstructionBytes || 32768;
   const entries = strings(options.entryFiles).map((relative) => inspectHostFile(root, relative, maximum));
   const skills = strings(options.skillPaths).map((relative) => inspectHostFile(root, relative, Infinity));
@@ -508,8 +517,8 @@ function doctorHost(options) {
   const warnings = entries.filter((entry) => entry.oversized).map((entry) => `${entry.path} 超过 ${maximum} 字节参考预算；请核对宿主实际配置与内容加载范围`);
   const runtime = inspectRuntime(root, options);
   warnings.push(...runtime.warnings);
-  const ready = hostReady(gateway, skills, entries, runtime);
-  return { recordVersion: RECORD_VERSION, packageName: options.packageName, packageVersion: options.packageVersion, host: options.host || "unspecified", projectRoot: root, entries, skills, gateway, runtime, entryReadiness: ready ? "ready" : "incomplete", hostDiscovery: "unverified", mcpConnection: "unverified", contentLoaded: "unverified", warnings, instructionBudgetSource: "reference-default-not-observed-host-config" };
+  const ready = scope.status === "applicable" && hostReady(gateway, skills, entries, runtime);
+  return { recordVersion: RECORD_VERSION, packageName: options.packageName, packageVersion: options.packageVersion, host: options.host || "unspecified", projectRoot: root, scope, entries, skills, gateway, runtime, entryReadiness: ready ? "ready" : "incomplete", hostDiscovery: "unverified", mcpConnection: "unverified", contentLoaded: "unverified", warnings, instructionBudgetSource: "reference-default-not-observed-host-config" };
 }
 
 function hostReady(gateway, skills, entries, runtime) {
@@ -551,6 +560,7 @@ function noticeRules(item) {
 }
 function noticeScope(record, options, item) {
   return { targets: strings(options.originalTargets || record.targets || options.targets),
+    ...(item.scope ? { scope: item.scope } : {}),
     executionStatus: record.executionStatus || "not-executed", validationStatus: record.validationStatus || "unverified",
     unverified: strings(item.unverified || ["host-discovery", "model-read-canonical-files", "planned-actions-not-executed"]) };
 }

package/bin/task-observability.schema.json

@@ -3,44 +3,232 @@
   "$id": "urn:wl-skills:task-observability:1",
   "title": "WL independent package task and execution evidence v1",
   "type": "object",
-  "required": ["recordVersion", "kind", "packageName", "packageVersion", "runId", "recordedAt", "eventId", "targets", "inputSnapshot", "executionStatus", "validationStatus"],
+  "required": [
+    "recordVersion",
+    "kind",
+    "packageName",
+    "packageVersion",
+    "runId",
+    "recordedAt",
+    "eventId",
+    "targets",
+    "inputSnapshot",
+    "executionStatus",
+    "validationStatus"
+  ],
   "properties": {
-    "recordVersion": { "const": 1 },
-    "kind": { "enum": ["task-decision", "tool-started", "tool-finished"] },
-    "packageName": { "type": "string", "pattern": "^@agile-team/wl-skills-(kit|ui|bd|design|test)$" },
-    "packageVersion": { "type": "string", "minLength": 1 },
-    "runId": { "type": "string", "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.-]{0,127}$" },
-    "eventId": { "type": "string", "minLength": 1 },
-    "recordedAt": { "type": "string", "pattern": "^\\d{4}-\\d{2}-\\d{2}T" },
-    "targets": { "type": "array", "items": { "type": "string" }, "uniqueItems": true },
-    "task": { "type": "string" },
-    "tool": { "type": "string" },
-    "executionStatus": { "enum": ["not-executed", "started", "completed", "failed"] },
-    "validationStatus": { "enum": ["passed", "failed", "partial", "unverified", "not-applicable"] },
-    "exitCode": { "type": "integer" },
-    "durationMs": { "type": "number", "minimum": 0 },
-    "inputSnapshot": { "$ref": "#/definitions/snapshot" },
-    "inputBefore": { "$ref": "#/definitions/snapshot" },
-    "ruleSnapshot": { "$ref": "#/definitions/snapshot" },
-    "configSnapshot": { "$ref": "#/definitions/snapshot" },
-    "checkedSnapshot": { "$ref": "#/definitions/snapshot" },
-    "executionId": { "type": "string", "minLength": 1 },
-    "executionStartedAt": { "type": "string", "pattern": "^\\d{4}-\\d{2}-\\d{2}T" },
-    "decision": { "$ref": "#/definitions/decision" },
-    "checks": { "type": "array", "items": { "$ref": "#/definitions/check" } },
-    "checkedFiles": { "type": "array", "items": { "$ref": "#/definitions/file" } },
-    "checkedScopeSource": { "enum": ["executor", "unreported"] },
-    "summary": { "type": "object" },
-    "artifacts": { "type": "array", "items": { "$ref": "#/definitions/file" } },
-    "changedDuringCheck": { "type": "boolean" },
-    "errorCode": { "type": "string" },
-    "recordPath": { "type": ["string", "null"] },
-    "notice": { "$ref": "#/definitions/notice" }
+    "recordVersion": {
+      "const": 1
+    },
+    "kind": {
+      "enum": [
+        "task-decision",
+        "tool-started",
+        "tool-finished"
+      ]
+    },
+    "packageName": {
+      "type": "string",
+      "pattern": "^@agile-team/wl-skills-(kit|ui|bd|design|test)$"
+    },
+    "packageVersion": {
+      "type": "string",
+      "minLength": 1
+    },
+    "runId": {
+      "type": "string",
+      "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.-]{0,127}$"
+    },
+    "eventId": {
+      "type": "string",
+      "minLength": 1
+    },
+    "recordedAt": {
+      "type": "string",
+      "pattern": "^\\d{4}-\\d{2}-\\d{2}T"
+    },
+    "targets": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      },
+      "uniqueItems": true
+    },
+    "task": {
+      "type": "string"
+    },
+    "tool": {
+      "type": "string"
+    },
+    "executionStatus": {
+      "enum": [
+        "not-executed",
+        "started",
+        "completed",
+        "failed"
+      ]
+    },
+    "validationStatus": {
+      "enum": [
+        "passed",
+        "failed",
+        "partial",
+        "unverified",
+        "not-applicable"
+      ]
+    },
+    "exitCode": {
+      "type": "integer"
+    },
+    "durationMs": {
+      "type": "number",
+      "minimum": 0
+    },
+    "inputSnapshot": {
+      "$ref": "#/definitions/snapshot"
+    },
+    "inputBefore": {
+      "$ref": "#/definitions/snapshot"
+    },
+    "ruleSnapshot": {
+      "$ref": "#/definitions/snapshot"
+    },
+    "configSnapshot": {
+      "$ref": "#/definitions/snapshot"
+    },
+    "checkedSnapshot": {
+      "$ref": "#/definitions/snapshot"
+    },
+    "executionId": {
+      "type": "string",
+      "minLength": 1
+    },
+    "executionStartedAt": {
+      "type": "string",
+      "pattern": "^\\d{4}-\\d{2}-\\d{2}T"
+    },
+    "decision": {
+      "$ref": "#/definitions/decision"
+    },
+    "checks": {
+      "type": "array",
+      "items": {
+        "$ref": "#/definitions/check"
+      }
+    },
+    "checkedFiles": {
+      "type": "array",
+      "items": {
+        "$ref": "#/definitions/file"
+      }
+    },
+    "checkedScopeSource": {
+      "enum": [
+        "executor",
+        "unreported"
+      ]
+    },
+    "summary": {
+      "type": "object"
+    },
+    "artifacts": {
+      "type": "array",
+      "items": {
+        "$ref": "#/definitions/file"
+      }
+    },
+    "changedDuringCheck": {
+      "type": "boolean"
+    },
+    "errorCode": {
+      "type": "string"
+    },
+    "recordPath": {
+      "type": [
+        "string",
+        "null"
+      ]
+    },
+    "notice": {
+      "$ref": "#/definitions/notice"
+    }
   },
   "allOf": [
-    { "if": { "properties": { "kind": { "const": "task-decision" } } }, "then": { "required": ["task", "decision"], "properties": { "executionStatus": { "const": "not-executed" }, "validationStatus": { "const": "unverified" } } } },
-    { "if": { "properties": { "kind": { "const": "tool-started" } } }, "then": { "required": ["tool"], "properties": { "executionStatus": { "const": "started" }, "validationStatus": { "const": "unverified" } } } },
-    { "if": { "properties": { "kind": { "const": "tool-finished" } } }, "then": { "required": ["tool", "executionId", "executionStartedAt", "exitCode", "durationMs", "checks", "artifacts", "inputBefore", "changedDuringCheck"], "properties": { "executionStatus": { "enum": ["completed", "failed"] } } } }
+    {
+      "if": {
+        "properties": {
+          "kind": {
+            "const": "task-decision"
+          }
+        }
+      },
+      "then": {
+        "required": [
+          "task",
+          "decision"
+        ],
+        "properties": {
+          "executionStatus": {
+            "const": "not-executed"
+          },
+          "validationStatus": {
+            "const": "unverified"
+          }
+        }
+      }
+    },
+    {
+      "if": {
+        "properties": {
+          "kind": {
+            "const": "tool-started"
+          }
+        }
+      },
+      "then": {
+        "required": [
+          "tool"
+        ],
+        "properties": {
+          "executionStatus": {
+            "const": "started"
+          },
+          "validationStatus": {
+            "const": "unverified"
+          }
+        }
+      }
+    },
+    {
+      "if": {
+        "properties": {
+          "kind": {
+            "const": "tool-finished"
+          }
+        }
+      },
+      "then": {
+        "required": [
+          "tool",
+          "executionId",
+          "executionStartedAt",
+          "exitCode",
+          "durationMs",
+          "checks",
+          "artifacts",
+          "inputBefore",
+          "changedDuringCheck"
+        ],
+        "properties": {
+          "executionStatus": {
+            "enum": [
+              "completed",
+              "failed"
+            ]
+          }
+        }
+      }
+    }
   ],
   "definitions": {
     "notice": {
@@ -134,38 +322,205 @@
         },
         "displayEvidence": {
           "const": "unverified"
+        },
+        "scope": {
+          "$ref": "#/definitions/scope"
         }
       }
     },
     "file": {
-      "type": "object", "required": ["path", "sha256", "bytes"],
-      "properties": { "path": { "type": "string" }, "sha256": { "type": "string", "pattern": "^[a-f0-9]{64}$" }, "bytes": { "type": "integer", "minimum": 0 } }
+      "type": "object",
+      "required": [
+        "path",
+        "sha256",
+        "bytes"
+      ],
+      "properties": {
+        "path": {
+          "type": "string"
+        },
+        "sha256": {
+          "type": "string",
+          "pattern": "^[a-f0-9]{64}$"
+        },
+        "bytes": {
+          "type": "integer",
+          "minimum": 0
+        }
+      }
     },
     "snapshot": {
-      "type": "object", "required": ["targets", "files", "omitted", "complete", "sha256"],
+      "type": "object",
+      "required": [
+        "targets",
+        "files",
+        "omitted",
+        "complete",
+        "sha256"
+      ],
       "properties": {
-        "targets": { "type": "array", "items": { "type": "string" } },
-        "files": { "type": "array", "items": { "$ref": "#/definitions/file" } },
-        "omitted": { "type": "array", "items": { "type": "object", "required": ["path", "reason"], "properties": { "path": { "type": "string" }, "reason": { "type": "string" } } } },
-        "complete": { "type": "boolean" }, "sha256": { "type": "string", "pattern": "^[a-f0-9]{64}$" },
-        "resolution": { "const": "project-internal-realpath" }
+        "targets": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        },
+        "files": {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/file"
+          }
+        },
+        "omitted": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "required": [
+              "path",
+              "reason"
+            ],
+            "properties": {
+              "path": {
+                "type": "string"
+              },
+              "reason": {
+                "type": "string"
+              }
+            }
+          }
+        },
+        "complete": {
+          "type": "boolean"
+        },
+        "sha256": {
+          "type": "string",
+          "pattern": "^[a-f0-9]{64}$"
+        },
+        "resolution": {
+          "const": "project-internal-realpath"
+        }
       }
     },
     "decision": {
-      "type": "object", "required": ["status", "selectedSkills", "requiredChecks", "gaps"],
+      "type": "object",
+      "required": [
+        "status",
+        "selectedSkills",
+        "requiredChecks",
+        "gaps"
+      ],
       "properties": {
-        "status": { "enum": ["matched", "baseline", "ambiguous", "gap", "not-applicable", "needs-context"] },
-        "selectedSkills": { "type": "array", "items": { "type": "string" } },
-        "requiredChecks": { "type": "array", "items": { "type": "string" } },
-        "requiredFiles": { "type": "array", "items": { "type": "string" } },
-        "gaps": { "type": "array", "items": { "type": "object" } }
+        "status": {
+          "enum": [
+            "matched",
+            "baseline",
+            "ambiguous",
+            "gap",
+            "not-applicable",
+            "needs-context"
+          ]
+        },
+        "selectedSkills": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        },
+        "requiredChecks": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        },
+        "requiredFiles": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        },
+        "gaps": {
+          "type": "array",
+          "items": {
+            "type": "object"
+          }
+        },
+        "scope": {
+          "$ref": "#/definitions/scope"
+        }
       }
     },
     "check": {
-      "type": "object", "required": ["id", "status", "reason", "evidencePaths"],
+      "type": "object",
+      "required": [
+        "id",
+        "status",
+        "reason",
+        "evidencePaths"
+      ],
       "properties": {
-        "id": { "type": "string" }, "status": { "enum": ["passed", "failed", "skipped", "not-applicable", "unverified", "not-executed"] },
-        "reason": { "type": "string" }, "evidencePaths": { "type": "array", "items": { "type": "string" } }
+        "id": {
+          "type": "string"
+        },
+        "status": {
+          "enum": [
+            "passed",
+            "failed",
+            "skipped",
+            "not-applicable",
+            "unverified",
+            "not-executed"
+          ]
+        },
+        "reason": {
+          "type": "string"
+        },
+        "evidencePaths": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        }
+      }
+    },
+    "scope": {
+      "type": "object",
+      "required": [
+        "schemaVersion",
+        "status",
+        "reason",
+        "adopted",
+        "inherited"
+      ],
+      "properties": {
+        "schemaVersion": {
+          "const": 1
+        },
+        "status": {
+          "enum": [
+            "applicable",
+            "not-applicable",
+            "needs-context"
+          ]
+        },
+        "adopted": {
+          "type": "boolean"
+        },
+        "inherited": {
+          "const": false
+        },
+        "reason": {
+          "type": "string"
+        },
+        "projectType": {
+          "type": "string"
+        },
+        "projectRoot": {
+          "type": "string"
+        },
+        "fingerprint": {
+          "type": "string",
+          "pattern": "^[a-f0-9]{64}$"
+        }
       }
     }
   }

package/bin/wl-ui.js

@@ -564,7 +564,7 @@ function transformForEditor(content, editor) {
   if (!headerTemplate) return body;
 
   const header = headerTemplate
-    .replace("{SKILL_DESCRIPTION}", description.split("\n")[0])
+    .replace("{SKILL_DESCRIPTION}", `仅用于自身已接入UI包的PC Vue管理端，排除移动端和未接入项目。${description.split("\n")[0]}`)
     .replace("{APPLY_GLOB}", applyTo)
     .replace(
       "{SKILL_NAME}",
@@ -574,7 +574,7 @@ function transformForEditor(content, editor) {
         ?.slice(2) || "Skill",
     );
 
-  return header + "\nStart each task with local `wl-ui task \"<task>\" --target <path>`. Before editing visibly show the returned notice: actual package/version, decision, Skill or baseline, rule IDs/names, targets, runId and unexecuted checks. Report local command failures/version drift. Read only the selected Skill. Finish actual tools with the same `--run-id` and report `wl-ui status`; model declarations do not prove verification.\n\n" + body;
+  return header + "\nOnly apply these rules inside a PC Vue admin project with its own UI manifest/direct dependency or explicit scope opt-in. Parent installations and Vue files do not adopt a project; mobile and unadopted projects receive no UI rules.\n\nStart each task with local `wl-ui task \"<task>\" --target <path>`. Before editing visibly show the returned notice: actual package/version, decision, Skill or baseline, rule IDs/names, targets, runId and unexecuted checks. Report local command failures/version drift. Read only the selected Skill. Finish actual tools with the same `--run-id` and report `wl-ui status`; model declarations do not prove verification.\n\n" + body;
 }
 
 function selectedSkills(mode, profile) {

package/docs/project-scope.md

@@ -0,0 +1,44 @@
+# 项目范围与精准触发
+
+本包只应用于目标项目自身已接入、平台适用且任务属于本包职责的场景。父目录、全局安装、兄弟包、Vue文件和触发词都不能证明目标项目已接入。项目初始化与任务执行是不同阶段；已安装文件也不能证明宿主加载或检查通过。
+
+## 判定顺序
+
+1. 从目标文件确定最近项目边界：package.json、独立Git仓库、安装清单或范围配置。父清单不能越过未接入子项目。同一Java工程的Maven模块共享工程接入，独立嵌套仓库仍单独判断。
+2. 排除移动端：UniApp/Taro/React Native/Expo/Ionic/Capacitor依赖、pages.json+manifest.json，或显式mobile配置。不靠“页面”“Vue”或仓库名字猜平台。
+3. 检查本包自身接入：有效的本包安装清单、package.json直接依赖（含dev/optional），或范围文件显式启用。node_modules里的传递/提升依赖不作为接入证据。
+4. 才进行既有技能、基础约束、歧义和缺口判断。每包独立执行此步骤，不要求兄弟包或harness。Kit/UI仍只支持PC Vue管理端；BD保留后端职责，design/test保留各自设计/测试职责。
+
+| 情况 | 回执与行为 |
+|---|---|
+| PC开源项目未接入本包 | not-applicable，无规则/技能、无任务写入，不自动建议安装 |
+| 父工作区已安装，子项目未接入 | not-applicable，不继承父安装 |
+| 已接入但自己的canonical资产缺失 | gap，说明本包资产缺口 |
+| 已接入的移动端 | not-applicable，移动事实优先于pc配置 |
+| 多个目标跨独立项目 | needs-context，按项目拆分，复用用户任务runId，零写入 |
+| 范围元数据无效、projectType=unknown | needs-context，零写入，不猜测 |
+| 工具与项目版本不一致 | doctor-host显示mismatch，先正常升级对齐 |
+
+## 可选显式配置
+
+在实际项目根创建用户维护的 `.wl-skills-scope.json`；安装器不覆盖或登记该用户文件。它不需要共享包运行依赖。已有有效安装/直接依赖无需额外配置；平台不能可靠推断时（尤其纯Vue移动H5），应明确声明。
+
+```json
+{
+  "schemaVersion": 1,
+  "projectType": "pc",
+  "packages": { "ui": true }
+}
+```
+
+projectType可为pc/backend/documents/testing/mobile/workspace/unknown。packages中的布尔false禁用对应包，true表示明确接入；未列出的包只根据各自清单/直接依赖判断，不自动启用。projectType本身不是接入证明。mobile排除这套项目约束；workspace只作聚合入口，指定已接入子项目才继续。父配置不跨项目继承。严格Schema随本包 `bin/project-scope.schema.json` 分发，protocol describe同时公布此契约。
+
+工作区根可声明 `{"schemaVersion":1,"projectType":"workspace"}`；未接入的开源项目无需新增任何文件。移动H5可声明 `{"schemaVersion":1,"projectType":"mobile"}`，其现有组件、构建、目录及测试约定仍由自身项目维护。
+
+## 使用建议与证据
+
+把依赖与init/update放在实际项目根，进入最近项目AGENTS和原生gateway；编辑前显示工具notice里的实际包版本、scope证据、判定、规则来源、目标、runId和待检查项。使用同runId执行真实校验并读status；范围/接入配置变化使旧计划过期，currentScope反映当前范围。
+
+包提供确定性判定和真实工具记录，宿主负责发现入口、调用工具与聊天展示。只npm安装可执行器而未初始化资产，会出现明确gap；只分发资产但缺可执行器，也不能宣称工具执行。Markdown不能强制所有宿主/模型调用，不保证任意自然语言100%匹配。不要为“没触发”自动安装包或扩大PC规则范围；相关能力缺口应先记录复现、审阅后完善。
+
+本轮范围护栏保护task/route/explain及其CLI/MCP/公开protocol入口。用户明确调用的独立业务CLI仍遵循原授权与检查契约；护栏不代表任意外部命令的强制沙箱。

package/package.json

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