加"样板技能"驱动: skill 归驱动管的样例 (主模型 / 小模型两档)

老板口径 (2026-09-16): skill 可以写个示例, 但 skill 是归驱动管的, 所以只要样例就行, 分主模型和小模型 skill.

驱动/样板技能/  (第 4 个样板驱动)
  配置.efi.json            oneshot / interpreter system / 无契约
  技能.py                  只列不执行: 把自带的 skill 读出来打印 (档次 / 步骤数 / 样例数 / 边界数)
  技能/请求解析-主模型.json  tier=main    步骤 3 (抽象, 规划权交给模型) / 样例 1 / 边界 3
  技能/请求解析-小模型.json  tier=small   步骤 5 (编号写死, 每步一个判据) / 样例 3 (含 2 条反例) / 边界 4

口径
  内核不认识 skill (只管确定性代码能力的接入与仲裁); 读它 / 选模型 / 拼 prompt / 校验输出 / 重试 全归驱动
  同一件事写两份: main 靠模型规划 / small 靠结构稳 (args 键白名单 + confidence 只许 0/0.5/1 + 反例 few-shot)
  样例任务选"把一句话解析成 calls 的 want+args" -- 正是底座里主模型(规划多步)与小模型(填固定结构)的真实分工

设计/05-技能规范.md (新): 归谁管 / 字段表 12 项 / 两档对照 / 版本边界(v0.1 不做加载器·选模型·校验·重试) / 连带清单
文档同步: README(程序(Skill) 行 + 驱动清单 3->4 + 设计档案 01~05) / 文档02(新增"驱动可以带 skill"节, 原第 8 节顺移为 9) /
         文档06(分层表那条) / 文档07(依赖图加技能声明一行) / 文档01(驱动列表快照补第 4 行) / 设计01(第 7 节指向 设计/05)

验收: 扫描 驱动 4 / 有效 4 / 运行 0; 启动 样板技能 -> oneshot 退出码 0, 日志里两档 skill 都列出来;
      uvx pyright 0 errors / 0 warnings (新驱动代码过严格档; json.loads 收窄成 dict[Unknown,Unknown] 那处用 cast 修掉);
      五份自测全过; 试跑引导器 PASS 11 / FAIL 0 / 残留无

README.md

@@ -14,7 +14,7 @@
 | 引导器 | `UEFI.boot.py` | 体检 6 项 / venv / 包台账 / 内核进程启停记账 / 参数原样透传 |
 | 内核 | `内核/` | 常驻总调度：命令消费、驱动契约仲裁（六条）、依赖链巡检、收尸、独一份调度锁 |
 | 驱动 | `驱动/<名>/` | **一个文件夹 = 一个驱动**（根目录有 `配置.efi.json` 才认）；只经 PG 表与外界说话 |
-| 程序(Skill) | — | v0.2 占位（`web.json` 声明式） |
+| 程序(Skill) | 驱动内的 `技能/*.json` | 声明式、模型驱动，**归驱动管**（内核不掺和）；样例 `驱动/样板技能/`，规范 `设计/05` |
 
 驱动之间**零耦合**：不 import、不互调、配置里也不写对方名字 —— 只声明"我要什么 / 我产出什么"（契约名），
 谁给、什么顺序、怎么送达全归内核。
@@ -43,8 +43,8 @@ python3 UEFI.boot.py 内核 停止                   # 收工 (驱动不动, 下
 | `内核/` | 内核本体：`内核.py` 常驻调度 + `扫描.py` 校验契约 + `状态.py` 状态机快照 + `db.py`（**唯一碰 SQL**）+ `进程.py` + `日志.py` + `文本.py` |
 | `内核/自测*.py` | 五份**真机**自测（进程 / 内核 / 配置 / db / 日志） |
 | `试跑引导器.py` | 端到端验收（11 项，含残留检查） |
-| `驱动/` | 三个样板：`Json解码`(oneshot) / `样板常驻`(resident + 提供服务) / `样例消费器`(消费契约) |
-| `设计/` | 设计档案 `01-驱动规范` ~ `04-日志系统`（字段表、DDL、判定表的原文在这里） |
+| `驱动/` | 四个样板：`Json解码`(oneshot) / `样板常驻`(resident + 提供服务) / `样例消费器`(消费契约) / `样板技能`(skill 归驱动管，main+small 两档) |
+| `设计/` | 设计档案 `01-驱动规范` ~ `05-技能规范`（字段表、DDL、判定表的原文在这里） |
 | `文档/` | 使用与开发文档 `00-索引` ~ `10-验收与质量门` |
 | `归档/` | 修前的证据存档（如日志系统重做前的原始 `内核.log`） |
 

文档/01-快速上手.md

@@ -127,6 +127,7 @@ python3 UEFI.boot.py 内核 状态
 状态    驱动名      形态    PID    运行时长  配置  说明
 ──────  ──────────  ──────  ─────  ────────  ────  ──────────────────────────────
 已退出  Json解码    python  —      —         一致  把 web.json 解出来打印 -- 程序/Skill 层样本
+停止    样板技能    python  —      —         一致  演示 skill 归驱动管: skill 是声明式文件 (技能/*.json), 分主模型 / 小模型两档
 停止    样例消费器  python  —      —         一致  要别人的东西时不认识对方, 只往 calls 表发契约请求
 运行    样板常驻    python  20444  00:00:12  一致  常驻 + 打印心跳 + 往 events 表汇报
 

文档/02-写一个驱动.md

@@ -171,7 +171,33 @@ def 汇报(连接, message: str, kind: str = "heartbeat") -> None:
 | 不起眼但最有用的一招 | 直接**手动跑一遍**：`python3 驱动/问好/问好.py`（驱动是普通程序，不需要内核就能跑） |
 | 配置改完不生效 | 配置有 `config_hash` 指纹，改完要**重启**：`内核/内核.py 重启 <名>`（`列表` 会提示"待重启"） |
 
-## 8. 交付一个驱动前的检查表
+## 8. 驱动可以带 skill（归你管）
+
+驱动不只会跑代码，还可以**携带 skill** —— 声明式文件放在 `驱动/<名>/技能/*.json`，**一个 skill 一个文件**。
+规矩只有一条：**内核不知道 skill 的存在**，读它、解释它、决定给哪个模型，全是驱动自己的事
+（内核只管确定性代码能力的接入与仲裁，一旦它掺和 skill，"模型"这个概念就漏进内核了）。
+
+同一件事**写两份**，分模型档（字段表与两档差别见 `设计/05-技能规范.md`）：
+
+| 档 | 给谁 | 写法 |
+|---|---|---|
+| `tier: "main"` | 云端强模型 / 本地 27B+ | 步骤**抽象** 3 条，只锁外层结构，规划权交给模型 |
+| `tier: "small"` | 本地 4B~9B | 步骤**写死**编号 5 条，字段白名单 + 置信度只许三档，含反例 few-shot |
+
+最小骨架（完整样例看 `驱动/样板技能/技能/请求解析-主模型.json`）：
+
+```json
+{ "efi": 1, "name": "…", "version": "0.1", "tier": "main",
+  "description": "一句话", "when": ["什么时候用"],
+  "input": { "说明": "…", "schema": {} }, "steps": ["…"],
+  "output": { "format": "json", "schema": {}, "说明": "…" },
+  "examples": [ { "输入": {}, "输出": {} } ], "boundaries": ["不许编 / 不许猜"], "notes": ["给谁跑"] }
+```
+
+驱动怎么用：启动时读自己目录下的 `技能/`，按 `tier` 选模型、拼 prompt、校验输出、失败重试 —— **全在你手里**。
+`驱动/样板技能/技能.py` 是最小示范（只把自带的 skill 列出来打印，不执行）。
+
+## 9. 交付一个驱动前的检查表
 
 - [ ] 文件夹根目录有 `配置.efi.json`，且 `efi=1` / `name` 唯一 / `runtime` / `entry` 齐全
 - [ ] `entry` 是**相对路径**，不出驱动根（不许 `..`）

文档/06-架构与不变量.md

@@ -125,4 +125,4 @@
 | 调用结果没有大小限制 | `result` 是 jsonb；大对象该走"提供方写自己的表 + result 只放引用" | 出现大结果时 |
 | 依赖巡检 10s 粒度 | 崩了最多 10s 才被发现/重拉 | 需要更快时（但会更吵） |
 | 单 PG 单库 | 没有分片/跨库 | 不在本版范围 |
-| 程序/Skill 层未加载 | `web.json` 是雏形样本，由 `Json解码` 这类驱动解释执行 | v0.2 |
+| 程序/Skill 层未加载 | skill **归驱动管**：声明在 `驱动/<名>/技能/*.json`（两档样例 `驱动/样板技能/`，规范 `设计/05`），驱动自己读自己解释；内核不认识它 | v0.2 才定"谁执行" |

文档/07-模块与接口.md

@@ -19,6 +19,7 @@ UEFI.boot.py ──┬─► 进程.py          通用进程库: 启停 / 判活
                └─► 汇总: 命令分发 / 单驱动动作 / 常驻调度
 
 驱动/<名>/*.py ──► psycopg2 直连 PG (只写 events / calls; 不 import 项目里任何模块)
+驱动/<名>/技能/*.json ──► 纯声明 (由所属驱动自己读; 内核不认识它)
 ```
 
 规矩：`db.py` 是**唯一**写 SQL 的地方（别处一律不出现 SQL 字符串）；`进程.py` / `日志.py` / `文本.py`

设计/01-驱动规范.md

@@ -216,8 +216,9 @@ __pycache__/
 老板 9/7 的分层是：引导器(UEFI) → 内核 → 驱动 → 程序(Skill)。
 
 - **驱动 = 确定性代码能力接入层** → 本文件写的这一层，有 `配置.efi.json` 才是驱动。
-- **程序(Skill) = 声明式、模型驱动** → `web.json`（{html, css, js}）就是最早的雏形样本，由
-  `Json解码` 这类驱动负责解释执行。
+- **程序(Skill) = 声明式、模型驱动，且归驱动管** → `web.json`（{html, css, js}）是最早的雏形样本，由
+  `Json解码` 这类驱动负责解释执行；skill 现在落在 `驱动/<名>/技能/*.json`，分主模型 / 小模型两档，
+  **内核不认识它**（字段表与两档差别见 `05-技能规范.md`，样例见 `驱动/样板技能/`）。
 
 驱动 ↔ 内核、驱动 ↔ 驱动之间**不设计协议**，全部经 PostgreSQL（`events` 表当总线，见本文件第 3 节
 末与 02 第 3 节）—— 这是老板定的口径，不需要"三选一"。

设计/05-技能规范.md

@@ -0,0 +1,79 @@
+# 05 · 技能（Skill）规范 —— skill 归驱动管
+
+> 老板 2026-09-16 的口径：**"skill 是归驱动管的，所以只要样例就行，分主模型和小模型 skill"**。
+> 本文只定"**放哪、长什么样、两档差在哪**"；**谁执行、怎么调模型，留到 v0.2**，本版一个样例都不执行。
+> 分层依据见 `01-驱动规范.md` 第 7 节（引导器 → 内核 → 驱动 → 程序(Skill)）。
+
+## 1. 归谁管（先把边界说死）
+
+| 谁 | 管什么 |
+|---|---|
+| **内核** | **不知道 skill 的存在**。内核管的是"确定性代码能力的接入与仲裁"（扫描/契约/启停/调用），skill 不在它的视野里 |
+| **驱动** | **持有并解释**自己的 skill：从哪读、给哪个模型、prompt 怎么拼、输出怎么校验、失败怎么重试，全是驱动自己实现 |
+| 目录 | `驱动/<驱动名>/技能/*.json` —— 一个 skill 一个文件，文件名不参与语义（`name` 字段才是名字） |
+
+为什么不让内核管：skill 天生带着"模型"这个概念（分档、prompt、温度、上下文…），一旦内核掺和，
+内核就从"确定性调度器"变成"模型编排器"，后面每换一个模型都要动内核。**换模型只该动驱动和 skill 文件。**
+
+## 2. 声明字段（JSON，键用英文；值用中文）
+
+| 字段 | 类型 | 必填 | 说明 |
+|---|---|---|---|
+| `efi` | int | ✅ | 声明版本，现在是 `1`（跟 `配置.efi.json` 同一套版本号习惯） |
+| `name` | str | ✅ | skill 名（人看、日志里打）；建议和文件名一致，不一致以本字段为准 |
+| `version` | str | | 这份 skill 自己的版本 |
+| `tier` | str | ✅ | **模型档**：`main`（主模型）/ `small`（小模型） |
+| `description` | str | ✅ | 一句话：这份 skill 干什么 |
+| `when` | [str] | ✅ | 触发条件；**也要写"什么情况别用"**（在 `boundaries` 里兜） |
+| `input` | obj | ✅ | `{"说明": str, "schema": obj}` —— 输入长什么样（谁提供也要写清） |
+| `steps` | [str] | ✅ | 执行步骤；两档写法差别最大的字段（见第 3 节） |
+| `output` | obj | ✅ | `{"format": "json", "schema": obj, "说明": str}` |
+| `examples` | [obj] | | few-shot：`[{"输入": …, "输出": …}]` |
+| `boundaries` | [str] | ✅ | 边界与错误处理：**画红线的那几条**（不许编、不许猜、信息不足回问） |
+| `notes` | [str] | | 注意事项：给谁跑、坑在哪、为什么这么写 |
+
+## 3. 两档差在哪（同一件事写两份）
+
+| | `main`（主模型档） | `small`（小模型档） |
+|---|---|---|
+| 步骤 | **抽象**：3 条左右，"读懂 → 挑 → 填"，把规划权交给模型 | **写死**：编号 5 条，每步只做一件事 + 一个判据（"别的都别看"） |
+| 输出结构 | **只锁外层**：`plan` 是数组、每步必须有 `want`；参数细节不预设 | **全锁死**：单值 `want`（不是数组）、`args` 键白名单、`confidence` 只许 `0 / 0.5 / 1` |
+| few-shot | 1 条（示范格式） | 2~3 条，**必须含反例**（信息不足 → 回问；多步请求 → 只做第一步） |
+| 兜底 | 允许用自己的常识补全参数 | 一律"**与原话字面比对**"：原话里没有的值填 `null`，不许举例、不许编路径 |
+| 执行权 | 允许多步（`plan` 是数组），要长上下文 | 一次只做一步 |
+| 给谁跑 | 云端强模型 / 本地 27B+ | 本地 4B~9B |
+| 换模型 | **不用改文件** | **不用改文件** |
+
+一句话：**main 靠模型聪明，small 靠结构稳。** 这就是老板那句"结构稳不赖模型智商，深度靠换模型"的落法。
+
+## 4. 样例在哪、怎么验
+
+| 位置 | 内容 |
+|---|---|
+| `驱动/样板技能/配置.efi.json` | 声明这个驱动是 `oneshot`、`interpreter: system`、无契约 |
+| `驱动/样板技能/技能.py` | **只列不执行**：把自带的 skill 读出来打印（档次 / 步骤数 / 样例数 / 边界数） |
+| `驱动/样板技能/技能/请求解析-主模型.json` | main 档样例（任务：把一句话解析成 `calls` 的 `want` + `args`，允许多步计划） |
+| `驱动/样板技能/技能/请求解析-小模型.json` | small 档样例（同一任务，锁死结构 + 3 条样例含 2 条反例） |
+
+```bash
+./.venv/bin/python 内核/内核.py 启动 样板技能    # 跑一遍
+./.venv/bin/python 内核/内核.py 日志 样板技能    # 看它列出来的清单
+```
+
+选择"请求解析"当样例任务的原因：它正好是这个底座里**主模型与小模型真实的分工** ——
+主模型负责"该调谁、要不要多步"，小模型负责"把一句话填进 `want` + `args` 这个固定结构"。
+skill 自己**不碰 PG、不发 `calls`**（那是驱动的事），它只是声明。
+
+## 5. 版本边界（v0.1 明确不做）
+
+| 不做 | 为什么 / 谁做 |
+|---|---|
+| 加载器 / 注册表 / 内核侧索引 | 内核不管 skill；驱动自己在启动时读自己目录下的 `技能/` |
+| 选模型、拼 prompt、温度、上下文配额 | 驱动实现（各驱动用的模型可能完全不同） |
+| 输出校验、重试、降级、记账 | 驱动实现；要留痕就写 `events` 表（`kind` 自己定，见 `文档/08`） |
+| skill 之间互相调用 / 组合 | 不需要：要串就由驱动编排，或让主模型在 `plan` 里排多步 |
+| 权限、配额、沙箱 | 跟驱动同等待遇，v0.2 再说 |
+
+**改动这份规范时的连带清单**：`驱动/样板技能/技能/*.json`（样例要跟着改）→
+`文档/02-写一个驱动.md`（"驱动可以带 skill"那节）→ `文档/06-架构与不变量.md`（分层表里 Skill 那行）→
+`README.md`（三层结构表）→ 技能 `kernel-driver-framework`。

驱动/样板技能/技能.py

@@ -0,0 +1,75 @@
+"""样板技能: 演示 "skill 归驱动管"。
+
+skill = 声明式文件 (技能/*.json), 由**驱动**持有并解释 -- 内核不知道 skill 的存在,
+也不管它怎么执行 (依据 设计/01 第 7 节的分层: 引导器 -> 内核 -> 驱动 -> 程序(Skill))。
+
+这个驱动只干一件事: 把自己带的 skill 列出来 (档次 / 步骤数 / 样例数), 证明驱动拿得到自己的 skill。
+真执行 (选模型、拼 prompt、校验输出) 留给驱动自己实现, 本驱动不掺和。
+
+为什么分两档 (老板口径 "结构稳不赖模型智商"): 同一件事写两份 --
+  main  : 步骤抽象, 只锁外层结构, 靠模型自己规划 (强模型)
+  small : 步骤写死, 字段白名单 + 置信度只许三档, 靠结构稳 (小模型)
+换模型不用改底座, 也不用改驱动。
+"""
+
+import json
+from pathlib import Path
+from typing import Any, cast
+
+技能目录 = Path(__file__).resolve().parent / "技能"
+
+
+def 读一份(路径: Path) -> dict[str, Any] | None:
+    """读一份 skill 声明; 读不了就报一行错并给 None (不静默跳过)."""
+    try:
+        内容: Any = json.loads(路径.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as 错:
+        print(f"  [错误] {路径.name}: {错}")
+        return None
+    if not isinstance(内容, dict):
+        print(f"  [错误] {路径.name}: 顶层必须是对象")
+        return None
+    # json.loads 给的是 Any, 上面只核了"是不是对象"; 这里显式声明键值类型 (pyright 严格档要的)
+    return cast(dict[str, Any], 内容)
+
+
+def 读全部() -> list[dict[str, Any]]:
+    """把本驱动带的 skill 全读出来 (按文件名排, 结果稳定)."""
+    if not 技能目录.is_dir():
+        return []
+    结果: list[dict[str, Any]] = []
+    for 路径 in sorted(技能目录.glob("*.json")):
+        内容 = 读一份(路径)
+        if 内容 is not None:
+            结果.append(内容)
+    return 结果
+
+
+def 一行(内容: dict[str, Any]) -> str:
+    """一行说清一份 skill 是哪一档、几步、几个样例."""
+    档 = "main" if 内容.get("tier") == "main" else ("small" if 内容.get("tier") == "small" else "?")
+    名字 = str(内容.get("name") or "?")
+    步数 = len(内容.get("steps") or [])
+    样例 = len(内容.get("examples") or [])
+    边界 = len(内容.get("boundaries") or [])
+    说明 = str(内容.get("description") or "")
+    return f"  [{档:<5}] {名字}  步骤 {步数} / 样例 {样例} / 边界 {边界}  {说明}"
+
+
+def 主() -> int:
+    """列清单, 不执行 (只证明 skill 归驱动管)."""
+    全部 = 读全部()
+    print(f"样板技能: 本驱动带 {len(全部)} 份 skill (目录 {技能目录})")
+    for 内容 in 全部:
+        print(一行(内容))
+    档 = {str(内容.get("tier") or "") for 内容 in 全部}
+    if {"main", "small"} <= 档:
+        print("样板技能: 两档齐全 -- main 靠模型规划(步骤抽象) / small 靠结构稳(步骤写死 + 字段白名单)")
+    else:
+        print(f"样板技能: 注意, 两档不齐 (现在只有 {sorted(档)})")
+    print("样板技能: 收工 (skill 由驱动管; 内核不掺和它的执行)")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(主())

驱动/样板技能/技能/请求解析-主模型.json

@@ -0,0 +1,55 @@
+{
+  "efi": 1,
+  "name": "请求解析-主模型",
+  "version": "0.1",
+  "tier": "main",
+  "description": "把用户一句自然语言请求, 解析成驱动调用 (want 契约名 + args 参数); 需要时拆成多步计划.",
+  "when": [
+    "用户的话里有明确动作意图 (取什么 / 解什么 / 算什么)",
+    "要判断该调哪个驱动、参数怎么填",
+    "信息不够时敢回问, 不硬猜"
+  ],
+  "input": {
+    "说明": "用户原话 + 当前可用契约清单 (由内核扫描产出, 不写死在 skill 里)",
+    "schema": {
+      "用户原话": "string",
+      "可用契约": ["string"]
+    }
+  },
+  "steps": [
+    "读懂用户到底要什么 (要数据、要结论、还是要动作)",
+    "在可用契约里挑最贴的; 一个不够就串成多步, 顺序写清谁先谁后",
+    "参数填成 JSON; 拿不准的宁可留 null 并说明, 不要编一个看起来合理的值"
+  ],
+  "output": {
+    "format": "json",
+    "schema": {
+      "plan": [{ "want": "契约名", "args": {}, "为什么": "一句话" }],
+      "need_user": "string|null -- 信息不够时写要问什么, 此时 plan 留空",
+      "confidence": "0~1"
+    },
+    "说明": "主模型档只锁外层结构: plan 是数组 (一步或多步都行), 每步必须有 want; 参数细节不预设, 由模型按契约语义自己定."
+  },
+  "examples": [
+    {
+      "输入": {
+        "用户原话": "把那份 json 里的字段名都列出来",
+        "可用契约": ["Json解码:解析", "样板:心跳"]
+      },
+      "输出": {
+        "plan": [{ "want": "Json解码:解析", "args": { "文件": "上次那份" }, "为什么": "只有它能读 json" }],
+        "need_user": null,
+        "confidence": 0.8
+      }
+    }
+  ],
+  "boundaries": [
+    "契约清单里没有能满足的 -> 不要硬编一个 want, 用 need_user 说明缺什么",
+    "用户话里有歧义 -> 回问一句, 不要两件事都做",
+    "输出必须是能直接被 json.loads 的 JSON, 前后不加解释文字"
+  ],
+  "notes": [
+    "这一档靠模型自己规划, 所以步骤写得抽象; 换个更强的模型不用改这份文件.",
+    "给云端强模型或本地 27B 以上跑 (plan 允许多步, 上下文要够长)."
+  ]
+}

驱动/样板技能/技能/请求解析-小模型.json

@@ -0,0 +1,74 @@
+{
+  "efi": 1,
+  "name": "请求解析-小模型",
+  "version": "0.1",
+  "tier": "small",
+  "description": "把用户一句话填进固定结构: 只从给定契约清单里选一个 want, 并填 args; 不许自己发明契约名.",
+  "when": [
+    "只有一句话、一个动作, 不需要规划多步",
+    "契约清单和参数名都已给定 (抽取任务, 不是规划任务)",
+    "要求输出严格 JSON, 能直接被程序读"
+  ],
+  "input": {
+    "说明": "用户原话 + 契约清单 (每条带它接受的参数名); 都由驱动给, 不给就不许答",
+    "schema": {
+      "用户原话": "string",
+      "契约清单": [{ "want": "string", "参数": ["string"] }]
+    }
+  },
+  "steps": [
+    "第 1 步: 读用户原话, 只找动词和名词 (要做什么 / 对什么做), 别的都别看",
+    "第 2 步: 在契约清单里逐条比对, 选中唯一一条 want; 找不到就填 null 并跳到第 5 步",
+    "第 3 步: 对选中的 want, 只允许填它 参数 列表里出现的参数名, 不许新增参数名",
+    "第 4 步: 参数值只能来自用户原话里出现过的词; 原话里没有的参数一律填 null (不许猜、不许举例、不许编路径)",
+    "第 5 步: 只输出 JSON, 四个字段一个都不能少 (want / args / need_user / confidence)"
+  ],
+  "output": {
+    "format": "json",
+    "schema": {
+      "want": "string|null -- 必须来自契约清单, 不许自造",
+      "args": "object -- 键必须来自该契约的 参数 列表; 缺的值填 null",
+      "need_user": "string|null -- 只有 want=null 时填一句要问的话",
+      "confidence": "number -- 只能是 0 / 0.5 / 1 三个值之一"
+    },
+    "说明": "小模型档把结构锁死: 单值 want (不是数组)、args 键白名单、置信度只许三档、不许输出多余字段."
+  },
+  "examples": [
+    {
+      "输入": {
+        "用户原话": "把 demo.json 解出来",
+        "契约清单": [{ "want": "Json解码:解析", "参数": ["文件"] }]
+      },
+      "输出": { "want": "Json解码:解析", "args": { "文件": "demo.json" }, "need_user": null, "confidence": 1 }
+    },
+    {
+      "输入": {
+        "用户原话": "帮我看看那个东西怎么样了",
+        "契约清单": [{ "want": "Json解码:解析", "参数": ["文件"] }]
+      },
+      "输出": { "want": null, "args": {}, "need_user": "你说的哪个文件?", "confidence": 1 }
+    },
+    {
+      "输入": {
+        "用户原话": "先解 demo.json 再算一下字数",
+        "契约清单": [{ "want": "Json解码:解析", "参数": ["文件"] }]
+      },
+      "输出": {
+        "want": null,
+        "args": {},
+        "need_user": "这句要两步 (解 + 算字数), 我一次只做一步: 先解哪个文件?",
+        "confidence": 0.5
+      }
+    }
+  ],
+  "boundaries": [
+    "契约清单没给 -> 直接 need_user 要清单, 不要凭常识编契约名",
+    "用户原话里没出现过的参数值 -> 填 null, 不要填示例值、不要猜路径",
+    "多步请求 (出现 先...再...) -> 这一档只做第一步, 剩下写进 need_user, 不要自己串",
+    "输出前后不许有任何解释文字, markdown 代码块标记也算多余"
+  ],
+  "notes": [
+    "这一档靠结构稳, 不靠模型聪明: 所有判断都落在'与原话字面比对'上, 所以 4B~9B 也跑得稳.",
+    "步骤编号写死是让模型逐步跟; 改成大段描述就退化 (老板口径: 结构稳不赖模型智商)."
+  ]
+}

驱动/样板技能/配置.efi.json

@@ -0,0 +1,12 @@
+{
+  "efi": 1,
+  "runtime": "python",
+  "mode": "oneshot",
+  "entry": "技能.py",
+  "interpreter": "system",
+  "provides": [],
+  "needs": [],
+  "autostart": false,
+  "restart": "no",
+  "note": "演示 skill 归驱动管: skill 是声明式文件 (技能/*.json), 由本驱动持有; 分主模型 / 小模型两档"
+}