skvm-general

分类: 数据与AI | 上传者: SJTU-IPADS | 下载: 0 | 版本: v1.0（最新）
代表用户驱动 skvm CLI 来分析模型、AOT 编译技能、运行技能辅助任务、运行基准测试以及管理已编译的提案。当用户要求“分析”、“aot-compile”、“bench”、“运行技能”或询问 skvm 建议时触发。
更新日志: Source: GitHub https://github.com/SJTU-IPADS/SkVM
目录结构

当前层级: tree/main/skills/skvm-general/
📄 SKILL.md 8.8 KB
SKILL.md

---
name: skvm-general
description: Drive the skvm CLI on behalf of a user to profile models, AOT-compile skills, run skill-assisted tasks, run benchmarks, and manage compiled proposals. Trigger when the user asks to "profile", "aot-compile", "bench", "run a skill", or asks about skvm proposals.
---

# SkVM General Usage

You are driving `skvm`, a CLI that AOT-compiles and runs LLM agent skills across heterogeneous models. Use this skill when the user wants to *use* skvm — profile a model, AOT-compile a skill, run a task with a skill, run a benchmark, or manage optimization proposals. Do **not** invent flags — every example below uses the real flag set from the installed `skvm` binary.

## Step 1: Prerequisite self-check

Split the check in two — the binary must always be present, but the API key is only required for commands that call an LLM.

**Always required** — skvm is on PATH:

```bash
skvm --help >/dev/null 2>&1 || { echo "skvm not installed — tell the user to run: curl -fsSL https://skillvm.ai/install.sh | sh"; exit 1; }
```

**Required only before LLM-calling commands** — `profile` (without `--list`), `aot-compile`, `pipeline`, `run`, `bench`, `jit-optimize`. Local filesystem commands (`profile --list`, `proposals list|show|reject`, `logs`, `clean-jit`) do **not** need the API key — run them even if the key is unset.

```bash
# Before running profile/aot-compile/run/bench/jit-optimize:
test -n "${OPENROUTER_API_KEY:-}" || { echo "OPENROUTER_API_KEY is not set — ask the user for their key"; exit 1; }
```

If a required prerequisite is missing, **stop** and tell the user what is missing. Do not install anything yourself.

## Step 2: Profile a model

A profile (TCP — Target Capability Profile) records what an LLM can do across 26 primitive capabilities. It is the input for AOT compilation and is cached so subsequent compile calls reuse it.

```bash
skvm profile --model=<id>                              # profile one model
skvm profile --model=<id1>,<id2> --concurrency=4       # profile several in parallel
skvm profile --model=<id> --adapter=opencode           # non-default adapter
skvm profile --model=<id> --force                      # ignore cache, re-run
skvm profile --list                                    # list cached profiles
```

Notes:
- Default adapter is `bare-agent`. Other valid adapters: `opencode`, `openclaw`, `hermes`, `jiuwenclaw`.
- Cache lives at `$SKVM_PROFILES_DIR` (default `.skvm/profiles/`).
- Profiling is expensive — confirm with the user before running on several models, and prefer `--concurrency` over sequential runs.

## Step 3: AOT-compile a skill

AOT compilation rewrites a skill's `SKILL.md` (and optionally bundle files) so it fits a specific target model's capability profile. The three-pass AOT compiler runs by default.

```bash
skvm aot-compile --skill=<path> --model=<id>                       # all three passes
skvm aot-compile --skill=<path> --model=<id> --pass=1,2,3          # explicit
skvm aot-compile --skill=<path> --model=<id> --pass=1              # only pass 1 (SCR + gap analysis)
skvm aot-compile --skill=<path> --model=<id> --dry-run             # no write
skvm pipeline --skill=<path> --model=<id>                          # profile-if-needed → aot-compile
```

Pass semantics:
- `--pass=1` — SCR extraction, gap analysis, capability substitution/compensation
- `--pass=2` — dependency manifest + env-binding script generation
- `--pass=3` — workflow decomposition + DAG parallelism extraction

Compiled variants land under the proposals tree (`proposals/aot-compile/...`). Multiple passes can be combined in any subset: `--pass=1,3` runs passes 1 and 3, skipping 2.

## Step 4: Run a single task with a skill

For ad-hoc debugging of one skill on one task:

```bash
skvm run --task=<path/to/task.json> --model=<id>                    # no skill
skvm run --task=<path> --model=<id> --skill=<path/to/SKILL.md>      # with skill
skvm run --task=<path> --model=<id> --adapter=opencode --verbose    # explicit adapter + debug
```

Use this to reproduce a single failing task or validate a skill edit. Do **not** use it for benchmarking — use `skvm bench` instead.

## Step 5: Bench a skill

Benchmarking runs a skill across many tasks and condition variants. It can get expensive fast — always confirm with the user before running across many models or tasks, and use `--concurrency` for parallelism.

```bash
skvm bench --model=<id>                                              # all conditions, all tasks
skvm bench --model=<id> --conditions=original,aot-compiled           # baseline + compiled
skvm bench --model=<id> --conditions=jit-optimized                   # use latest jit-optimize best round
skvm bench --model=<id> --conditions=jit-boost --jit-runs=5          # 5 warmup runs for solidification
skvm bench --model=<id1>,<id2> --concurrency=4                       # multi-model in parallel
skvm bench --model=<id> --tasks=task_01,task_02 --runs-per-task=3    # specific tasks, 3 reps each
skvm bench --model=<id> --async-judge                                # defer LLM-judge to post-run batch
skvm bench --resume=latest                                           # resume an interrupted session
skvm bench --list-sessions                                           # list past sessions
```

Valid `--conditions` strings:
- `no-skill` — run the task with no skill injected (baseline floor)
- `original` — the skill as-written (baseline ceiling)
- `aot-compiled` — full 3-pass AOT compiled variant
- `aot-compiled-p1`, `-p2`, `-p3`, `-p12`, `-p13`, `-p23` — single or partial AOT passes
- `jit-optimized` — the latest best-round variant from `skvm jit-optimize` proposals
- `jit-boost` — code-solidification runtime optimization

Bench logs land at `.skvm/log/bench/<sessionId>/`.

## Step 6: Manage jit-optimize proposals

Proposals are the artifact produced by `skvm jit-optimize` (and by the sibling `skvm-jit` skill). Each proposal contains the original skill in `round-0/`, one or more improved rounds in `round-N/`, and metadata recording which round the engine considered best.

```bash
skvm proposals list                                           # all proposals
skvm proposals list --status=pending                          # only pending (not yet accepted/rejected)
skvm proposals list --skill=<name> --target-model=<id>        # filter by skill + target model
skvm proposals show <id>                                      # print metadata and per-round summary
skvm proposals accept <id>                                    # deploy the engine-recommended best round
skvm proposals accept <id> --round=2                          # override: deploy round 2 instead
skvm proposals accept <id> --target=<dir>                     # deploy to a non-default skill dir
skvm proposals reject <id>                                    # mark as rejected (no deploy)
```

Proposal id format: `<harness>/<target-model>/<skill-name>/<timestamp>`. When the user gives you an id like `bare-agent/claude-sonnet-4.6/calendar/20260401T120000Z`, pass it verbatim — do not reformat it.

**Critical rule**: only run `skvm proposals accept` when the user has **explicitly** asked to deploy. If the user just says "check the proposals", run `list` and `show` and stop there. Accepting without confirmation overwrites the skill files in place.

## Step 7: Environment variables

| Variable | Required | Purpose |
|----------|----------|---------|
| `OPENROUTER_API_KEY` | yes | OpenRouter key used by bare-agent, profiler, compiler (when routed through OpenRouter), and jit-optimize optimizer |
| `ANTHROPIC_API_KEY` | optional | Enables the Anthropic SDK backend for the compiler and judge |
| `SKVM_DATA_DIR` | optional | Override the input dataset root (default: `./skvm-data` submodule) |
| `SKVM_CACHE` | optional | Override the runtime cache root (default: `~/.skvm`) |
| `SKVM_PROPOSALS_DIR` | optional | Override the proposals storage root (default: `~/.skvm/proposals/`) |

`OPENROUTER_API_KEY` is only required for commands that actually call an LLM. Local-only commands (`proposals list/show/reject`, `profile --list`, `logs`, `clean-jit`) run without it.

## Rules

- **Never run `bench` or `profile` across many models without explicit user confirmation** — they can cost tens of dollars per run. Always quote an expected model count back to the user before starting.
- **Never run `skvm proposals accept` unless the user explicitly asked to deploy.**
- **Prefer `--concurrency=<n>` over sequential loops** for multi-model work.
- **Do not invent flags.** If the user asks for something you don't see in this skill, run `skvm <command> --help` to check before guessing.
- **Do not install anything.** If `skvm` is missing, tell the user to run the installer; if `OPENROUTER_API_KEY` is missing, ask them for it.
- **Surface skvm's stderr progress lines** (e.g. `Installing bundled opencode…`, `Downloading profile…`) as normal output — they are not errors.
登录后下载/点赞/收藏 ❤ 14 | ★ 0
skvm-general

目录结构

SKILL.md

举报内容

提示
