--- 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](#外网访问-sop出网不稳环境强制)：信源一次成功即落盘缓存、curl 收敛为 > `--retry 1 --max-time 40` + 失败先换镜像域、GitHub 文件走 jsdelivr、落盘后按 title/关键词复核假 200、 > 词级重复视为流抖动不干预。 > 另外：调研中凡涉及**飞书 / Wiki / 多维表格**信源，必须走 [飞书文档读取 SOP](#飞书文档读取-soplark-cli强制) > 的 `/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: ```markdown # {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: ```markdown # {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: ```markdown --- 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: ```markdown --- 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 < 2 points for 3 consecutive iterations → **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`（数组追加，不覆盖旧条目）： ```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 实测后修订）： ```bash 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//@/` 全部 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 查 `` 是否与预期主题一致， 再 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） ```bash 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`: ```markdown ## {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`: ```markdown # 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