Makes the WASM skill runtime actually usable: a guest-side SDK that hides the sandbox ABI (`alloc` / `execute` / `memory` exports, `librefang.host_call` / `host_log` imports) behind one `skill!(handler)` macro plus typed host-call wrappers. An author writes `fn(Request) -> Result<Value, String>` and builds a `cdylib` for `wasm32-unknown-unknown`.

- `sdk/rust/librefang-skill` is its own workspace root (mirrors the sidecar SDKs): a WASM guest must not transitively pull in any host-only crate, and an isolated `target/` keeps it off the kernel's shared one.
- `Request` carries the `{tool, input, config}` envelope — identical to what the Python / Node / Shell runtimes receive. A handler `Err` or a malformed envelope surfaces to the agent as `{"error": ...}`.
- `host::` exposes the built-in methods (`time_now`, `fs_*`, `env_read`, `kv_*`, `net_fetch`, `shell_exec`, `agent_send`, `agent_spawn`) with each method's capability and fuel cost documented; `host_call` / `log` are escape hatches.
- Pointer marshaling is gated to `wasm32`; the envelope decode, pack/unpack, and dispatch logic are target-agnostic and unit-tested on the host (7 tests).
- Ships `examples/echo.rs` and a README (crate-type, `panic = "abort"`, build command, matching `skill.toml`).

Verified end-to-end: a real `cargo build --target wasm32-unknown-unknown` of an SDK-based skill emits a module importing exactly `librefang.host_call` / `librefang.host_log` (no WASI) and exporting `memory` / `alloc` / `execute` — the exact surface `WasmSandbox` instantiates. Host clippy `-D warnings` clean; `cargo test` 7 passed.

…xample

The WASM runtime existed but the supporting pieces did not, so a skill author could not actually produce or test one. This fills those gaps.

- docs (`agent/skills` EN + zh): the WASM section described a `wasm32-wasi` + `_start` + stdin model that never matched the sandbox and would fail to instantiate (the sandbox provides only the `librefang` host imports, no WASI). Rewritten to the real `librefang-skill` SDK flow: `wasm32-unknown-unknown`, the `skill!` macro, the `{tool, input, config}` envelope, the host-call capability/fuel table, and accurate sandbox limits.
- `librefang skill create`: the scaffold hard-coded `entry = "src/main.py"` for every runtime and wrote a `// TODO` stub for anything non-Python. Now generates a correct per-runtime scaffold; for `wasm` a `cdylib` `Cargo.toml` (`librefang-skill` dep, `panic = "abort"`), a `src/lib.rs` with the `skill!` handler, the right `entry`, and the build/copy steps. Fixes the Node entry-path bug in passing.
- `librefang skill test`: WASM skills now run in the real sandbox with no kernel. `execute_wasm_skill` is now `pub` and re-exported from `tool_runner`; pure-compute tools run locally, capability-bearing host calls report an error instead of the previous "execution skipped".
- `publish.rs`: a `.wasm` entry is validated to start with the `\0asm` magic, catching an unbuilt placeholder or wrong path before publish. Convention is `entry = "skill.wasm"` at the skill root because the packager excludes `target/`.
- `examples/custom-skill-wasm/`: the WASM twin of `custom-skill-python`; builds to a valid wasm32-unknown-unknown module (verified to carry the `\0asm` magic).

Verification (dev container): clippy `--no-deps -D warnings` clean on cli/runtime/skills; `cargo test -p librefang-runtime --lib wasm_skill` 5 passed; `cargo test -p librefang-skills --lib` 201 passed; example compiles to wasm32 with correct magic bytes.

`sdk/rust/librefang-skill` and `examples/custom-skill-wasm` are independent Cargo workspaces, so the kernel-workspace CI lanes never compile them — the SDK could rot or drift from the sandbox guest ABI unnoticed.

Adds a `skill_sdk` path flag to the change router and a `WASM Skill SDK` job gated on it: fmt + clippy + test the SDK, and compile the example for `wasm32-unknown-unknown` (the target the sandbox loads). Gated to `sdk/rust/librefang-skill/` and `examples/custom-skill-wasm/` so unrelated PRs don't pay for it.

Scoped deliberately to the crates this series introduces; the sidecar SDK crates remain uncovered by PR CI as before (separate concern).

`librefang skill create` for a `wasm` runtime wrote the raw skill name into the generated `Cargo.toml` `[package] name`. A skill name with characters a Cargo package name forbids (uppercase, spaces, a leading digit, punctuation) produced an invalid manifest, so the very first `cargo build` the scaffold tells the author to run would fail.

Derive a legal package name (lowercased, non-`[a-z0-9_-]` mapped to `-`, leading-digit prefixed) for the `Cargo.toml`. The artifact name is already fixed to `skill` via `[lib] name`, so the package name only needs to be valid, not meaningful. The skill.toml `[skill] name` keeps the author's original name.

Surfaced by self-review of the WASM-skill series.

Two correctness gaps found in self-review:

- is_error was hardcoded false, so a WASM skill returning the SDK error
  envelope {"error": ...} surfaced to the agent as a success. Detect a
  top-level error key and set is_error, matching the Python/Node runtimes
  where a non-zero exit yields is_error = true.
- timeout_secs was passed through unclamped, letting a manifest request an
  unbounded wall-clock budget. Clamp to MAX_SKILL_TIMEOUT_SECS (600s) like
  the subprocess runtimes; treat 0 as unset (sandbox default).

Add wasm_skill_error_envelope_sets_is_error covering the error path.

# Conflicts:
#	.secrets.baseline

# Conflicts:
#	.secrets.baseline