宜博 / lemonboss

SKILL.md 31 KB

name: innovator-skill description: > A self-learning, self-iterating skill factory powered by the Hunt→Digest→Evolving (FDE) philosophy. Use this skill whenever a user presents ANY task or question that requires producing high-quality, domain-specific output — writing, research, analysis, code, strategy, etc. — especially when no existing skill is available. The innovator-skill will automatically find or create a purpose-built skill, ground it in real-world industry data, benchmark it against human/industry averages, and iteratively evolve it until it reaches or exceeds that bar. Trigger this skill when the user says things like "help me write X", "create a Y", "analyze Z", "I need a skill for...", or any open-ended

domain task. This is the meta-skill that produces all other skills.

Innovator-Skill

Core Philosophy: Every user question deserves a skill that is grounded in real-world knowledge, measured against industry standards, and continuously evolved until it surpasses human average performance. This is achieved through the Hunt → Digest → Evolving (FDE) three-layer architecture, operating two nested feedback loops: a small loop (Skill Iteration) and a large loop (Benchmark Iteration).

Architecture Overview

[User Question]
      │
      ▼
┌─────────────────────────────────────────────────────────────┐
│  Step 0: ROUTE — Search skill_list.md for existing skill    │
│   ├── Exact/Semantic match found (status: enable) → USE IT  │
│   ├── Match found (status: disable/training) → NOTIFY USER  │
│   └── No match → CREATE NEW SKILL (Steps 1–3)               │
└─────────────────────────────────────────────────────────────┘
      │
      ▼
┌─────────────── LAYER 1: HUNT ───────────────────────────────┐
│  Step 1.1: Deep Research — knowhow, methodology, standards  │
│  Step 1.2: Data Source Discovery — APIs, RSS, rankings, DBs │
│  Step 1.3: Crawler Setup — scripts, schedule, storage       │
│  Step 1.4: First Crawl Run — seed dataset                   │
└─────────────────────────────────────────────────────────────┘
      │
      ▼
┌─────────────── LAYER 2: DIGEST ─────────────────────────────┐
│  Step 2.1: Build knowhow.md — methods, frameworks, criteria │
│  Step 2.2: Build benchmark.md — scoring rubric              │
│  Step 2.3: Label datasets — train set / test set split      │
│  Step 2.4: Establish industry baseline score                │
│  Step 2.5: Write SKILL.md prompt (v1.0.0)                   │
└─────────────────────────────────────────────────────────────┘
      │
      ▼
┌─────────────── LAYER 3: EVOLVING ───────────────────────────┐
│                                                             │
│  ┌──────────────── SMALL LOOP (Skill Iteration) ─────────┐  │
│  │  Run skill on train data → benchmark score            │  │
│  │  Score < 90 → analyze weak dims → fix prompt          │  │
│  │  Repeat until score ≥ 90 OR max iterations            │  │
│  └───────────────────────────────────────────────────────┘  │
│                     ↓ score ≥ 90                            │
│            [SKILL ENABLED → Deliver to Human]               │
│                     ↓ human feedback received               │
│  ┌──────────────── LARGE LOOP (Benchmark Iteration) ─────┐  │
│  │  Feedback = benchmark is wrong/incomplete             │  │
│  │  Re-Hunt + Re-Digest → new benchmark.md version       │  │
│  │  Re-trigger Small Loop with updated benchmark         │  │
│  └───────────────────────────────────────────────────────┘  │
└─────────────────────────────────────────────────────────────┘

Directory Structure (per skill)

/innovator/
├── SKILL.md                          ← this file (meta-skill)
├── skill_list.md                     ← registry of all created skills
│
└── {skill_name}/                     ← e.g., xianxia_novel_skill/
    ├── SKILL.md                      ← the generated skill's prompt & rules
    ├── knowhow.md                    ← domain knowledge, methodology
    ├── benchmark.md                  ← scoring rubric (versioned)
    ├── skill_prompt_v{X}.md          ← versioned prompt snapshots
    │
    ├── crawl/
    │   ├── crawl_config.md           ← data sources, frequencies, priority
    │   ├── crawl_schedule.md         ← cron expressions, deployment guide
    │   ├── crawl_runner.py           ← executable crawler script
    │   ├── crawl_log.md              ← success/failure/skip records
    │   └── {source_name}/
    │       └── {YYYYMMDD}_{source}_{title}.md
    │
    ├── datasets/
    │   ├── train/                    ← 70% of labeled data
    │   ├── test/                     ← 30% of labeled data
    │   └── experience/               ← human feedback records
    │
    ├── benchmark_scores/
    │   └── score_{YYYYMMDD_HHMMSS}.md ← each scoring run result
    │
    └── evolving/
        ├── evolving_log.md           ← iteration history & reasoning
        └── v{X}/
            ├── output_{task}_{time}.md
            └── score_{task}_{time}.md

Step 0: Route — Skill Discovery

Before doing anything else, read /innovator/skill_list.md.

Matching logic (three tiers):

  1. Exact match (skill_name or keywords match exactly, status: enable) → load and use that skill's SKILL.md directly
  2. Semantic match (>80% conceptual overlap) → ask user: "I found a related skill {name}. Reuse/extend it, or create a new one?"
  3. No match / status: disable or training → proceed to Step 1 (create new skill)

Update on every use: increment use_count and last_used in skill_list.md.

Step 1: HUNT — Knowledge & Data Acquisition

Goal: Capture the best available real-world knowledge and data sources for this domain.

⚠️ 本层所有联网动作（deep research / 数据源抓取 / 复检）必须遵守文末 外网访问 SOP：信源一次成功即落盘缓存、curl 收敛为 --retry 1 --max-time 40 + 失败先换镜像域、GitHub 文件走 jsdelivr、落盘后按 title/关键词复核假 200、 词级重复视为流抖动不干预。 另外：调研中凡涉及飞书 / Wiki / 多维表格信源，必须走 飞书文档读取 SOP 的 /app/bin/lark-cli（搜得到 ≠ 读得到），不得用 WebFetch / curl 直连 open.feishu.cn。

1.1 Deep Research (knowhow foundation)

Use the deep_research skill (or web search + synthesis) to answer:

  • What are the established methodologies and frameworks for this domain?
  • What do experts consider the hallmarks of excellent output?
  • What are common failure modes or pitfalls?
  • Who are the top practitioners / benchmark works?

Save raw research notes to {skill_name}/hunt_research_{YYYYMMDD}.md.

1.2 Data Source Discovery

Search for real-world data sources across three categories:

Category Description Examples
Structured APIs, databases, leaderboards, rankings Novel rankings API, arXiv API, GitHub trending
Unstructured Articles, papers, documents, web pages Top-10 novel chapters, recent papers, blog posts
Experience Human-curated, labeled, or rated examples Award winners, expert-reviewed samples, user ratings

For each source, record in crawl_config.md:

source_name: {name}
url: {url}
type: structured | unstructured | experience
frequency: daily | weekly | on_demand
data_points: {what to extract}
industry_relevance: elite | average | broad
priority: 1-5

Important distinction:

  • industry_relevance: elite → Top 10 rankings → used to set elite_avg_score (ceiling target)
  • industry_relevance: average → Rankings 20-100, general samples → used to set industry_avg_score (reference baseline, NOT the pass threshold)

⚠️ IMPORTANT: industry_avg_score is only a reference indicator. The actual pass threshold is always 90, regardless of the industry average. A skill that scores 75 (industry average) is NOT good enough — we demand excellence.

1.3 Crawler Setup

Generate crawl_runner.py with:

  • Configurable source list (reads from crawl_config.md)
  • Rate limiting and retry logic (max 3 retries, exponential backoff)
  • Deduplication (hash-based, skip already-crawled URLs)
  • Output: crawl/{source_name}/{YYYYMMDD}_{source}_{title}.md
  • Logging to crawl_log.md

Generate crawl_schedule.md with cron expressions and deployment instructions.

1.4 First Crawl

Execute crawl_runner.py immediately to seed the dataset. Log results.

Step 2: DIGEST — Knowledge Synthesis & Asset Building

Goal: Transform raw data into structured, reusable knowledge assets.

2.1 Build knowhow.md

Synthesize from Hunt research and crawled data into:

# {Skill Name} — Domain Knowhow

## Core Methodology
[step-by-step approach the skill should follow]

## Key Frameworks
[named frameworks, models, or structures relevant to this domain]

## Quality Dimensions
[what separates excellent from mediocre in this domain]

## Common Pitfalls
[what to avoid]

## Elite Reference Works
[top examples with notes on what makes them excellent]

## Structural Data References
[any APIs, schemas, or data formats the skill should know]

2.2 Build benchmark.md

Derive evaluation rubric from knowhow. Structure:

# {Skill Name} — Benchmark v{X.0.0}
Last updated: {date}
Benchmark version: {X.0.0}
Trigger: {what caused this version — initial | human_feedback | data_update}

## Scoring Dimensions

| # | Dimension | Weight | Description |
|---|-----------|--------|-------------|
| 1 | {dim}     | {%}    | {what it measures} |
...

## Scoring Rubric (per dimension)

### Dimension 1: {name}
- **90-100**: {description of excellent}
- **70-89**:  {description of good}
- **50-69**:  {description of acceptable}
- **30-49**:  {description of poor}
- **0-29**:   {description of failure}

## Total Score Calculation
Weighted sum of all dimensions = Final Score (0-100)

## Pass Thresholds
- **pass_score: 90** — **硬性及格线，所有技能必须达到 90 分才能启用**
- industry_avg_score: {X} — 行业平均参考值（仅做基准对比，不作为通过标准）
- elite_avg_score: {X} — 精英水平参考值

2.3 Label Datasets

From crawled data, create labeled samples:

  • Train set (70%): datasets/train/{YYYYMMDD}_{source}_{id}.md — used in small loop
  • Test set (30%): datasets/test/{YYYYMMDD}_{source}_{id}.md — held out, only used for final validation

Each file should include:

---
source: {source_name}
data_type: structured | unstructured | experience
split: train | test
crawled_at: {datetime}
---
[content]

2.4 Establish Industry Baseline

Score a sample of crawled data (minimum 10 items, mix of elite and average sources) using benchmark.md.

Calculate:

  • industry_avg_score = mean score of industry_relevance: average samples
  • elite_avg_score = mean score of industry_relevance: elite samples

Store full scoring results in benchmark_scores/industry_baseline_{YYYYMMDD}.md.

Update skill_list.md entry for this skill with both scores.

2.5 Write Initial Skill Prompt (v1.0.0)

Write {skill_name}/SKILL.md (the generated skill) based on knowhow.md. Also save snapshot as skill_prompt_v1.0.0.md.

Structure of the generated SKILL.md:

---
name: {skill_name}
description: {when to use, what it does}
version: 1.0.0
---

# {Skill Name}

## Role & Objective
[what this skill's Claude instance should embody]

## Methodology
[step-by-step process from knowhow.md]

## Output Format
[exact format, structure, length expectations]

## Quality Checklist
[self-check list the skill should apply before finalizing output]

## Reference Examples
[1-2 brief elite examples from crawled data]

Step 3: EVOLVING — Reinforcement Learning Loops

Goal: Iteratively improve the skill until output reaches 90 分 (our hard minimum quality bar). Two nested loops operate here: Small Loop (skill iteration) and Large Loop (benchmark iteration).

Small Loop — Skill Iteration

Termination conditions (check before each iteration):

  • ✅ Score ≥ 90 → SUCCESS: enable skill, exit loop
  • ❌ Iterations ≥ MAX_ITERATIONS (default: 10) → HALT: status: disable, log reason
  • ❌ Score delta STALL: trigger deep_research to enrich knowhow.md, then continue (max 1 stall recovery per training run)

Iteration process:

SMALL LOOP:
  current_version = read latest version from evolving_log.md (start: v1)

  REPEAT:
    1. SELECT one training sample from datasets/train/
    2. RUN current skill SKILL.md on the sample as if it were a user question
    3. SCORE output using benchmark.md → save to evolving/v{N}/score_{task}_{time}.md
    4. READ evolving_log.md to get previous scores

    IF score ≥ 90:
      → UPDATE skill_list.md: status=enable, current_score={score}
      → LOG success in evolving_log.md
      → EXIT small loop

    ELSE:
      5. ANALYZE: which benchmark dimensions scored lowest?
      6. TRACE: which part of skill_prompt / knowhow is responsible for those dimensions?
      7. PATCH: rewrite relevant section of SKILL.md
         - Minor fix (prompt wording) → version bump: patch (+0.0.1)
         - Methodology change → version bump: minor (+0.1.0)
      8. SAVE new prompt snapshot as skill_prompt_v{version}.md
      9. LOG in evolving_log.md:
         ```
         ## Iteration {N} — {datetime}
         Version: {old} → {new}
         Train sample: {filename}
         Score: {old_score} → {new_score}
         Weak dimensions: {list}
         Changes made: {description}
         Reasoning: {why this change should help}
         ```
      10. INCREMENT iteration counter → GOTO step 1

  ON HALT (max iterations or stall):
    → UPDATE skill_list.md: status=disable
    → LOG halt reason in evolving_log.md
    → NOTIFY user with summary of attempts and bottlenecks

Version numbering:

  • +0.0.1 (patch): prompt wording, tone, format tweaks
  • +0.1.0 (minor): methodology step changes, new quality checklist items
  • +1.0.0 (major): full rewrite of knowhow or benchmark

Large Loop — Benchmark Iteration (triggered by human feedback)

When a user provides feedback after using an enabled skill, evaluate the feedback:

Feedback classification:

  • Type A — Output quality issue: The skill's output was poor → small loop issue → re-run small loop with more iterations
  • Type B — Benchmark definition issue: The skill followed the benchmark but the result still felt wrong → large loop trigger

Large loop process (Type B only):

LARGE LOOP:
  1. PARSE human feedback → extract what dimension or expectation was unmet
  2. RE-HUNT:
     - New deep research focused on the unmet dimension
     - Search for new data sources that better represent the gap
     - Crawl new samples
  3. RE-DIGEST:
     - Update knowhow.md with new insights (append, don't overwrite history)
     - Revise benchmark.md:
       - Increment version: +1.0.0
       - Add/modify dimensions to address feedback
       - Recalculate industry_avg_score with new benchmark on existing data
       - Document what changed and why in benchmark.md header
  4. LABEL new datasets from newly crawled data
  5. RE-TRIGGER small loop (start from v{current_major+1}.0.0)
  6. LOG in evolving_log.md:
     ```
     ## Large Loop Trigger — {datetime}
     Feedback received: {summary}
     Feedback type: B (benchmark revision)
     Benchmark: v{old} → v{new}
     Changes: {what changed in benchmark}
     Re-entering small loop at: v{new_major}.0.0
     ```

Step 4: DEPLOY — Skill 部署到 Agent（必须执行，不可跳过）

⚠️ CRITICAL: 这是 FDE 流水线的最后一步。如果跳过此步，训练成果 等于白费 — Skill 将只存在于 workspace 中，而 Agent 仍然是个空壳。 任何情况下，训练达标后必须立即执行部署。这不是可选步骤。

部署流程

DEPLOY (score ≥ 90 后自动触发):

  1. COPY SKILL:
     → 复制 train/evolver/{skill_name}/skill_*.md
     → 到 agents/{agent_name}/SKILL.md
     → 验证: 确认文件存在且 > 1KB

  2. UPDATE AGENT.MD:
     → 在 agents/{agent_name}/agent.md 末尾追加:
     ```markdown
     ## Trained Skill
     - **版本**: {version}
     - **评分**: {score}
     - **状态**: ✅ 已达标 (≥ 90)
     - **训练日期**: {date}
     > 详细 Skill 定义见: SKILL.md
     ```

  3. UPDATE CONFIG.JSON:
     → 设置 agents/{agent_name}/config.json 中 status = "ready"

  4. UPDATE PLAN.MD:
     → 在 agents/{agent_name}/plan.md 中记录训练完成

  5. VERIFY (最终检查):
     → 确认 agents/{agent_name}/SKILL.md 存在
     → 确认 agents/{agent_name}/config.json status = "ready"
     → 确认 agents/{agent_name}/agent.md 包含 "Trained Skill" 章节
     → 如果任何一项缺失，立即补齐

  ON FAILURE:
     → 不能返回“训练完成”
     → 必须报告 DEPLOY 失败原因
     → 重试部署

目录结构对照

训练产出位置 部署目标位置 操作
train/evolver/{skill}/skill_*.md agents/{agent}/SKILL.md 复制
train/evolver/{skill}/evolution_log.json 保留原位 不动
- agents/{agent}/agent.md 追加摘要
- agents/{agent}/config.json 更新 status
- agents/{agent}/plan.md 更新进度

外网访问 SOP（出网不稳环境，强制）

背景：本机出网不稳定（github.com 超时、raw.githubusercontent 直连不可达、docs.claude.com 有区域封锁假 200） 已被确认为 Innovator 链路反复报「网络错误」的根因。以下五条规则在所有 Hunt / Digest / Evolving 环节的 联网动作上强制执行，并由 Innovator 在派单给 Hunter / Evolver 时随任务一并下发。 （R2/R4/R5 于 2026-08-28 依 deep-research Hunt P0 实测结论修订，源自 Hunter 的抓取环境结论 + master 验收意见。）

R1 官方信源一次成功即落盘缓存（cache-first，后续轮次禁止复抓）

官方参考文档抓取成功一次之后，必须立刻持久化，不允许留在对话上下文里：

  • 原文全文另存到该 skill 的 train/hunt/sources_raw/<域名>_<名称>.txt
  • 同时登记进 train/hunt/sources_*.json（数组追加，不覆盖旧条目）：
{
  "url": "https://raw.githubusercontent.com/...",
  "name": "官方 prompt 规范",
  "sha256": "<64 位十六进制，用 sha256sum 计算>",
  "fetched_at": "YYYY-MM-DDTHH:MM:SSZ",
  "local_path": "train/hunt/sources_raw/raw.githubusercontent_<名称>.txt",
  "fetch_method": "curl | webfetch",
  "note": "首抓成功"
}
  • 后续轮次（retrain / large loop / 任何复检）对该 URL 只读缓存、不再复抓； 需要核对版本一致性时先 sha256sum local_path 与登记值比对，只有比对不一致才允许重抓， 并作为新条目记入 sources_*.json（带新 sha256 与时间戳）。
  • 这样做的收益：把「抓得到看运气」变成「抓到过一次就永久可用」，出网抖动不会再拖垮下游阶段。

R2 单次抓取硬参数 + 三级降级，失败不回滚整轮

所有 curl 必须收敛为这组参数（2026-08-28 deep-research Hunt P0 实测后修订）：

curl -sSL --retry 1 --max-time 40 ...
  • ❌ 禁止再使用 --retry 3 --retry-all-errors --max-time 60：慢主机上单条 URL 会被放大到 4 分钟以上（实测 raw.githubusercontent 45s 超时 × 3 次重试 ≈ 4 分钟白等，最后什么也没拿到）。
  • --max-time 40 是上限，不许为了让它多等一会儿改成更大的值；重试次数固定 1，不再加码。
  • 降级顺序固定：curl 失败 → 换镜像域/换路径再试一次（GitHub 文件走 R4 的 jsdelivr 镜像）→ 用 WebFetch 再试一次 → 仍失败则在当轮产出里标注「无法复检（URL + 时间戳）」，然后照常推进。 注意 WebFetch / WebSearch 在本环境可能整段被网络策略拦截（deep-research Hunt P0 实测两者均不可用）， 不要把它当可靠兜底，更不要因为它失败而卡住整轮。
  • ❌ 禁止因单个 URL 抓不到就重跑整轮 Hunt/Digest/Evolving 训练。网络抖动不是训练质量问题 的证据，也不能作为返工理由；「无法复检」条目列入产出中如实上报即可。

R3 transcript 词级重复 = 流中断自愈，无需人工干预

  • 特征：transcript 里出现词级重复，例如 Quotes Quotes、同一个词或半句话紧接着又从头打一遍。
  • 含义：这是输出流被中断后网关侧自动重试产生的，属于网关抖动，会自行恢复。
  • 处置：判定为抖动后不需要人工干预 —— 不重启会话、不重发派单、不改判本轮产出无效； 只有当同一处内容重复出现 ≥3 次仍无法恢复成正常输出时，才升级为异常另行处理。
  • 与记忆库记录一致：「Innovator 网络错误根因 = 出网受限 + 流抖动，词级重复是流中断特征」。

R4 GitHub 仓库文件：raw.githubusercontent 直连不可达，先走 jsdelivr 镜像域

  • 实测（deep-research Hunt P0，2026-08-28）：raw.githubusercontent.com 全部 TCP/响应 timeout、0 字节； 同一批文件经 https://cdn.jsdelivr.net/gh/<org>/<repo>@<branch>/<path> 全部 200 （已验证 anthropics/skills、anthropics/claude-code、assafelovic/gpt-researcher、stanford-oval/storm）。
  • 规则：抓 GitHub 仓库文件先试镜像域，直连 raw 只作为镜像 404 时的最后尝试 （jsdelivr 是 CDN 缓存，刚推送的文件可能尚未同步）。
  • 镜像抓到的文件同样按 R1 落盘 + sha256；登记时 url 仍写原始 raw / github.com 地址、 fetch_method 注明「jsdelivr 镜像」，保证后续轮次能对回官方出处。

R5 HTTP 200 ≠ 内容有效：落盘后必须按 title/关键词复核

  • 实测两类假 200（deep-research Hunt P0）：
    1. docs.claude.com 区域封锁页 —— HTTP 200、约 429KB，正文是 "App unavailable in region"， 且不同 URL 返回字节级相同内容（sha256 完全一致）；
    2. WordPress 软 404 —— 目标文章返回 404 状态却带回 94KB 正常站点外壳页，目标关键词 grep = 0。
  • 规则：每个抓到的文件落盘后必须复核一次有效性 —— HTML 查 <title> 是否与预期主题一致， 再 grep 1–2 个该文档必含的关键词；两条 URL 的 sha256 完全一致即判定为镜像/错误页，只记其一。
  • 复核不过关的文件：可留在 sources_raw/ 供复核，但必须登记进 blocked_sources， 不得当有效信源引用；依赖它的方法论结论一律降级为「未复检」，不得编造引文。

✅ 自检清单（Hunt / Evolve 收尾时逐项过一遍）：

  • [ ] 本次涉及的每个官方 URL 都已有 sources_*.json 条目（含 sha256 与本地原文路径）
  • [ ] 所有 curl 调用带齐 --retry 1 --max-time 40，且失败后先换镜像域再考虑 WebFetch
  • [ ] GitHub 仓库文件走了 cdn.jsdelivr.net/gh/... 镜像，登记里注明镜像方式
  • [ ] 每个落盘文件都过了 title/关键词复核，假 200 全部进了 blocked_sources、没混进有效信源
  • [ ] 抓取失败的 URL 已标注「无法复检」，且没有因此触发整轮重跑
  • [ ] 本轮未因词级重复做过无意义的人工干预

飞书文档读取 SOP（lark-cli，强制）

背景：飞书 / 开放平台域名在本环境出网受限且带登录墙，用 WebFetch / curl 去抓 open.feishu.cn 必然读不到（这是 Innovator 早期「读不到飞书文档」的根因）。2026-08-28 master 安装并复验了 /app/bin/lark-cli（官方 larksuite/cli v1.0.91，bot 身份 + tenant_access_token，读操作免浏览器 OAuth）， 实测 docs +fetch --doc SREndflzEonZnIxyGBEcLtEmnuQ --scope outline 返回 ok:true 且拿到真实大纲。 因此：凡是要读飞书文档 / Wiki / 多维表格 / 表格，一律只走 lark-cli，不得再尝试 WebFetch / curl。

命令模板（写死这个入口，别自己找 PATH）

L=/app/bin/lark-cli

# 搜文档（返回 title / url / token / summary）
$L drive +search --query "关键词"

# 读内容：先 outline 拿结构，再按需取正文 / 定位章节
$L docs +fetch --doc <token或完整URL> --scope outline
$L docs +fetch --doc <token> --doc-format markdown
$L docs +fetch --doc <token> --scope keyword --keyword "验收标准"
# section 模式不接受 --keyword，必须先用 outline 拿 block id：
$L docs +fetch --doc <token> --scope section --start-block-id <block_id>

# 其它域：$L wiki --help / $L base --help / $L sheets --help
# 查官方 AI 友好用法：$L docs --help  /  $L skills read lark-doc
  • 输出是 JSON，ok:true 才算成功；失败看 error.type / error.message / error.hint。
  • 命令分三层：快捷命令带 + 前缀（docs +fetch、drive +search），子命令不带 +； 报 unknown subcommand 先看 hint，多半是漏了 +。
  • --doc-format markdown 下内嵌白板只渲染成 <whiteboard token="..."/>，流程图正文拿不到 —— 这是受限项，要如实记成「读不到」，不要当成空内容或凭空补写。

权限边界（别反复踩坑）

  • 搜得到 ≠ 读得到：自建应用只能读「对该应用可见」的文档。+fetch 报权限 / 不存在时， 需要文档所有者把文档加为应用可用范围 / 加 bot 为协作者——这不是工具问题， 正确动作是记为 blocked 并继续推进，禁止反复重试。
  • 凭据在 /home/node/.lark-cli/config.json（权限 600）：不要 cat / 打印 / 复制它， 不在日志或汇报里出现 App Secret / token（与全局安全规则一致）。
  • 读操作免登录；写操作（创建 / 更新 / 发消息）risk level 为 write / high-risk-write， high-risk-write 要 --yes；拿不准先 --dry-run，并向上级说明打算写什么。
  • 完整 SOP（含凭据重灌、重装、更多域命令）： /app/system/agents/master/_global/master/lark-cli-sop.md； 通用工具层条款见 packages/agent-core/base/common/tools-base.md 的 lark-cli 段。

✅ lark-cli 自检（涉及飞书信源时逐项过）：

  • [ ] 全部飞书读取都走了 /app/bin/lark-cli，本次 0 次 WebFetch / curl 直连 open.feishu.cn
  • [ ] 先 outline 后正文 / 章节，--scope section 用的是 block id 而不是 --keyword
  • [ ] 权限失败的文档记为 blocked 并上报（等所有者开放），未做无意义重试
  • [ ] 未 cat / 打印 / 复制 /home/node/.lark-cli/config.json，日志中无 secret
  • [ ] 白板等读不到的富媒体已按「受限项」如实标注，未被当成空内容

skill_list.md Schema

Each skill entry in /innovator/skill_list.md:

## {skill_name}
- **skill_id**: {uuid or sequential id}
- **directory**: /innovator/{skill_name}/
- **description**: {one-line description}
- **scope**: {domains/use cases}
- **status**: training | enable | disable
- **version**: {current version e.g. 1.3.2}
- **benchmark_version**: {e.g. 2.0.0}
- **industry_avg_score**: {number, 0-100}
- **elite_avg_score**: {number, 0-100}
- **current_score**: {number, 0-100}
- **use_count**: {number}
- **last_used**: {datetime}
- **last_updated**: {datetime}
- **created_at**: {datetime}
- **keywords**: [{list of trigger keywords}]

evolving_log.md Schema

Located at {skill_name}/evolving/evolving_log.md:

# Evolving Log — {skill_name}

## Summary
- Total iterations: {N}
- Current version: {version}
- Current score: {score}
- Industry avg: {score}
- Status: training | enable | disable

---

## Iteration {N} — {datetime}
Loop type: small | large
Version: {old} → {new}
Score: {old} → {new}
Weak dimensions: [dim1, dim2]
Changes: {description}
Reasoning: {why}

---

Execution Checklist

When a new skill creation is triggered, Claude must complete ALL of these. 不允许跳过任何步骤：

  • [ ] Step 0: Search skill_list.md — no match confirmed
  • [ ] Step 1.1: Deep research completed → hunt_research_{date}.md
  • [ ] Step 1.2: Data sources identified → crawl_config.md
  • [ ] Step 1.3: Crawler script written → crawl_runner.py, crawl_schedule.md
  • [ ] Step 1.4: First crawl executed → data in crawl/{source}/
  • [ ] Step 2.1: knowhow.md written
  • [ ] Step 2.2: benchmark.md v1.0.0 written (pass_score = 90)
  • [ ] Step 2.3: Train/test datasets labeled and split
  • [ ] Step 2.4: Industry baseline scored → industry_avg_score and elite_avg_score set
  • [ ] Step 2.5: SKILL.md v1.0.0 written + skill_prompt_v1.0.0.md saved
  • [ ] Step 3 (small loop): Evolving completed → score ≥ 90
  • [ ] Step 4.1: SKILL.md 复制到 agents/{agent}/SKILL.md ❗
  • [ ] Step 4.2: agent.md 追加 Trained Skill 摘要 ❗
  • [ ] Step 4.3: config.json status 更新为 ready ❗
  • [ ] Step 4.4: plan.md 记录训练完成 ❗
  • [ ] Step 4.5: 验证部署 — 确认 SKILL.md 存在且完整 ❗
  • [ ] Skill enabled → skill_list.md updated with status: enable
  • [ ] Delivered to user with score report + 部署确认

Reference Files

Read these when needed:

  • references/skill_list_template.md — blank template for skill_list.md initialization
  • references/benchmark_template.md — starter benchmark structure for common domains
  • references/crawl_runner_template.py — base crawler script to customize
  • references/evolving_log_template.md — blank evolving log template