skillfed 0.1.0__tar.gz

skillfed-0.1.0/.gitignore

@@ -0,0 +1,32 @@
+# Node
+node_modules/
+npm-debug.log*
+*.tgz
+
+# Python
+__pycache__/
+*.pyc
+.venv/
+dist/
+build/
+*.egg-info/
+
+# Vendored payload — copied from integrations/claude-code/ by scripts/vendor-payload.mjs.
+# Canonical source lives there; these are build-time copies, never hand-edited or committed.
+installer/payload/
+python-installer/src/skillfed/payload/
+
+# Local env / secrets
+.env
+*.local
+
+# Editor / OS junk
+.DS_Store
+Thumbs.db
+~$*
+
+# Local Claude state (never part of the release)
+.claude/
+
+# Federation runtime sinks (tenant-session artifacts)
+federation_data/

skillfed-0.1.0/PKG-INFO

@@ -0,0 +1,37 @@
+Metadata-Version: 2.4
+Name: skillfed
+Version: 0.1.0
+Summary: No-clone installer for Skill Federation — drops the curl-tier finder skill + /skillfed command into ~/.claude. Run via `uvx skillfed` or `pipx run skillfed`. Stdlib only, zero deps.
+Project-URL: Homepage, https://github.com/skill-federation/skill-federation
+Project-URL: Repository, https://github.com/skill-federation/skill-federation
+License-Expression: MIT
+Keywords: agent-skills,claude-code,installer,skill-federation,skillfed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# skillfed (Python installer)
+
+No-clone installer for [Skill Federation](https://github.com/skill-federation/skill-federation).
+Drops the curl-tier finder skill + `/skillfed` command into `~/.claude` (or `./.claude`).
+
+```bash
+uvx skillfed                  # curl tier, user scope (~/.claude)
+uvx skillfed --with-hook      # + plan-approval nudge
+uvx skillfed --with-npx       # + register the npx -y skillfed-mcp MCP server
+uvx skillfed --scope project  # install into ./.claude
+
+# or, with pipx:
+pipx run skillfed
+```
+
+Then **restart Claude Code** and run `/skillfed <what you're trying to do>`.
+
+Stdlib only, zero dependencies. The runtime finder itself needs just `curl`. This package is one
+of three install paths — see the project README for the curl bootstrap and `npx skillfed`.
+
+## Build (maintainers)
+
+```bash
+node ../scripts/vendor-payload.mjs   # vendor the 3 payload files into src/skillfed/payload/
+python -m build                      # sdist + wheel in dist/
+```

skillfed-0.1.0/README.md

@@ -0,0 +1,26 @@
+# skillfed (Python installer)
+
+No-clone installer for [Skill Federation](https://github.com/skill-federation/skill-federation).
+Drops the curl-tier finder skill + `/skillfed` command into `~/.claude` (or `./.claude`).
+
+```bash
+uvx skillfed                  # curl tier, user scope (~/.claude)
+uvx skillfed --with-hook      # + plan-approval nudge
+uvx skillfed --with-npx       # + register the npx -y skillfed-mcp MCP server
+uvx skillfed --scope project  # install into ./.claude
+
+# or, with pipx:
+pipx run skillfed
+```
+
+Then **restart Claude Code** and run `/skillfed <what you're trying to do>`.
+
+Stdlib only, zero dependencies. The runtime finder itself needs just `curl`. This package is one
+of three install paths — see the project README for the curl bootstrap and `npx skillfed`.
+
+## Build (maintainers)
+
+```bash
+node ../scripts/vendor-payload.mjs   # vendor the 3 payload files into src/skillfed/payload/
+python -m build                      # sdist + wheel in dist/
+```

skillfed-0.1.0/pyproject.toml

@@ -0,0 +1,29 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "skillfed"
+version = "0.1.0"
+description = "No-clone installer for Skill Federation — drops the curl-tier finder skill + /skillfed command into ~/.claude. Run via `uvx skillfed` or `pipx run skillfed`. Stdlib only, zero deps."
+readme = "README.md"
+requires-python = ">=3.9"
+license = "MIT"
+keywords = ["skill-federation", "skillfed", "claude-code", "agent-skills", "installer"]
+dependencies = []
+
+[project.urls]
+Homepage = "https://github.com/skill-federation/skill-federation"
+Repository = "https://github.com/skill-federation/skill-federation"
+
+[project.scripts]
+skillfed = "skillfed.cli:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/skillfed"]
+
+# The payload is vendored from integrations/claude-code/ by scripts/vendor-payload.mjs and is
+# git-ignored, so hatchling's VCS-aware file selection would skip it. `artifacts` force-includes
+# it into both the sdist and the wheel. Run `node scripts/vendor-payload.mjs` before building.
+[tool.hatch.build]
+artifacts = ["src/skillfed/payload/*"]

skillfed-0.1.0/src/skillfed/__init__.py

@@ -0,0 +1,3 @@
+"""Skill Federation — no-clone installer (Python tier, `uvx skillfed` / `pipx run skillfed`)."""
+
+__version__ = "0.1.0"

skillfed-0.1.0/src/skillfed/cli.py

@@ -0,0 +1,147 @@
+"""Skill Federation installer — Python tier (`uvx skillfed` / `pipx run skillfed`).
+
+Same curl-tier install as install.sh / install.ps1 / `npx skillfed`, packaged for PyPI so the
+smallest-dependency audience (CI, Python shops) can install with no clone and no Node:
+
+    uvx skillfed                  # curl tier, user scope (~/.claude)
+    uvx skillfed --with-hook      # + plan-approval nudge (safe settings.json merge)
+    uvx skillfed --with-npx       # + register the npx -y skillfed-mcp MCP server
+    uvx skillfed --scope project  # install into ./.claude instead of ~/.claude
+
+The 3 payload files are vendored into this package (src/skillfed/payload/) by
+scripts/vendor-payload.mjs and shipped inside the wheel. When run from a source checkout before
+vendoring, we fall back to the canonical copy under integrations/claude-code/. Stdlib only.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import shutil
+import sys
+from importlib.resources import files
+from pathlib import Path
+
+ENDPOINT_DEFAULT = "https://qurini-skill-federation.hf.space"
+
+# vendored filename -> (dest path under .claude, repo-relative clone-fallback path)
+PAYLOAD = [
+    ("SKILL.md", ("skills", "skill-federation", "SKILL.md"),
+     ("skills", "skill-federation", "SKILL.md")),
+    ("plan_nudge.json", ("skills", "skill-federation", "plan_nudge.json"),
+     ("hooks", "plan_nudge.json")),
+    ("skillfed.md", ("commands", "skillfed.md"),
+     ("commands", "skillfed.md")),
+]
+
+
+def _read_payload(name: str, repo_rel: tuple[str, ...]) -> bytes:
+    """Bytes of a payload file: the bundled copy if present, else the clone fallback."""
+    try:
+        # chained single-arg joinpath: multi-arg joinpath is 3.11+, this stays 3.9-safe
+        res = files("skillfed").joinpath("payload").joinpath(name)
+        if res.is_file():
+            return res.read_bytes()
+    except (FileNotFoundError, ModuleNotFoundError, OSError):
+        pass
+    # Clone fallback: <repo>/integrations/claude-code/<repo_rel>
+    # cli.py -> skillfed -> src -> python-installer -> <repo root>
+    repo = Path(__file__).resolve().parents[3]
+    cand = repo.joinpath("integrations", "claude-code", *repo_rel)
+    if cand.is_file():
+        return cand.read_bytes()
+    sys.exit(
+        f"error: payload '{name}' not found (bundled or in a clone). "
+        "Run scripts/vendor-payload.mjs, or install from the published package."
+    )
+
+
+def _backup(path: Path) -> None:
+    if path.exists():
+        shutil.copyfile(path, path.with_name(path.name + ".bak"))
+        print(f"  backed up -> {path}.bak")
+
+
+def _read_json(path: Path) -> dict:
+    if path.exists() and path.stat().st_size > 0:
+        return json.loads(path.read_text(encoding="utf-8"))
+    return {}
+
+
+def _write_json(obj: dict, path: Path) -> None:
+    path.write_text(json.dumps(obj, indent=2) + "\n", encoding="utf-8")
+
+
+def main(argv: list[str] | None = None) -> int:
+    ap = argparse.ArgumentParser(prog="skillfed", description="Install the Skill Federation finder.")
+    ap.add_argument("--scope", choices=("user", "project"), default="user")
+    ap.add_argument("--target")
+    ap.add_argument("--with-hook", action="store_true")
+    ap.add_argument("--with-npx", action="store_true")
+    ap.add_argument("--endpoint", default=ENDPOINT_DEFAULT)
+    args = ap.parse_args(argv)
+
+    if args.target:
+        target = Path(args.target).resolve()
+    elif args.scope == "user":
+        target = Path.home() / ".claude"
+    else:
+        target = Path.cwd() / ".claude"
+
+    print("Skill Federation installer (uvx skillfed)")
+    print(f"  target : {target}  (scope={args.scope})")
+    print()
+
+    # ALWAYS: curl tier (skill + command) — plain file writes, works immediately.
+    skill_dir = target / "skills" / "skill-federation"
+    cmd_dir = target / "commands"
+    skill_dir.mkdir(parents=True, exist_ok=True)
+    cmd_dir.mkdir(parents=True, exist_ok=True)
+    for name, dest_parts, repo_rel in PAYLOAD:
+        (target.joinpath(*dest_parts)).write_bytes(_read_payload(name, repo_rel))
+    print("[curl] installed finder skill + /skillfed command (zero runtime)")
+
+    # --with-hook: register the plan-approval nudge (safe merge + backup, idempotent).
+    if args.with_hook:
+        nudge_abs = str(skill_dir / "plan_nudge.json").replace("\\", "/")
+        cmd = f'curl -s "file://{nudge_abs}"'
+        settings = target / "settings.json"
+        s = _read_json(settings)
+        ptu = s.setdefault("hooks", {}).setdefault("PostToolUse", [])
+        already = any(
+            "plan_nudge.json" in str(h.get("command", ""))
+            for e in ptu for h in e.get("hooks", [])
+        )
+        if already:
+            print("[hook] already registered; skipped")
+        else:
+            _backup(settings)
+            ptu.append({
+                "matcher": "ExitPlanMode",
+                "hooks": [{"type": "command", "command": cmd, "timeout": 20}],
+            })
+            _write_json(s, settings)
+            print("[hook] registered plan-approval nudge in settings.json")
+
+    # --with-npx: register the published Node MCP server (project-scoped .mcp.json).
+    if args.with_npx:
+        mcp = Path.cwd() / ".mcp.json"
+        m = _read_json(mcp)
+        _backup(mcp)
+        m.setdefault("mcpServers", {})["skillfed-mcp"] = {
+            "command": "npx",
+            "args": ["-y", "skillfed-mcp"],
+            "env": {"SKILLFED_ENDPOINT": args.endpoint},
+        }
+        _write_json(m, mcp)
+        print(f"[npx] registered Node MCP server -> {mcp} (npx -y skillfed-mcp)")
+
+    print()
+    print("Done. Restart Claude Code, then run:  /skillfed <what you're trying to do>")
+    print(f"Endpoint: {args.endpoint}  (override with $SKILLFED_ENDPOINT)")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

skillfed-0.1.0/src/skillfed/payload/SKILL.md

@@ -0,0 +1,185 @@
+---
+name: skill-federation
+description: Find vetted agent skills for the current task from a federated catalog, the privacy-preserving way. Use right after a plan is approved, when you hit a capability gap mid-task, or when the user asks to find/discover a skill ("/skillfed …", "is there a skill that…"). You generate an abstract wish-list (never the plan) and the federation matches it.
+allowed-tools: Bash, Read, Write, Glob
+---
+
+# Skill Federation — wish-list finder
+
+Discover vetted agent skills **without ever sending the user's plan, brief, or work
+across the boundary**. You reason about the *ideal* skills for the task, emit an
+abstract wish-list, and the federation matches those wishes against its catalog.
+
+> **Privacy floor (constitution Principle IV) — non-negotiable.** What leaves the machine is only
+> the abstract wish — its one-line `description`, its ~4 paraphrased `formulations`, 1–5
+> `keywords`, and its structured capability `sketch` (per [demand-sketch.md](demand-sketch.md)).
+> The sketch's flattened terms ride **inside the search query on every search** (and on a miss the
+> same sketch is the demand pointer). (The wish `name` is display-only and stays local; the search
+> payload is the concatenated description + formulations + flattened sketch, plus keywords.) Every
+> field stays at the "what skill should exist" abstraction. The plan, brief, outputs, file
+> contents, and your reasoning trace MUST NOT appear in any description, formulation, keyword,
+> sketch, or search payload. If you can't phrase a need without quoting the user's content,
+> abstract it until you can.
+
+## When to use
+
+- A plan was just approved (the plan-approval hook nudges you here).
+- You're about to build something a packaged skill likely already does (PDF
+  extraction, market sizing, PR review, SQL reporting, resume tailoring, …).
+- The user says "find a skill for…", "is there a skill that…", or runs `/skillfed`.
+
+> **Don't skip silently.** If you conclude a plan needs no skill search (e.g. bespoke work on your
+> own codebase), say so **explicitly** — name the capabilities you considered and why none needs a
+> federated skill — and **confirm with the user** before proceeding without a search.
+
+## Backend — MCP tools if present, else `curl`
+
+**If the `skillfed-mcp` MCP tools are available this session** (`find_skills`,
+`get_skill_bundle`, `report_selection`, `emit_demand_pointer` — the optional Node/npx tier),
+**use them**: they hit the same federation with typed, validated I/O and no shell-out. The
+wish-list, selection, trust, and reporting logic below are identical — just call the tool
+instead of the matching `curl` POST (`find_skills` ≙ `/search`, `get_skill_bundle` ≙ `/fetch`,
+`report_selection` ≙ `/report_selection`, `emit_demand_pointer` ≙ `/report_demand`).
+
+**Otherwise (the default), use `curl`** — it ships with Windows 10+ (`curl.exe`) and macOS
+(`/usr/bin/curl`), so the finder needs **no Python, no Node, no install**. You run `curl`
+through your shell (Bash) tool.
+
+- **Endpoint**: use `$SKILLFED_ENDPOINT` if it's set, else default
+  `https://qurini-skill-federation.hf.space` (the keyless demo). Point it at our own
+  federation core later — the request/response shapes are unchanged.
+- **Defaults**: `top_n` = 3 candidates per wish; ~4 paraphrases per wish.
+- **Windows note**: in PowerShell, `curl` is an alias for `Invoke-WebRequest` — call
+  **`curl.exe`** explicitly. On macOS/Linux plain `curl` is fine.
+- **Quoting-safe pattern**: write each JSON request body to a temp file and send it with
+  `--data-binary "@<file>"`, so no shell has to escape braces or quotes.
+
+The federation operations below are one `curl` POST each — `/search`, `/fetch`,
+`/report_selection`, `/report_demand`. (The endpoint also exposes `/report_outcome` for
+post-use signals; that's out of scope for the finder.)
+
+## The flow (two hops; always user-approved before install)
+
+### Hop 1 — search
+
+1. **Form an expected-response sketch, then a wish-list.** For the task, imagine the
+   *ideal* skill(s): what each would do, its inputs/outputs, the key operations, and the
+   discriminative vocabulary its SKILL.md would contain. Emit that sketch as a real
+   `sketch` field on each wish (it powers the search query *and* becomes the demand
+   pointer on a miss — author it once, per [demand-sketch.md](demand-sketch.md)). Then
+   write **up to 10 wishes** — fewer is fine — each:
+   - `name`: short hypothetical skill name (display-only, stays local),
+   - `description`: **one line** for display only (the wish→match table) — abstract, no
+     plan specifics,
+   - `keywords`: **1–5 required** evidence terms the description omits but the target
+     skill's docs would contain (the discriminative subset of `sketch.domain_vocab`),
+   - `formulations`: **~4 paraphrases** of the description with *deliberately varied
+     vocabulary* (synonyms, alternate framings). The load-bearing recall field — a single
+     phrasing misses ~20% of the time; 4 concatenated paraphrases erase that (BM25 is
+     bag-of-words, so they form a robust term-union query). Keep each abstract; never
+     quote the plan/brief.
+   - `sketch`: the structured expected-response sketch — `purpose / inputs / outputs /
+     operations / domain_vocab / section_sketch / tags` (demand-sketch.md schema). Its
+     flattened term values are appended to the search query, so the single BM25 call sees
+     the full discriminative vocabulary a matching SKILL.md would contain (SIRA step iii),
+     not just the 1–5 keywords. Keep it terse and capability-level — never task data.
+
+2. **Search each wish with `curl` (`/search`).** For each wish, concatenate its
+   `description` + `formulations` + the flattened `sketch` term values into ONE
+   bag-of-words query string (BM25 is bag-of-words, so the concatenation is a robust
+   term-union — matches a K-request ensemble at 1/K the cost; the sketch supplies the rare,
+   discriminative vocabulary SIRA rewards). Flatten the sketch to its *values* only
+   (`domain_vocab`, `operations`, `inputs`, `outputs`, `purpose`, `section_sketch`, `tags`)
+   — never JSON keys or punctuation. Write the request body to a temp file and POST it:
+
+   ```bash
+   # body.json  →  { "tenant":"local",
+   #                 "wish":"<description + formulations + flattened sketch, space-joined>",
+   #                 "keywords":["1-5","evidence","terms"], "top_n":3 }
+   curl.exe -s --max-time 20 -X POST "$SKILLFED_ENDPOINT/search" \
+     -H "Content-Type: application/json" --data-binary "@body.json"
+   ```
+   Response per wish:
+   ```json
+   { "query_id":"q_…",
+     "candidates":[ { "skill_id":"…","name":"…","description":"…","score":0.27,
+       "trust":{"license":"MIT","license_class":"permissive","provenance":"verified","stars":null},
+       "source_url":"https://…" } ],
+     "confidence":0.59, "recommendation":"…" }
+   ```
+   Keep each wish's `query_id` (needed for selection reporting). Empty `candidates` →
+   demand case. Run the wishes in turn (≤10; each is <300 ms) — or issue them in parallel.
+
+3. **Drop already-installed skills.** Before showing matches, `Glob`
+   `~/.claude/skills/*/SKILL.md` and `./.claude/skills/*/SKILL.md`, read each skill's
+   frontmatter `name`, and remove any candidate whose name matches (normalize: lowercase,
+   non-alphanumerics → `-`). Don't re-recommend something the user already has.
+
+### Selection (your job — precision)
+
+4. **Agentic selection, per wish.** Each `/search` returns ≤k recall candidates; *you*
+   decide. For each wish: pick the single best candidate, or reject all. A high score
+   is not approval — judge fit against the actual need.
+5. **Surface trust BEFORE approval.** Show the user a wish→match table with each
+   candidate's `license_class` (permissive / copyleft / proprietary / review),
+   `provenance` (verified / unverified), `stars`, `source_url`, and a ⚠ for any
+   `security_flags`. Prefer permissive + verified; call out review/unverified ones.
+   **Never install without explicit user approval.**
+
+### Hop 2 — local resolution (local-first)
+
+6. For each approved match, check whether it's already installed at
+   `.claude/skills/<id>/` (existence check — that *is* "local search"). If present,
+   use the local copy as-is (local-first rule; a drifted local copy is personalization,
+   not corruption). If absent, fetch the bundle with `curl` (`/fetch`):
+   ```bash
+   # body.json  →  { "tenant":"local", "skill_id":"<skill_id>" }
+   curl.exe -s --max-time 20 -X POST "$SKILLFED_ENDPOINT/fetch" \
+     -H "Content-Type: application/json" --data-binary "@body.json"
+   # → { "skill_id","name","license","source_url", "body":"<full SKILL.md content>" }
+   #   (an in-house bundle may instead return "files":{ "SKILL.md":…, … } — handle both)
+   ```
+   Write the returned `body` (or each `files` entry) to `.claude/skills/<id>/SKILL.md`
+   and record a `.federation.json` manifest (`skill_id`, `installed_at`, `source_url`/
+   `license` for OSS). Surface attribution at install.
+7. **Use or revise.** Run the installed skill. If it needs local adaptation for this
+   task, stage the change as a LOCAL update on the installed copy (drift) — never push
+   local edits back. A general improvement that isn't tenant-specific is a FEDERATED
+   suggestion instead. (Full reflection/suggestion chain is a later task; keep it light.)
+
+### Report outcomes — two complementary reports
+
+8. For every wish that **had candidates**, report the selection with `curl`
+   (`/report_selection`, per wish, with its `query_id`). `chosen` must be a **non-empty
+   string** — the selected id, or the literal `"None"` if you rejected every candidate:
+   ```bash
+   # body.json  →  { "tenant":"local", "query_id":"<query_id>",
+   #                 "chosen":"<id-or-'None'>", "rejected":["<id>","…"] }
+   curl.exe -s --max-time 20 -X POST "$SKILLFED_ENDPOINT/report_selection" \
+     -H "Content-Type: application/json" --data-binary "@body.json"
+   ```
+   `"chosen":"None"` records that the shown candidates were all wrong — a retrieval-quality
+   signal (not a substitute for the demand pointer below).
+9. For every wish that ended with **no skill installed** — search came back **empty**, OR you
+   **rejected every candidate** — record a demand pointer with `curl` (`/report_demand`).
+   `wish` is REQUIRED (the wish string you searched). Build the `sketch` **string** exactly per
+   **[demand-sketch.md](demand-sketch.md)** — a `"<query_id>: <minified-json>"` build spec
+   (it is a STRING, not an object; the endpoint's `sketch` field is a string):
+   ```bash
+   # body.json  →  { "tenant":"local",
+   #   "wish":"<the description + formulations + flattened sketch you searched>",
+   #   "sketch":"<query_id>: {\"purpose\":\"…\",\"inputs\":[…],\"outputs\":[…],\"operations\":[…],\"domain_vocab\":[…],\"section_sketch\":\"…\",\"tags\":[…],\"source\":\"unmatched_wish|all_rejected\"}" }
+   curl.exe -s --max-time 20 -X POST "$SKILLFED_ENDPOINT/report_demand" \
+     -H "Content-Type: application/json" --data-binary "@body.json"
+   ```
+   The two reports are **complementary**, not conflated: `report_selection` labels retrieval
+   quality (these candidates were shown); `report_demand` captures the capability gap (what was
+   actually needed). On **all-rejected** send BOTH; on **empty** send only the demand pointer.
+
+## Don't
+
+- Don't put plan/brief/output text into any wish, keyword, sketch, or payload.
+- Don't install without user approval, or re-recommend an already-installed skill.
+- Don't author a demand sketch for a wish whose candidate you **accepted** (only on empty or all-rejected).
+- Don't send `sketch` as a JSON object or `chosen` as null/empty — both are strings (see step 8–9).
+- Don't treat candidates as authoritative — they're recall; you and the user decide.

skillfed-0.1.0/src/skillfed/payload/plan_nudge.json

@@ -0,0 +1 @@
+{"hookSpecificOutput":{"hookEventName":"PostToolUse","additionalContext":"A plan was just approved. Before executing it, run the **Skill Federation finder** (the skill-federation skill) to see whether vetted skills already exist:\n1. From the plan in your context, write a wish-list of UP TO 10 wishes — each a {name, description, keywords, formulations} for an ideal skill this plan would use (\"if every skill existed, which ≤10 would I reach for?\"), with 1–5 evidence keywords and ~4 vocabulary-varied paraphrases per wish. Do NOT send the plan anywhere — only the wishes cross.\n2. Search each wish with curl (POST $SKILLFED_ENDPOINT/search; default https://qurini-skill-federation.hf.space) and drop anything already in ~/.claude/skills or ./.claude/skills.\n3. Review the candidates per wish; select the best match or reject all; present matches with license/provenance/trust metadata and get the user's approval BEFORE installing anything (fetch via POST /fetch).\n4. Report two complementary outcomes: for a wish that had candidates → POST /report_selection with chosen = the picked id or the literal \"None\" if you rejected all; for a wish with NO skill installed (empty OR all-rejected) → POST /report_demand with the wish string + a sketch string built per demand-sketch.md.\nDo NOT skip the finder silently. If you judge that a skill search is unnecessary for this plan (e.g. bespoke work on your own codebase), state that explicitly and verbosely — list the capabilities you considered and why none needs an external skill — and ask the user to confirm before proceeding without a search."}}

skillfed-0.1.0/src/skillfed/payload/skillfed.md

@@ -0,0 +1,34 @@
+---
+description: Find vetted agent skills for a task via the Skill Federation wish-list finder
+---
+
+Run the **Skill Federation wish-list finder** (the `skill-federation` skill) for the
+task below. Follow that skill's flow exactly:
+
+1. Sketch the ideal skill(s), then write a wish-list of **up to 10 wishes**, each
+   `{name, description, keywords, formulations, sketch}`: a one-line `description` (display),
+   **1–5 evidence keywords**, **~4 vocabulary-varied paraphrases** in `formulations` (the
+   load-bearing recall field), and a structured `sketch` (`purpose / inputs / outputs /
+   operations / domain_vocab / section_sketch / tags`, per `demand-sketch.md`) — author the
+   sketch once; it powers the search and, on a miss, becomes the demand pointer. Abstract
+   capability only — **never put the task's raw content, data, or outputs into any field**
+   (constitution Principle IV).
+2. Search each wish with `curl` (POST `$SKILLFED_ENDPOINT/search`, default endpoint
+   `https://qurini-skill-federation.hf.space`): concatenate each wish's
+   description + formulations + the flattened `sketch` values into the `wish` string, send
+   `keywords` and `top_n`. No Python, no Node — just `curl` (use `curl.exe` on Windows).
+   Then drop any candidate whose name matches a skill already in `~/.claude/skills` or
+   `./.claude/skills`.
+3. Per wish, select the best candidate or reject all. Present matches with trust
+   metadata (license class, provenance, stars, source, ⚠ flags) and get approval
+   **before** installing anything.
+4. On approval, fetch with `curl` (POST `/fetch`) + install the returned `body`/`files` under
+   `.claude/skills/<id>/` (local-first: use an existing local copy if present). Then report two
+   complementary outcomes: for any wish that had candidates → `curl` POST `/report_selection`
+   with `chosen` = the picked id, or the literal `"None"` if you rejected all; for any wish with
+   **no skill installed** (empty OR all-rejected) → `curl` POST `/report_demand` with the `wish`
+   string + a `sketch` string built per `demand-sketch.md`.
+
+If the task below is empty, ask the user what capability they're looking for.
+
+Task to search for: $ARGUMENTS