@lark-apaas/coding-miaoda-sandbox-skills 0.1.0-dev.b2f659e → 0.1.0-dev.c8cc2b5

package/miaoda/lark-design-prototype/scripts/icon-query.mjs

@@ -0,0 +1,272 @@
+#!/usr/bin/env node
+import fs from 'node:fs/promises';
+import { createHash } from 'node:crypto';
+import path from 'node:path';
+
+const SVG_BASE = 'https://cdn-tos-cn.bytedance.net/obj/archi/ee/es-design-base/svgs';
+const REMOTE_CATALOG =
+  'https://lf3-static.bytednsdoc.com/obj/eden-cn/pshi/lark-design-prototype/1.0.4/db71a6cd-33f97519-0d446cd5/icons.catalog.json';
+const REMOTE_CATALOG_SHA256 = 'db71a6cd6ac90c77629e8ce0fc0905ca1488a6601800ff7533385490b10eac9d';
+
+function usage() {
+  return `Usage:
+  node icon-query.mjs [--catalog <remote|catalog.json|url>] --query "<keywords>" [--family outlined] [--style v2-outlined|source-outlined|source-filled|source-colorful] [--shape normal|round] [--prefer-v2] [--require-v2] [--limit 5]
+
+Returns a compact JSON array with name, hash, family, version, shape, score, description, and final svgUrl.
+Never print the raw icon catalog during page generation.`;
+}
+
+function argValue(name, fallback = '') {
+  const index = process.argv.indexOf(name);
+  return index === -1 ? fallback : process.argv[index + 1] || fallback;
+}
+
+function argFlag(name) {
+  return process.argv.includes(name);
+}
+
+function tokenize(text) {
+  const rawTokens = String(text || '')
+    .toLowerCase()
+    .split(/[\s,，、:：;；/|()（）\[\]{}'"`<>.!?？。_-]+/)
+    .map((item) => item.trim())
+    .filter(Boolean);
+  const aliases = {
+    搜索: ['search'],
+    查找: ['search'],
+    通知: ['notification', 'bell'],
+    提醒: ['reminder', 'bell'],
+    主页: ['home'],
+    首页: ['home'],
+    模板: ['template'],
+    文档: ['doc', 'document', 'file'],
+    document: ['doc'],
+    文件: ['file'],
+    文件夹: ['folder'],
+    表格: ['sheet', 'table', 'bitable'],
+    spreadsheet: ['sheet'],
+    table: ['sheet'],
+    图表: ['chart'],
+    看板: ['dashboard', 'chart'],
+    帮助: ['help', 'faq'],
+    指南: ['guide', 'info'],
+    飞书: ['feishu', 'lark', 'logo', 'logotype'],
+    品牌: ['brand', 'logo', 'logotype'],
+    标识: ['logo', 'logotype'],
+    logo: ['brand', 'logotype'],
+  };
+  const expanded = new Set(rawTokens);
+  for (const token of rawTokens) {
+    for (const alias of aliases[token] || []) {
+      expanded.add(alias);
+    }
+  }
+  return [...expanded];
+}
+
+async function readJsonFile(filePath) {
+  const text = await fs.readFile(filePath, 'utf8');
+  return JSON.parse(text);
+}
+
+async function readCatalog(source) {
+  const resolved = !source || source === 'remote' ? REMOTE_CATALOG : source;
+  if (/^https?:\/\//.test(resolved)) {
+    const response = await fetch(resolved);
+    if (!response.ok) {
+      throw new Error(`Catalog request failed with HTTP ${response.status}`);
+    }
+    const text = await response.text();
+    if (resolved === REMOTE_CATALOG) {
+      const actualHash = createHash('sha256').update(text).digest('hex');
+      if (actualHash !== REMOTE_CATALOG_SHA256) {
+        throw new Error(
+          `Catalog integrity check failed: expected ${REMOTE_CATALOG_SHA256}, got ${actualHash}`,
+        );
+      }
+    }
+    return { catalog: JSON.parse(text), catalogSource: resolved };
+  }
+  const filePath = path.resolve(resolved);
+  return { catalog: await readJsonFile(filePath), catalogSource: filePath };
+}
+
+function detectVersion(name) {
+  return /(?:^|[-_])v2(?:[-_]|$)/i.test(name) ? 'v2' : 'non-v2';
+}
+
+function detectShape(icon) {
+  const name = icon.name.toLowerCase();
+  if (name.includes('file-round-') || name.includes('wiki-round-')) return 'round';
+  if (icon.family === 'colorful' && /(?:icon_|wiki-)?file[-_]/.test(name)) return 'normal';
+  return 'none';
+}
+
+function detectStyleType(icon) {
+  const version = detectVersion(icon.name);
+  const shape = detectShape(icon);
+  if (icon.family === 'outlined') {
+    return version === 'v2' ? 'v2-outlined' : 'non-v2-outlined';
+  }
+  if (icon.family === 'filled') {
+    return 'source-filled';
+  }
+  if (icon.family === 'colorful' && /(?:feishu|lark).*logo|logotype|logo/i.test(icon.name)) {
+    return 'brand-colorful';
+  }
+  if (icon.family === 'colorful' && version === 'v2' && shape === 'round') {
+    return 'file-v2-colorful-round';
+  }
+  if (icon.family === 'colorful' && version === 'v2' && shape === 'normal') {
+    return 'file-v2-colorful-normal';
+  }
+  return icon.family;
+}
+
+function normalizeOptions() {
+  const style = argValue('--style');
+  const options = {
+    family: argValue('--family', 'outlined'),
+    style,
+    shape: argValue('--shape'),
+    preferV2: argFlag('--prefer-v2'),
+    requireV2: argFlag('--require-v2'),
+    requireNonV2: argFlag('--require-non-v2'),
+    include: argValue('--name-include'),
+    exclude: argValue('--name-exclude'),
+  };
+
+  if (style === 'v2-outlined') {
+    options.family = 'outlined';
+    options.requireV2 = true;
+  } else if (style === 'non-v2-outlined') {
+    options.family = 'outlined';
+    options.requireNonV2 = true;
+  } else if (style === 'file-v2-colorful-normal') {
+    options.family = 'colorful';
+    options.requireV2 = true;
+    options.shape = 'normal';
+    options.include ||= 'file';
+  } else if (style === 'file-v2-colorful-round') {
+    options.family = 'colorful';
+    options.requireV2 = true;
+    options.shape = 'round';
+    options.include ||= 'file-round';
+  } else if (style === 'source-outlined') {
+    options.family = 'outlined';
+    options.preferV2 = true;
+  } else if (style === 'source-filled') {
+    options.family = 'filled';
+  } else if (style === 'brand-colorful' || style === 'source-colorful') {
+    options.family = 'colorful';
+    if (style === 'source-colorful') {
+      options.preferV2 = true;
+    }
+  }
+  return options;
+}
+
+function flattenCatalog(catalog, options) {
+  const rows = [];
+  for (const category of catalog) {
+    for (const [family, icons] of Object.entries(category.icons || {})) {
+      if (options.family && family !== options.family) {
+        continue;
+      }
+      for (const icon of icons || []) {
+        const row = {
+          category: category.id || '',
+          family,
+          name: icon.name,
+          hash: icon.hash,
+          darkHash: icon.darkHash,
+          description: icon.description || '',
+        };
+        row.version = detectVersion(row.name);
+        row.shape = detectShape(row);
+        row.styleType = detectStyleType(row);
+        rows.push(row);
+      }
+    }
+  }
+  return rows;
+}
+
+function passesFilters(icon, options) {
+  const name = icon.name.toLowerCase();
+  if (options.requireV2 && icon.version !== 'v2') return false;
+  if (options.requireNonV2 && icon.version !== 'non-v2') return false;
+  if (options.shape && icon.shape !== options.shape) return false;
+  if (options.include && !name.includes(options.include.toLowerCase())) return false;
+  if (options.exclude && name.includes(options.exclude.toLowerCase())) return false;
+  const sourceStyles = new Set(['source-outlined', 'source-filled', 'source-colorful']);
+  if (options.style && !sourceStyles.has(options.style) && icon.styleType !== options.style)
+    return false;
+  return true;
+}
+
+function scoreIcon(icon, queryTokens, options) {
+  const name = icon.name.toLowerCase();
+  const description = icon.description.toLowerCase();
+  let score = 0;
+  for (const token of queryTokens) {
+    if (name.includes(token)) score += 5;
+    if (description.includes(token)) score += 3;
+    if (name === `icon_${token}_outlined`) score += 8;
+    if (name === `icon_${token}-v2_outlined`) score += 8;
+    if (name === `icon_${token}_filled`) score += 8;
+    if (name === `icon_file-${token}-v2_colorful`) score += 8;
+  }
+  if (score === 0) return 0;
+  if (icon.family === 'outlined') score += 1;
+  if ((options.preferV2 || options.style?.includes('v2')) && icon.version === 'v2') score += 4;
+  if (
+    options.style === 'brand-colorful' &&
+    /feishu|lark|logotype|logo/i.test(`${name} ${description}`)
+  )
+    score += 10;
+
+  const objectTokens = ['doc', 'document', 'file', 'card', 'sheet', 'bitable', 'ai'];
+  const queryHasObject = objectTokens.some((token) => queryTokens.includes(token));
+  if (
+    !queryHasObject &&
+    objectTokens.some((token) => name.includes(`_${token}`) || name.includes(`-${token}`))
+  ) {
+    score -= 3;
+  }
+  return score;
+}
+
+const catalogSource = argValue('--catalog', 'remote');
+const query = argValue('--query');
+const limit = Math.max(1, Number.parseInt(argValue('--limit', '5'), 10) || 5);
+
+if (!query) {
+  console.error(usage());
+  process.exit(2);
+}
+
+const options = normalizeOptions();
+const queryTokens = tokenize(query);
+const { catalog, catalogSource: usedCatalogSource } = await readCatalog(catalogSource);
+const matches = flattenCatalog(catalog, options)
+  .filter((icon) => passesFilters(icon, options))
+  .map((icon) => ({ ...icon, score: scoreIcon(icon, queryTokens, options) }))
+  .filter((icon) => icon.score > 0)
+  .sort((a, b) => b.score - a.score || a.name.localeCompare(b.name))
+  .slice(0, limit)
+  .map((icon) => ({
+    name: icon.name,
+    hash: icon.hash,
+    darkHash: icon.darkHash || undefined,
+    family: icon.family,
+    version: icon.version,
+    shape: icon.shape,
+    styleType: icon.styleType,
+    score: icon.score,
+    description: icon.description.slice(0, 180),
+    svgUrl: `${SVG_BASE}/${icon.name}.${icon.hash}.svg`,
+    catalogSource: usedCatalogSource,
+  }));
+
+console.log(JSON.stringify(matches, null, 2));

package/miaoda/lark-design-prototype/scripts/token-query.mjs

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+import { createHash } from 'node:crypto';
+
+const SOURCES = {
+  semantic: {
+    url: 'https://lf3-static.bytednsdoc.com/obj/eden-cn/pshi/lark-design-prototype/1.0.4/db71a6cd-33f97519-0d446cd5/semantic.json',
+    sha256: '33f975193bcd0b5b12df9003e6f8586bf4662336e0bd5cf73ea1f362cfa4eb50',
+  },
+  keys: {
+    url: 'https://lf3-static.bytednsdoc.com/obj/eden-cn/pshi/lark-design-prototype/1.0.4/db71a6cd-33f97519-0d446cd5/keys.json',
+    sha256: '0d446cd57b0beaaaa9ba485009b31a73be77d5f87a8481ec032c54f33b3bb471',
+  },
+};
+
+function usage() {
+  return `Usage:
+  node token-query.mjs --query "<token name or intent>" [--source semantic|keys] [--limit 5]
+
+Fetches the versioned public token resource, verifies SHA-256, and returns compact matches.`;
+}
+
+function argValue(name, fallback = '') {
+  const index = process.argv.indexOf(name);
+  return index === -1 ? fallback : process.argv[index + 1] || fallback;
+}
+
+function tokenize(value) {
+  return String(value || '')
+    .toLowerCase()
+    .split(/[\s,，、:：;；/|()（）\[\]{}'"`<>.!?？。_-]+/)
+    .map((item) => item.trim())
+    .filter(Boolean);
+}
+
+function scoreEntry([key, value], query, queryTokens) {
+  const normalizedKey = key.toLowerCase();
+  const searchText = `${key} ${value?.$description || ''} ${value?.$extensions?.id || ''} ${
+    value?.$extensions?.name || ''
+  }`.toLowerCase();
+  let score = normalizedKey === query ? 100 : normalizedKey.includes(query) ? 40 : 0;
+  for (const token of queryTokens) {
+    if (normalizedKey.includes(token)) score += 10;
+    if (searchText.includes(token)) score += 3;
+  }
+  return score;
+}
+
+const sourceName = argValue('--source', 'semantic');
+const source = SOURCES[sourceName];
+const query = argValue('--query').trim().toLowerCase();
+const limit = Math.max(1, Number.parseInt(argValue('--limit', '5'), 10) || 5);
+
+if (!source || !query) {
+  console.error(usage());
+  process.exit(2);
+}
+
+const response = await fetch(source.url);
+if (!response.ok) {
+  throw new Error(`Token request failed with HTTP ${response.status}`);
+}
+const text = await response.text();
+const actualHash = createHash('sha256').update(text).digest('hex');
+if (actualHash !== source.sha256) {
+  throw new Error(`Token integrity check failed: expected ${source.sha256}, got ${actualHash}`);
+}
+
+const queryTokens = tokenize(query);
+const matches = Object.entries(JSON.parse(text))
+  .map((entry) => ({ entry, score: scoreEntry(entry, query, queryTokens) }))
+  .filter(({ score }) => score > 0)
+  .sort((a, b) => b.score - a.score || a.entry[0].localeCompare(b.entry[0]))
+  .slice(0, limit)
+  .map(({ entry: [key, value] }) => ({ key, ...value, source: source.url }));
+
+console.log(JSON.stringify(matches, null, 2));

package/miaoda/lark-design-prototype/scripts/verify-static-html.mjs

@@ -0,0 +1,117 @@
+#!/usr/bin/env node
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+function usage() {
+  return `Usage:
+  node verify-static-html.mjs <file.html> [--sidebar]
+
+Runs token-light pre-browser checks for Lark-style static HTML deliverables.
+Use --sidebar only when the page contains a navigation sidebar. Shadow declarations are reported for contextual review.`;
+}
+
+const htmlPath = process.argv[2];
+if (!htmlPath) {
+  console.error(usage());
+  process.exit(2);
+}
+
+const absoluteHtmlPath = path.resolve(htmlPath);
+const html = await fs.readFile(absoluteHtmlPath, 'utf8');
+
+const hardFailures = [];
+const warnings = [];
+const passed = [];
+
+function pass(name, ok, failMessage, warn = false) {
+  if (ok) {
+    passed.push(name);
+  } else if (warn) {
+    warnings.push(failMessage);
+  } else {
+    hardFailures.push(failMessage);
+  }
+}
+
+pass(
+  'no gradients',
+  !/(linear-gradient|radial-gradient|conic-gradient)/i.test(html),
+  'Page UI contains gradients.',
+);
+const shadows = [...html.matchAll(/box-shadow\s*:\s*([^;}"'<>]+)/gi)]
+  .map((match) => match[1].trim())
+  .filter((value) => !/^none(?:\s*!important)?$/i.test(value));
+pass(
+  'no shadows requiring contextual review',
+  shadows.length === 0,
+  'Shadow declarations found; verify they belong to permitted floating layers, not ordinary cards.',
+  true,
+);
+if (process.argv.includes('--sidebar')) {
+  pass(
+    'fixed sidebar background',
+    html.includes('#f9f9f9'),
+    'Sidebar background #f9f9f9 is missing.',
+  );
+  pass(
+    'fixed selected sidebar state',
+    html.includes('#1f23290d'),
+    'Selected sidebar state #1f23290d is missing.',
+  );
+}
+pass('has table', /<table[\s>]/i.test(html), 'No table found.', true);
+pass('has search input', /type=["']search["']/i.test(html), 'No search input found.', true);
+pass(
+  'has local responsive CSS',
+  /@media\s*\(/i.test(html),
+  'No responsive media query found.',
+  true,
+);
+
+const imageRefs = [...html.matchAll(/<img\b[^>]*\bsrc=["']([^"']+)["']/gi)].map(
+  (match) => match[1],
+);
+const localImageRefs = imageRefs.filter(
+  (src) => !/^(https?:)?\/\//.test(src) && !src.startsWith('data:'),
+);
+const missingImages = [];
+for (const src of localImageRefs) {
+  try {
+    await fs.access(new URL(src, pathToFileURL(absoluteHtmlPath)));
+  } catch {
+    missingImages.push(src);
+  }
+}
+
+pass(
+  'all local images exist',
+  missingImages.length === 0,
+  `Missing local image assets: ${missingImages.join(', ')}`,
+);
+
+const tableHeaders = [...html.matchAll(/<th\b[^>]*>([\s\S]*?)<\/th>/gi)]
+  .map((match) => match[1].replace(/<[^>]+>/g, '').trim())
+  .filter(Boolean);
+
+console.log(
+  JSON.stringify(
+    {
+      file: absoluteHtmlPath,
+      passed,
+      warnings,
+      hardFailures,
+      stats: {
+        images: imageRefs.length,
+        localImages: localImageRefs.length,
+        tableHeaders,
+      },
+    },
+    null,
+    2,
+  ),
+);
+
+if (hardFailures.length > 0) {
+  process.exit(1);
+}

package/miaoda/testing-guide/SKILL.md

@@ -8,6 +8,59 @@ gate-tools:
     when:
       subagent_type: E2E
 ---
+{% if visualCheckEnabled %}
+# 检查与验证：工具选择指南
+
+静态页面检查和功能验收使用不同工具。向用户只说「页面检查」或「用浏览器操作验证」，不要解释内部工具或 agent 名称。
+
+## 决策规则
+
+```
+用户想确认应用是否正常
+  ├─ 明确要求验证后端接口 / API / 请求响应 → api_request
+  ├─ 只检查静态视觉结果（白屏、布局、样式、文案、图片）→ visual_check
+  └─ 交互 / 业务流程 / 数据 / 网络 → Task(subagent_type="E2E")
+```
+
+- **静态视觉检查**：调用 `visual_check`，一条路由一次调用；互不依赖的路由可同时发起。它只检查指定路由的最终静态画面，不用来点击、填写、提交或验证接口。
+- **功能验收**：交互 / 业务流程 / 数据 / 网络都派 `Task(subagent_type="E2E")`。E2E 一律按标准语义执行，调用时不要额外指定运行方式。
+- **接口验收**：只在用户明确要检查接口、API、请求或响应时调用 `api_request`；完成浏览器验收后不追加接口调用。
+- **E2E 不可用时（Legacy）**：Task 的 `subagent_type` 没有 E2E 选项时，交互、业务、数据和网络验收改用 `api_request`、读代码和读运行时日志；不要尝试派 E2E。静态视觉仍使用 `visual_check`。
+
+## 调用方式
+
+```js
+visual_check({
+  relative_path: "<路由相对路径>",
+})
+```
+
+`relative_path` 只填一个路由。一条路由检查完成后再根据结果决定是否修复；多个互不依赖的路由可以分别同时调用。
+
+```js
+Task({
+  subagent_type: "E2E",
+{% if e2eSemanticPlan %}
+  agent_options: { test_plan_file_path: ".spark/e2e-test/standard/<语义名>.json" },
+{% endif %}
+  description: "验收<功能名称>",
+  prompt: "执行<具体交互或业务闭环>，断言<可观察终态>。",
+})
+```
+
+{% if e2eSemanticPlan %}
+### 验收计划文件
+
+先读可能覆盖当前需求的 `.spark/e2e-test/standard/<语义名>.json`；有变化则更新同一文件，换功能或页面则新建。计划只包含交互、业务、数据和网络的可观察终态；`prompt` 只说明本轮执行范围和 Case 编号。
+{% endif %}
+
+## 验收要求
+
+- 视觉检查写清可观察结果，例如「首页标题完整可见、卡片两列排列、主图不是裂图」，不要只写「看起来正常」。
+- 功能验收必须走到终态：提交后记录出现、跳转后内容正确、删除后记录消失或 AI 输出出现；不要停在弹窗、按钮或表单字段出现。
+- 写操作和资源加载要核对网络结果；非 2xx、空结果、错误兜底或白屏都应报失败。
+- 不测试登录、认证、CAPTCHA，或会造成真实外部副作用的行为。
+{% else %}
 
 # 检查与验证：工具选择指南
 
@@ -29,32 +82,40 @@ gate-tools:
   ├─ Task 工具定义的 subagent_type 选项里没有 E2E（E2E 被关闭/不可用，非"本轮没派过"）→ api_request（接口级验收）+ 读代码/读日志兜底，不要尝试派 E2E
   ├─ 明确要求验证「后端接口」「API 返回值」「请求响应」 → api_request
   └─ 其他所有情况 → Task(subagent_type="E2E")（打开浏览器，以用户视角操作应用）
-                  ├─ 只看视觉（白屏/布局/样式/文案）→ agent_options.mode: "lite"
-                  └─ 涉及交互/业务流程/数据 → 不传或 agent_options.mode: "standard"
+                  ├─ 基础视觉验证（白屏/布局/样式/文案）→ agent_options.mode: "lite"（只截图看视觉）
+                  └─ 用户明确要求验证交互/业务流程/数据（点击/填写/提交/走一遍流程）→ agent_options.mode: "standard"
 ```
 
 - **E2E 不可用时改走 api_request（最高优先，先于下面所有规则判断）**：当 Task 工具定义的 subagent_type 选项里没有 E2E（用户关闭了浏览器验收 / 环境不支持；判断依据是工具定义中是否含 E2E 选项，不是"本轮有没有派过 E2E"）时，下面"模糊需求一律派遣 E2E"不再适用——改用 `api_request` 做接口级验收，配合读代码 / 读运行时日志确认核心链路，**不要尝试派 E2E、也不要空等**；此时验收范围收敛到接口与数据层可判定结果，视觉类目标顺延到非核心降级范围
 - **模糊需求一律派遣 E2E**（仅当 E2E 可用）：未明确提到「接口」「API」「后端」时必须派遣 E2E，不要主动选择 `api_request`
+- **基础视觉验证走 lite，standard 需用户明确要求功能测试**：用户没有主动要求跑具体功能（只说"看看有没有问题"这类模糊需求也算没主动要求）时，显式传 `agent_options.mode: "lite"`；只有用户明确要验证交互 / 业务流程 / 数据（点击、填写、提交、走一遍流程等）时才显式传 `agent_options.mode: "standard"`
 - **`api_request` 仅限显式请求**：仅当明确提到接口 / API / 后端 / 请求 / 响应、且意图是验证接口逻辑而非页面功能时才使用
 - **E2E 结束后禁止追加 `api_request`**：浏览器操作的结果即为最终结果，**严禁**再自动补充验证
 
+### 低投入产出验收的停止边界
+
+- 仅按“能否在 2 分钟、2 次观察内稳定看到结果”决定是否验收；短时且终态可观察的任务照常验收。
+- 完整体验依赖真实设备、语音/视频生成等长媒体处理、第三方实时通道或后台长异步终态且无法稳定观察时，标注未验收边界。
+- 有可观察部分时只选一种现有验证方式；达到时间或次数上限即停，标为部分验收/未验收，不新增验收专用工具，不跨轮等待不可控终态。
+
 ### E2E 的 mode 选择
 
-通过 `agent_options.mode` 指定，**可选参数**，不传或非 `lite` 一律按 `standard` 处理：
+通过 `agent_options.mode` 指定，**必填参数**，且只允许 `lite` 或 `standard`；缺失或非法时 E2E 会拒绝执行：
 
-| mode | 适用场景 | 行为 | 总超时 | 录屏 |
-|------|---------|------|-------|------|
-| `standard`（缺省） | 涉及业务流程、数据流、交互后状态变化 | 完整交互（点击/输入/滚动/提交）+ Network 验证 + 录制 | 5 分钟 | ✅ |
-| `lite` | 只看视觉渲染（CSS/布局/文案/图标）或快速冒烟 | 仅 `open` / `goto` / `wait` / `snapshot` / `screenshot`，**禁止** `click` / `fill` / `type` / `scroll` / `select` / `press` / `drag` / `hover` | 2 分钟 | ❌ |
+| mode | 适用场景 | 行为 | 录屏 |
+|------|---------|------|------|
+| `lite` | 基础视觉验证（白屏/布局/样式/文案）或快速冒烟 | 仅 `open` / `goto` / `wait` / `snapshot` / `screenshot`，**禁止** `click` / `fill` / `type` / `scroll` / `select` / `press` / `drag` / `hover` | ❌ |
+| `standard` | **仅当用户明确要求**验证业务流程、数据流、交互后状态变化 | 完整交互（点击/输入/滚动/提交）+ Network 验证 + 录制 | ✅ |
 
-**仅改 CSS / 文案 / 图标 / 布局**（无事件处理、无状态、无数据获取）应直接选 `lite`——更快且 token 消耗显著低，不要默认走 standard 浪费配额；但 `lite` 不能触发 popup / toast / 提交后状态切换等需要操作的现象。testRequirements 里出现"点击"、"填写"、"提交"等动词，**禁止** `lite`，必须 `standard`。
+**每次派发都必须显式传 mode**。基础视觉验证传 `lite`；`lite` 不能触发 popup / toast / 提交后状态切换等需要操作的现象。**用户明确要求跑功能**（testRequirements 里出现"点击"、"填写"、"提交"等动词，或用户直接要求验证某功能）时，传 `standard`。
 
 ## 工具选择速查表
 
 | 用户表达 | 选择 | 原因 |
 | --- | --- | --- |
-| "检查一下页面" / "看看有没有问题" / "走一遍流程" / "哪里出问题了" / "试试能不能用" / "XX 不好使" | E2E（standard） | 打开浏览器以用户视角操作 / 复现 |
-| "刚改了 CSS，看看样式对不对" | E2E（lite） | 仅视觉巡检，省时省 token |
+| "检查一下页面" / "看看有没有问题" / "哪里出问题了" / "试试能不能用" / "XX 不好使" | E2E（显式 `mode: "lite"`） | 未主动要求跑功能，执行基础视觉验证 |
+| "刚改了 CSS，看看样式对不对" | E2E（lite） | 仅视觉巡检 |
+| "点提交试试能不能成功" / "帮我把下单流程走一遍" / "走一遍流程" / "验证一下这个功能" | E2E（standard） | 用户明确要求功能 / 交互验证 |
 | "测试一下这个接口的返回值对不对" / "调一下后端 API 看看响应" | `api_request` | 明确指定接口验证 |
 
 ## 派遣 E2E 时的 prompt / 用例规范
@@ -63,6 +124,25 @@ gate-tools:
 
 > **核心原则：agent 只「机械执行 + 报判断」，不做推理。** 判定标准全写死在断言里——别让它自己推断"该测什么"或定义"什么算正常 / 好看"。它的活只有：执行动作 → 看现象 → 报通过 / 不通过。
 
+{% if e2eSemanticPlan %}
+### 验收计划文件：先写文件，再派发（首次与后续同一套）
+
+每次派发都必须带 `agent_options.test_plan_file_path`，不传不执行。**两种 mode 各一份卷**，目录必须与派发 mode 一致（串卷不执行）：standard 卷写 `.spark/e2e-test/standard/<语义名>.json`（含点击 / 输入 / 提交），lite 卷写 `.spark/e2e-test/lite/<语义名>.json`（只放看得见的检查点）。
+
+1. **先看已有的**：`glob .spark/e2e-test/<mode>/*.json` → **读**可能覆盖本需求的那份（没读过不要传）
+2. **改还是新建**：同需求用例有变化 → 编辑那份；换了功能 / 页面 → 新建一份
+3. **派发**：`prompt` 只说跑哪些（`跑 Case 1、2` / `复测 p0 和 p1` / `测试全部用例`），**不点名默认只跑 p0**；一轮点名 ≤5 条
+
+格式（一条用例一行，优先级小写，每卷 ≤10 条；一轮只跑其中 ≤5 条）：
+
+```json
+{"cases":[{"id":1,"priority":"p0","description":"打开首页，预期工单列表渲染出至少 1 行"}]}
+```
+
+- **用例正文只写在计划文件里**：本模式下 `prompt` 不写 `## 测试用例`（下面示例里的用例正文改为写进卷），只留应用结构与本次范围——两处都写会让计划外用例一条不跑、报告却全绿
+- **复测只点名、不删用例**：「只传 failed + 未完成的 Case」指在 `prompt` 里点名，不是从卷里删掉已通过的用例
+{% endif %}
+
 ### 调用结构
 
 ```js
@@ -109,7 +189,8 @@ task({
 - **跑到终态**：提交后出现在列表 / 跳转后内容正确 / 删除后从列表消失
 - **AI 功能看到输出**：翻译 / 摘要 / 生成等核心卖点，须断言到 AI 产出的内容，不停在"AI 弹窗打开"
 - **主链路 + AI 都覆盖**，不因"非主链路"遗漏
-- **Case ≤ 10**：过多会 token 膨胀、超时
+- **一次最多 5 条 Case**：多出来的分下一轮跑，不塞进同一轮
+- **单条 Case ≤ 8 步**：动作步 + 断言步合计，超了就拆 Case 或删断言
 - **不碰登录 / 认证**：应用无登录逻辑，禁止登录 / 注册 / OAuth / CAPTCHA 相关 Case
 
 | ❌ 停在中间状态 | ✅ 跑到最终结果 |
@@ -155,6 +236,16 @@ E2E agent 只在离散时刻抓快照 / 截图，**看不到瞬时过程、不
 
 断言对象若是瞬时中间态 / toast 本身 / 动效本身 / 需伪造网络的分支——改写成稳定终态断言，或直接删掉。
 
+### 高成本控件（最耗步数，按下表写）
+
+| 控件 | 写法 |
+|------|------|
+| 日期 / 时间选择器 | 用默认值，不指定具体日期 |
+| 下拉 / 搜索选择框（antd / MUI / Radix） | 选第一项，不搜关键词筛选；多级联动只验第一级 |
+| 长表单 | 只写必填项 |
+
+必须验这些控件本身时，单独占一条 Case，本轮总数相应减少。
+
 ### 建议覆盖维度
 
 覆盖维度（按实际功能裁剪）：
@@ -188,7 +279,7 @@ E2E 派遣是**昂贵操作**（每次消耗大量 token + 时间）。E2E agent
 
 **白屏 / 整页打不开 → 复测前先重启 devServer**：白屏多为 **devServer 编译挂死 / HMR 卡住**，非代码 bug，直接再派只会重复白屏、白吃一轮配额。顺序：**① 重启 devServer → ② 查编译输出 / runtime-log 确认无报错（不派 E2E）→ ③ 再正常复测**；真要肉眼确认用 `lite` 截图，别用 standard 探活。
 
-**测试范围**：首轮（spec 验收）总 Case **≤ 5**（单次派发上限 ≤10 见 Case 复杂度约束），一行一个 Case，必须含主链路流程测试。禁止测试有真实副作用的功能（发送飞书消息、飞书建群）。
+**测试范围**：每次派发 **≤ 5 条 Case**（首轮 spec 验收同此上限），一行一个 Case，必须含主链路流程测试。禁止测试有真实副作用的功能（发送飞书消息、飞书建群）。
 
 **停止派遣 E2E 的触发条件**（满足任一即停止）：
 
@@ -215,6 +306,9 @@ E2E 派遣是**昂贵操作**（每次消耗大量 token + 时间）。E2E agent
 | E2E 完成后又调 `api_request` 补充验证 | 浏览器操作结果即为最终结果，不追加    |
 | 用户说"看看有没有 bug"就同时调两个    | 只派遣 E2E                            |
 | 用户说"检查接口"时派遣 E2E            | 明确提到接口时用 `api_request`        |
+| 派发 E2E 时不传 `mode` | 每次都显式传 `lite` 或 `standard`；缺失或非法时不会执行 |
+| 用户没主动要求跑功能，却传 `standard` | 显式传 `lite`；仅用户明确要求交互 / 功能验证才传 `standard` |
 | 仅改 CSS / 文案，仍走 `standard`      | 优先用 `lite`，速度快、token 消耗低   |
 | 达到停止条件（≥3 轮 / 同一错误未改代码连续失败）仍继续派 E2E | 停止派遣，转为根因分析（读代码 / 查日志） |
 | 复测时全量重测 / 白屏直接再派一轮 | 只传 failed + 未完成的 Case；白屏先重启 devServer 再复测 |
+{% endif -%}

package/miaoda-modern/charts-skill/SKILL.md

@@ -5,7 +5,7 @@ description: "shadcn/ui + ReactECharts 图表开发规范。Use when creating or
 
 ## L0 基础配置
 
-- **库**: `import ReactECharts from 'echarts-for-react'` (v5.6.0)
+- **库**: `import ReactECharts from 'echarts-for-react'` (echarts v6.1.x)
 - **主题**: `theme="ud"`
 - **颜色**: 🚨 只能用 hex（如 `#1890ff`），禁止 hsl/rgb
 - **高度**: ≥300px (`className='h-[300px]'`)