agentnet-cli 0.4.0__tar.gz → 0.4.1__tar.gz

{agentnet_cli-0.4.0 → agentnet_cli-0.4.1}/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## 0.4.1 - 2026-07-23
+
+- Add Claude-safe skill-fire steer wording and system-message support.
+- Include platform usage context in skill-fire discovery flows.
+- Refresh README placement for the agent bootstrap command.
+- Bump bundled Hermes, hosted skill, and OpenClaw integration metadata to match the CLI release.
+
 ## 0.4.0 - 2026-07-23
 
 - Add every-prompt skill-fire support for Cursor and Hermes.

{agentnet_cli-0.4.0 → agentnet_cli-0.4.1}/CLAUDE.md

@@ -8,7 +8,7 @@ CLI tool that detects AI coding agents on your system and connects them to the [
 - **Package manager:** uv
 - **CLI framework:** Typer + Rich
 - **HTTP client:** httpx
-- **Testing:** pytest (475 tests), pytest-cov
+- **Testing:** pytest (511 tests), pytest-cov
 - **CI:** GitHub Actions (lint + test matrix on 3.11/3.12/3.13)
 - **Publish:** PyPI via trusted publisher (tag `v*`)
 
@@ -45,13 +45,15 @@ uv run agentnet --help           # Run locally
 - **OpenClaw Plugin:** `agentnet connect openclaw` delegates to `openclaw plugins install` + `openclaw plugins uninstall` instead of writing files directly. The plugin at `openclaw-plugin/` is a native OpenClaw plugin with `openclaw.plugin.json` manifest, publishable to ClawHub.
 - **Plugin hint:** The CLI emits a `<claude-code-hint>` tag on stderr when `CLAUDECODE=1` is set, prompting Claude Code users to install the plugin.
 - **Auto-update on the hook flow:** `maybe_auto_update()` (rate-limited 24h via manifest `last_update_check_at`, gated by `AGENTNET_AUTO_UPDATE`, PyPI version check, background installer upgrade + stale-integration refresh) runs on every non-hook `agentnet` command via the Typer `@app.callback()`. The **hook** commands (`{skill,cursor,hermes}-hook`) are excluded there (`_HOOK_COMMANDS`) so `--pre`/`--peek`/`--post` never block a tool call; the update runs **once per turn from the detached `--fetch` worker** (`skillfire.run_fetch`), off the agent's critical path.
-- **Skill-fire architecture — `tools/skillfire/` (ports & adapters):** the every-prompt skill-fire pipeline shared by all three harnesses lives in `tools/skillfire/`, split by responsibility — `config.py` (constants/credentials), `session.py` (event/cache/atomic-claim primitives), `candidates.py` (skills.sh discovery), `classifier.py` (the three backend gate runners), `render.py` (**pure**, zero I/O — the fenced user-facing list), `content.py` (`npx skills use` fetch, owns that `subprocess` call site so a test patching it can't affect the classifier's or candidate-discovery's), `broker.py` (brokered-A2A fallback), `worker.py` (orchestrates discovery → classify → render → content/broker → cache, plus `spawn_worker`), `steer.py` (steer-text + the `check_steer`/`check_fallback` decisions). `tools/skillfire/__init__.py` is **the port** — the only surface the three adapters (`tools/claude_hook.py`, `tools/cursor_hook.py`, `tools/hermes_hook.py`) may import: `spawn_worker(session, prompt, *, limit, timeout, classifier)` (launch the detached worker, spawn-claim + stale-cleanup + `Popen` in one call), `check_steer(session)` (mid-run hard-nudge text or `None`), `check_fallback(session, *, timeout)` (turn-end fallback text or `None`), `run_fetch` (the CLI-invoked worker entrypoint), plus the `SUBAGENT_ENV`/`AGENTNET_SENTINEL` constants. Internals are free to reshuffle without touching an adapter or `main.py`, since none of them reach past the port. Tests mirror the module split 1:1 under `tests/skillfire/`.
-- **Every-prompt skill hook (Claude Code):** `agentnet enable-skill-fire` (and `connect claude`) install three hooks in `~/.claude/settings.json` (also bundled in the plugin's `hooks/hooks.json`), dispatched to `tools/claude_hook.py`. `UserPromptSubmit` → `agentnet skill-hook --pre` calls `skillfire.spawn_worker(..., classifier="claude")` and returns immediately (0 latency). The worker discovers **installable skill candidates** (`discover_skills` → skills.sh, each carrying a `<repo>@<slug>`) + runs a cheap no-tool `claude -p` **classifier** (Haiku) as the reliable relevance **gate** (a bare yes/no gate isn't — the model just answers). Two-phase so the outcome reaches the hooks fast: **Phase 1** caches the **recommendation list** (relevant skills by name + why + skills.sh link) the moment the gate opens (~12s); **Phase 2** *appends* the top match fetched via `npx skills use <repo>@<slug>` (which downloads the skill — SKILL.md + references — to a temp dir; single-file skills are materialized to a temp `SKILL.md`) as a **concise header (name + description) + the on-disk path**, not a full SKILL.md dump. The injected outcome is thus the list *then* "Reading the top match and applying it." + that block — the agent surfaces the list and reads/applies the methodology from disk, which is what makes it *act* on the skill rather than just mention it. No files are written to the repo. If content is unavailable (no `npx`/all fetches miss), Phase 2 falls back — behind the same open gate — to the live **Skills Agent** over **brokered A2A**: `PlatformClient.use_agent(agent_id="agentnet-skills-agent", task=…)` with the user's `setup` identity; the platform relays A2A and returns `{status:"settled", agent_response}` in one call. **No skills-agent token is ever held client-side.** Only a `settled` response is used. Injection is layered: `PostToolUse` → `agentnet skill-hook --peek` calls `skillfire.check_steer` to force-steer the agent **mid-flight** once the outcome is ready (`{"decision":"block","reason":…}`); `Stop` → `agentnet skill-hook --post` calls `skillfire.check_fallback`, the guaranteed fallback (`{"decision":"block", …additionalContext}`) for no-tool answers. Because the hooks are registered in **both** `settings.json` (via `connect`/`enable-skill-fire`) and the plugin's `hooks.json`, Claude Code may run each twice in parallel — so idempotence is enforced with **atomic `O_EXCL` once-claims** inside `session.py`: a per-`(session,prompt)` **spawn marker** so duplicate `--pre` hooks spawn exactly one worker (not 2× classifier cost), and a per-prompt **emit marker** shared by peek + post so exactly one steer fires (and a re-fired `Stop` no-ops). The cache carries a **`final`** flag: Phase 1 writes `final:false` (the list names skills but has no methodology), Phase 2 writes `final:true` once content is attached — or promotes the list to `final` when no content is reachable. **A mid-run steer only fires on a `final` outcome**, so it can't burn its one shot on a list the agent has nothing to apply from; the `Stop`/fallback surface takes a non-final list as a last resort. Session-keyed JSON cache `$TMPDIR/agentnet-skill/<session>.json` (`{outcome, final}`) + sibling `.emitted`/`.<hash>.spawn` markers; `AGENTNET_SKILL_SUBAGENT=1` guards recursion. All best-effort — no token/binary/candidates/unreachable-platform/timeout injects nothing. `agent_id` overridable via `AGENTNET_SKILLS_AGENT_ID`/config. Implemented in `tools/skillfire/` + `tools/claude_hook.py` + `connectors/claude_search_hook.py`.
+- **Skill-fire architecture — `tools/skillfire/` (ports & adapters):** the every-prompt skill-fire pipeline shared by all three harnesses lives in `tools/skillfire/`, split by responsibility — `config.py` (constants/credentials), `session.py` (event/cache/atomic-claim primitives), `candidates.py` (skills.sh discovery), `classifier.py` (the three backend gate runners), `render.py` (**pure**, zero I/O — the fenced user-facing list), `content.py` (`npx skills use` fetch, owns that `subprocess` call site so a test patching it can't affect the classifier's or candidate-discovery's), `broker.py` (brokered-A2A fallback), `worker.py` (orchestrates discovery → classify → render → content/broker → cache, plus `spawn_worker`), `steer.py` (steer-text + the `check_steer`/`check_fallback` decisions). `tools/skillfire/__init__.py` is **the port** — the only surface the three adapters (`tools/claude_hook.py`, `tools/cursor_hook.py`, `tools/hermes_hook.py`) may import: `spawn_worker(session, prompt, *, limit, timeout, classifier)` (launch the detached worker, spawn-claim + stale-cleanup + `Popen` in one call), `check_steer(session)`/`check_fallback(session, *, timeout)` (the shared, wrapped decision — mid-run/fallback text or `None` — used by Cursor/Hermes), `check_steer_raw`/`check_fallback_raw` (same decision, bare outcome with no wrapper text, so a harness can build its own presentation — used by Claude, see below), `run_fetch` (the CLI-invoked worker entrypoint), plus the `SUBAGENT_ENV`/`AGENTNET_SENTINEL` constants. The `_raw` variants are purely additive — appended to `steer.py`, never touching `check_steer`/`check_fallback`'s own bodies — so Cursor/Hermes are byte-for-byte unaffected by anything Claude-specific. Internals are free to reshuffle without touching an adapter or `main.py`, since none of them reach past the port. Tests mirror the module split 1:1 under `tests/skillfire/`.
+- **Every-prompt skill hook (Claude Code):** `agentnet enable-skill-fire` (and `connect claude`) install three hooks in `~/.claude/settings.json` (also bundled in the plugin's `hooks/hooks.json`), dispatched to `tools/claude_hook.py`. `UserPromptSubmit` → `agentnet skill-hook --pre` calls `skillfire.spawn_worker(..., classifier="claude")` and returns immediately (0 latency). The worker discovers **installable skill candidates** (`discover_skills` → skills.sh, each carrying a `<repo>@<slug>`) + runs a cheap no-tool `claude -p` **classifier** (Haiku) as the reliable relevance **gate** (a bare yes/no gate isn't — the model just answers). Two-phase so the outcome reaches the hooks fast: **Phase 1** caches the **recommendation list** (relevant skills by name + why + skills.sh link) the moment the gate opens (~12s); **Phase 2** *appends* the top match fetched via `npx skills use <repo>@<slug>` (which downloads the skill — SKILL.md + references — to a temp dir; single-file skills are materialized to a temp `SKILL.md`) as a **concise header (name + description) + the on-disk path**, not a full SKILL.md dump. The injected outcome is thus the list *then* "Reading the top match and applying it." + that block — the agent surfaces the list and reads/applies the methodology from disk, which is what makes it *act* on the skill rather than just mention it. No files are written to the repo. If content is unavailable (no `npx`/all fetches miss), Phase 2 falls back — behind the same open gate — to the live **Skills Agent** over **brokered A2A**: `PlatformClient.use_agent(agent_id="agentnet-skills-agent", task=…)` with the user's `setup` identity; the platform relays A2A and returns `{status:"settled", agent_response}` in one call. **No skills-agent token is ever held client-side.** Only a `settled` response is used. Injection is layered: `PostToolUse` → `agentnet skill-hook --peek` calls `skillfire.check_steer_raw` (the bare outcome, no wrapper) to force-steer the agent **mid-flight** once the outcome is ready (`{"decision":"block","reason":…, "systemMessage":…}`); `Stop` → `agentnet skill-hook --post` calls `skillfire.check_fallback_raw`, the guaranteed fallback (`{"decision":"block", "systemMessage":…, …additionalContext}`) for no-tool answers. Claude builds its **own** plain-language wording in `claude_hook.py` rather than the shared `steer_reason`/`fold_context` Cursor/Hermes use (see below) — no STEP-numbered "reproduce this verbatim" scaffolding, and no claim that any section is hidden from the user. Reason: Claude Code prints the entire `reason`/`additionalContext` payload to the user's terminal (native CLI behavior), so the shared wording's `AGENT_ONLY` label ("do not show the user") is an observable lie there — live testing showed a session flag it as a probable prompt injection and refuse to comply. `systemMessage` (set on both events) is a separate, platform-guaranteed display channel — never passed to the model, shown to the user regardless of what the model does next — so the skill list's visibility no longer depends on model compliance the way `reason`/`additionalContext` do. Because the hooks are registered in **both** `settings.json` (via `connect`/`enable-skill-fire`) and the plugin's `hooks.json`, Claude Code may run each twice in parallel — so idempotence is enforced with **atomic `O_EXCL` once-claims** inside `session.py`: a per-`(session,prompt)` **spawn marker** so duplicate `--pre` hooks spawn exactly one worker (not 2× classifier cost), and a per-prompt **emit marker** shared by peek + post so exactly one steer fires (and a re-fired `Stop` no-ops). The cache carries a **`final`** flag: Phase 1 writes `final:false` (the list names skills but has no methodology), Phase 2 writes `final:true` once content is attached — or promotes the list to `final` when no content is reachable. **A mid-run steer only fires on a `final` outcome**, so it can't burn its one shot on a list the agent has nothing to apply from; the `Stop`/fallback surface takes a non-final list as a last resort. Session-keyed JSON cache `$TMPDIR/agentnet-skill/<session>.json` (`{outcome, final}`) + sibling `.emitted`/`.<hash>.spawn` markers; `AGENTNET_SKILL_SUBAGENT=1` guards recursion. All best-effort — no token/binary/candidates/unreachable-platform/timeout injects nothing. `agent_id` overridable via `AGENTNET_SKILLS_AGENT_ID`/config. Implemented in `tools/skillfire/` + `tools/claude_hook.py` + `connectors/claude_search_hook.py`.
 
 - **Every-prompt skill hook (Cursor):** `agentnet connect cursor` also installs three hooks in `~/.cursor/hooks.json` (`connectors/cursor_hook.py`) that call the *same* `skillfire` port as Claude — only the thin I/O adapter differs (`tools/cursor_hook.py`, command `agentnet cursor-hook --pre/--peek/--post`; session key is Cursor's `conversation_id`). `beforeSubmitPrompt` → `--pre` calls `spawn_worker(..., classifier="cursor")` and allows the prompt (`{"continue":true}` — this event can't inject). `preToolUse` → `--peek` is the **hard nudge**: Cursor's only forceful steer is a denied action, so `check_steer` denies the first tool call **once** (`{"permission":"deny","agent_message":…}`) once the outcome is ready, and the agent must read+apply the skill then retry; every later call is allowed. `stop` → `--post` calls `check_fallback`, the fallback for no-tool answers via `followup_message` (auto-submitted next turn); it's `[AgentNet]`-tagged so the re-fired `--pre` recognizes its own injection and won't loop. The relevance **gate runs on the user's own Cursor model** via `cursor-agent -p --mode ask --output-format text --trust` (`classify(backend="cursor")` in `tools/skillfire/classifier.py`). The backend-aware classifier tries the requested CLI first and falls back to the other (`claude -p` ↔ `cursor-agent -p`) so a machine with only one still gates; Cursor needs `cursor-agent login` (auth), and `AGENTNET_CURSOR_CLASSIFIER_MODEL` pins a cheaper/faster gate model than the default.
 
 - **Every-prompt skill hook (Hermes):** `agentnet connect hermes` also installs three **shell hooks** in `~/.hermes/config.yaml` (`connectors/hermes_hook.py`), calling the *same* `skillfire` port; only the I/O adapter differs (`tools/hermes_hook.py`, `agentnet hermes-hook --pre/--peek/--post`; session key is `session_id`, the prompt is `extra.user_message`). `pre_llm_call` → `--pre` calls `spawn_worker(..., classifier="hermes")` (Hermes' documented `UserPromptSubmit` equivalent; it *can* inject `{"context":…}` but the worker needs ~20s, so the steer lands later). `pre_tool_call` → `--peek` is the hard nudge: Hermes **natively accepts the Claude-Code `{"decision":"block","reason":…}` shape** (it normalizes to `{"action":"block","message":…}`) and returns the reason to the model as the tool's error, so it re-plans inline. `pre_verify` → `--post` fires when the agent edited code and is about to finish; `{"action":"continue","message":…}` appends a synthetic user turn (gated on `extra.attempt` since it re-fires per nudge, bounded by `agent.max_verify_nudges`). Gate backend `hermes` runs an **in-process `AIAgent`** on the user's own model via `gateway.run._resolve_gateway_model` + `_resolve_runtime_agent_kwargs` (no subprocess, no separate auth; `skip_memory=False` shares the user's memory/profile so the gate ranks per-user, while `disabled_toolsets` (incl. `memory`) + `max_iterations=1` keep it a one-shot classify), falling back to the CLI backends when not importable. Shell hooks need **consent** — install writes scoped entries to `~/.hermes/shell-hooks-allowlist.json` for our three commands only (narrower than global `hooks_auto_accept`), and registers the **absolute** binary path since `hermes hooks doctor` stats the command's first token. Verify headlessly with `hermes hooks list` / `doctor` / `test <event> --payload-file`.
 
+- **Platform call context & usage analytics:** the skill-fire pipeline attaches optional call context to its platform calls, but **the gate model rides only on post-classification records, never on the retrieval call.** `GET /skills/discover` (`marketplace/skills/discovery.py`) is candidate *retrieval* — it fires **before** the classifier runs, so which model/backend will gate is unknown there (and the backend can fall back), so it carries **only** `harness` (`claude`/`cursor`/`hermes`, the requested backend — still which IDE the user is in, unaffected by fallback) and `session_id`. The **post-gate** records — the brokered `POST /agents/{id}/use` (`marketplace/client.py::use_agent`, via `broker.negotiate_via_platform`) and the usage-telemetry `POST /skills/discover/feedback` (`broker.report_recommendation`) — additionally carry `classifier_model` and `model`, resolved for the **backend that *actually* ran** (`classify()` returns `(relevant, actual_backend)`; `worker.py` resolves the model from `actual_backend`, not the requested one). `classifier_model` comes from `classifier.resolve_classifier_model()`, a pure per-backend lookup done *without* invoking the classifier: the fixed `SUBAGENT_MODEL` constant for Claude, the `AGENTNET_CURSOR_CLASSIFIER_MODEL` env value for Cursor if pinned, `_resolve_gateway_model()` for Hermes. `model` is Hermes-only — identical to `classifier_model`, since Hermes classifies on the user's own model in-process; confirmed unobtainable for Claude/Cursor (no hooked event payload exposes the driving model, per Claude Code's own hook docs). Because discovery makes **no** model claim, its record can never *conflict* with the authoritative model on the feedback/broker record for the same recommendation. Every field is added only when resolvable — omitted, never sent as `null` or guessed — and the platform's routes ignore unrecognized query params/JSON keys by default, so this ships independently of the platform's own timeline. `broker.report_recommendation()` fires the feedback `POST` the moment the classifier gate opens (non-empty relevant list) — usage telemetry for "which skills get recommended," dispatched to a **daemon thread** so it never delays the phase-1 cache write, and **`.join()`-ed (bounded by `config.REPORT_JOIN_TIMEOUT`) right before the worker returns** so a fast-exiting process doesn't kill the thread before its HTTP call lands. Wrapped in the same try/except-everywhere pattern as every other platform call here, so a `404` (route not yet live) is silently absorbed exactly like a network failure would be. The feedback payload matches the platform's `SkillFeedbackRequest` exactly (`use_case`, `recommended:[{name,why,score}]` with `score` always a `str|None`, `harness`, `session_id`, `classifier_model`, `model`). Verified end-to-end (not just unit-tested) against a real local platform build: a genuine `uvicorn` server, real FastAPI/Pydantic validation, unmodified CLI code, only the DB session/auth resolution mocked.
+
 ## Testing Patterns
 
 - **CLI tests:** `typer.testing.CliRunner` + `fake_home` fixture (temp dir with patched `Path.home()`)

{agentnet_cli-0.4.0 → agentnet_cli-0.4.1}/GLOSSARY.md

@@ -1,6 +1,6 @@
 # AgentNet CLI Glossary
 
-Canonical **meaning vocabulary** for **agentnet-cli** — the tool that detects local AI coding agents and connects them to the Agent-net marketplace.
+Canonical **meaning vocabulary** for **agentnet-cli** -- the tool that detects local AI coding agents and connects them to the Agent-net marketplace.
 
 This is not an API index. Entries are the *ideas* the product talks about (including the verbs and nouns that give sense to important actions in the CLI). Prefer these words in docs, skills, MCP descriptions, UI copy, and comments.
 
@@ -11,17 +11,17 @@ This is not an API index. Entries are the *ideas* the product talks about (inclu
 | Form | Use for |
 |------|---------|
 | **Agent-net** | Product / brand in user-facing prose (`https://agentnet.market`) |
-| **AgentNet** | Compound product noun in titles and skill copy (“AgentNet CLI identity”) |
+| **AgentNet** | Compound product noun in titles and skill copy ("AgentNet CLI identity") |
 | **agentnet** | CLI binary, package name, env vars, MCP tool prefix, local dir (`~/.agentnet`) |
 | **agentnet-cli** | PyPI / repo package name |
 
 ---
 
-## A–Z glossary
+## A-Z glossary
 
 ### A2A (Agent-to-Agent)
 
-Inter-agent protocol relayed by the **platform**. When the CLI needs another agent’s help (e.g. Skills Agent), it uses **brokered A2A**: the user’s CLI credentials ask the platform to talk to that agent and return a **settled** session. The CLI never holds the remote agent’s token.
+Inter-agent protocol relayed by the **platform**. When the CLI needs another agent's help (e.g. Skills Agent), it uses **brokered A2A**: the user's CLI credentials ask the platform to talk to that agent and return a **settled** session. The CLI never holds the remote agent's token.
 
 ### Amount / max amount
 
@@ -29,7 +29,7 @@ Budget ceiling when **using** a marketplace agent. Discovery UX does not expose
 
 ### Apply
 
-Have the coding agent follow a skill’s methodology (read on-disk skill content and act), not merely mention the skill’s name.
+Have the coding agent follow a skill's methodology (read on-disk skill content and act), not merely mention the skill's name.
 
 ### Atomic write
 
@@ -37,7 +37,7 @@ Safe config/manifest save pattern: write a temp file, then replace. Prevents hal
 
 ### Agent (local / coding agent)
 
-An AI coding tool installed on the user’s machine that the CLI can **detect** and **connect** — Claude Code, Cursor, GitHub Copilot, VS Code, OpenAI Codex, Hermes, OpenClaw. Distinct from a **marketplace agent**.
+An AI coding tool installed on the user's machine that the CLI can **detect** and **connect** -- Claude Code, Cursor, GitHub Copilot, VS Code, OpenAI Codex, Hermes, OpenClaw. Distinct from a **marketplace agent**.
 
 ### Agent (marketplace / platform agent)
 
@@ -45,7 +45,7 @@ A registered entity on the Agent-net platform that offers capabilities (skills,
 
 ### Agent connector
 
-Per–local-agent adapter that can **detect**, **connect**, and **disconnect**. Injects MCP config, context/skill files, and permission rules — or installs a **native plugin**.
+Per-local-agent adapter that can **detect**, **connect**, and **disconnect**. Injects MCP config, context/skill files, and permission rules -- or installs a **native plugin**.
 
 ### Agent ID
 
@@ -53,7 +53,7 @@ Platform identifier for a marketplace or CLI-registered agent. Stored in local c
 
 ### Agent name / display name
 
-Internal slug for a local agent (`claude`, `cursor`, …) vs human label (“GitHub Copilot”, “VS Code”).
+Internal slug for a local agent (`claude`, `cursor`, ...) vs human label ("GitHub Copilot", "VS Code").
 
 ### AgentNet home (`~/.agentnet`)
 
@@ -91,7 +91,7 @@ List or page through a catalog without a free-text query (e.g. ClawHub browse).
 
 ### Brokered A2A
 
-See **A2A**. Pattern: CLI → platform → remote agent → **settled** response, under the user’s setup identity.
+See **A2A**. Pattern: CLI -> platform -> remote agent -> **settled** response, under the user's setup identity.
 
 ### Bundled
 
@@ -127,7 +127,7 @@ Cheap relevance check on candidates vs the user prompt. If the **gate** opens, t
 
 ### Claude Code plugin / native plugin
 
-Bundled plugin installed through Claude’s own marketplace/install path (skills, hooks, MCP), not only raw file writes.
+Bundled plugin installed through Claude's own marketplace/install path (skills, hooks, MCP), not only raw file writes.
 
 ### Cleanup / legacy
 
@@ -139,7 +139,7 @@ Agent record created during **setup** / **register** (default **visibility**: pr
 
 ### Compose / render / fold
 
-Turn ranked recommendations and fetched skill text into the final **outcome** string injected into the agent (list block + “applying top match” content).
+Turn ranked recommendations and fetched skill text into the final **outcome** string injected into the agent (list block + "applying top match" content).
 
 ### Concepts
 
@@ -147,7 +147,7 @@ Single-word cores extracted when **expanding** a use case (for fuzzy matching du
 
 ### Config root
 
-Local agent’s home config directory (e.g. `~/.claude`, `~/.cursor`) used for detect/connect.
+Local agent's home config directory (e.g. `~/.claude`, `~/.cursor`) used for detect/connect.
 
 ### Connect
 
@@ -159,7 +159,7 @@ Recorded wiring for one local agent: files created/modified, MCP entry, timestam
 
 ### Connector registry
 
-Map of local agent → connector implementation.
+Map of local agent -> connector implementation.
 
 ### Continue
 
@@ -200,7 +200,7 @@ Prefer unified **search** first; use discover senses to refine.
 
 ### Discovery (product idea)
 
-Surface existing agents/skills instead of reinventing. Guiding phrase: *“Google for agents.”*
+Surface existing agents/skills instead of reinventing. Guiding phrase: *"Google for agents."*
 
 ### Emit
 
@@ -220,7 +220,7 @@ Download or retrieve skill content / candidates (catalog search, `skills use`, p
 
 ### File injection / shims / templates
 
-Write skill/rule/agent markdown and MCP JSON/TOML/YAML into the local agent’s tree. Contrast with **native plugin** install.
+Write skill/rule/agent markdown and MCP JSON/TOML/YAML into the local agent's tree. Contrast with **native plugin** install.
 
 ### Filter / quality filter
 
@@ -232,11 +232,11 @@ Enable every-prompt skill hooks so discovery can run automatically on user promp
 
 ### Frontmatter
 
-YAML header inside a skill file (name, description, …) used when **summarizing** / **materializing** skill content.
+YAML header inside a skill file (name, description, ...) used when **summarizing** / **materializing** skill content.
 
 ### Get (detail)
 
-Fetch full profile for one agent (skills, pricing, trust) or full content for one skill — after search/discover.
+Fetch full profile for one agent (skills, pricing, trust) or full content for one skill -- after search/discover.
 
 ### Hermes (Nous)
 
@@ -244,7 +244,7 @@ Local agent with a **native in-process plugin** (no MCP subprocess).
 
 ### Hire
 
-Historical / future verb for paying to use a marketplace agent. **Not** part of current discovery copy. Prefer **present, don’t transact**.
+Historical / future verb for paying to use a marketplace agent. **Not** part of current discovery copy. Prefer **present, don't transact**.
 
 ### Hook / skill-hook
 
@@ -252,15 +252,15 @@ Lifecycle callbacks on Claude Code (prompt submit, after tools, stop) that disco
 
 ### Inject / injection
 
-Write Agent-net wiring or skill outcome into the local agent’s config or context.
+Write Agent-net wiring or skill outcome into the local agent's config or context.
 
 ### Inspect
 
-Ask for full detail on one already-found agent or skill. Follows Discover → Surface → Inspect.
+Ask for full detail on one already-found agent or skill. Follows Discover -> Surface -> Inspect.
 
 ### Install method
 
-How the CLI itself was installed (uv tool, pipx, npm, pip) — used to **upgrade** correctly.
+How the CLI itself was installed (uv tool, pipx, npm, pip) -- used to **upgrade** correctly.
 
 ### Installs (popularity)
 
@@ -280,7 +280,7 @@ Which family search returns: all, marketplace/listings, agents, skills, plugins.
 
 ### List
 
-Enumerate entities without a query (e.g. agents in the org) — contrast with **search** / **discover**.
+Enumerate entities without a query (e.g. agents in the org) -- contrast with **search** / **discover**.
 
 ### Listing
 
@@ -324,11 +324,11 @@ User or agent text sent when **using** or **continuing** a marketplace session.
 
 ### Native plugin
 
-Install via the agent’s own plugin system (Claude marketplace, OpenClaw plugins, Hermes plugins) rather than only merging MCP JSON.
+Install via the agent's own plugin system (Claude marketplace, OpenClaw plugins, Hermes plugins) rather than only merging MCP JSON.
 
 ### Negotiate
 
-Obtain skill help via the platform when local fetch fails — brokered call to the Skills Agent.
+Obtain skill help via the platform when local fetch fails -- brokered call to the Skills Agent.
 
 ### Outcome
 
@@ -336,7 +336,7 @@ Final text the skill-hook injects: recommendation list and/or top-match skill co
 
 ### Peek / pre / post
 
-Skill-hook phases: **pre** (on prompt — spawn worker), **peek** (mid-flight after tools — steer if ready), **post** (on stop — guaranteed fallback inject).
+Skill-hook phases: **pre** (on prompt -- spawn worker), **peek** (mid-flight after tools -- steer if ready), **post** (on stop -- guaranteed fallback inject).
 
 ### Permission / auto-approval
 
@@ -352,7 +352,7 @@ Backend API (production `https://app.agentnet.market`). Hub for discovery, auth,
 
 ### Platform URL / resolve / precedence
 
-How the CLI picks which backend to talk to: explicit URL → env URL → named env (dev/staging/prod) → saved config → production default.
+How the CLI picks which backend to talk to: explicit URL -> env URL -> named env (dev/staging/prod) -> saved config -> production default.
 
 ### Plugin
 
@@ -360,9 +360,9 @@ Package that extends a coding agent. In unified search, the plugins family route
 
 ### Poll secret / login id
 
-Opaque tokens for the browser login **poll** loop (not user-facing vocabulary beyond “waiting for sign-in”).
+Opaque tokens for the browser login **poll** loop (not user-facing vocabulary beyond "waiting for sign-in").
 
-### Present, don’t transact
+### Present, don't transact
 
 Discovery policy: show options and how to install/use them; never hire, pay, settle, or force a choice.
 
@@ -392,7 +392,7 @@ Local agent is **detected** but not yet **connected**.
 
 ### Recommendation
 
-Short list of relevant skills (name + why + link) shown when the gate opens — before or without full skill body dump.
+Short list of relevant skills (name + why + link) shown when the gate opens -- before or without full skill body dump.
 
 ### Record / remove (connection)
 
@@ -448,7 +448,7 @@ Reusable methodology package (often SKILL.md + references). Distinct from a live
 
 ### Skill discovery
 
-Pipeline: **expand** use case → search catalogs → **deduplicate** / **filter** → **rank** → return candidates.
+Pipeline: **expand** use case -> search catalogs -> **deduplicate** / **filter** -> **rank** -> return candidates.
 
 ### Skills Agent
 
@@ -464,7 +464,7 @@ Ranking signal: same skill appearing in more catalogs scores higher.
 
 ### Spawn / worker / detached
 
-Background process started on prompt submit to discover/classify without blocking the user’s latency path.
+Background process started on prompt submit to discover/classify without blocking the user's latency path.
 
 ### Stale (connection)
 
@@ -488,7 +488,7 @@ Reduce a full skill file to a concise header (name + description) plus on-disk p
 
 ### Surface (verb)
 
-Show a relevant match without forcing adoption. Discover → Surface → Inspect.
+Show a relevant match without forcing adoption. Discover -> Surface -> Inspect.
 
 ### Tags
 
@@ -504,7 +504,7 @@ Confirm credentials and inspect token metadata against the platform.
 
 ### Trust score
 
-Reputation signal on a marketplace agent profile — reason to **inspect** an agent.
+Reputation signal on a marketplace agent profile -- reason to **inspect** an agent.
 
 ### Update / upgrade / self-upgrade
 
@@ -512,7 +512,7 @@ Bring the CLI package to the latest release, then **refresh** connected integrat
 
 ### Use (an agent)
 
-Invoke a marketplace agent with a **task** (creates a **session**). Used internally for brokered A2A; not part of “present, don’t transact” discovery copy.
+Invoke a marketplace agent with a **task** (creates a **session**). Used internally for brokered A2A; not part of "present, don't transact" discovery copy.
 
 ### Use case
 
@@ -536,9 +536,9 @@ See **spawn**. Detached process that fetches candidates, classifies, and writes
 
 ---
 
-## Action vocabulary (from the CLI’s important behaviors)
+## Action vocabulary (from the CLI's important behaviors)
 
-Grouped meaning-words — use these instead of inventing synonyms:
+Grouped meaning-words -- use these instead of inventing synonyms:
 
 | Cluster | Words |
 |---------|--------|
@@ -570,7 +570,7 @@ Grouped meaning-words — use these instead of inventing synonyms:
 | Layer | Meaning |
 |-------|---------|
 | **cli** | User-facing commands; thin UX |
-| **connectors** | Per–local-agent install/uninstall |
+| **connectors** | Per-local-agent install/uninstall |
 | **marketplace** | Platform + catalog HTTP clients |
 | **tools** | MCP + Hermes tool surface |
 | **infra** | Config, paths, manifest, platform URL |
@@ -578,15 +578,15 @@ Grouped meaning-words — use these instead of inventing synonyms:
 
 ---
 
-## Ambiguous terms — preferred usage
+## Ambiguous terms -- preferred usage
 
 | Prefer | Avoid / clarify |
 |--------|-----------------|
-| **Local agent** vs **marketplace agent** | Bare “agent” when both appear in one sentence |
+| **Local agent** vs **marketplace agent** | Bare "agent" when both appear in one sentence |
 | **Search** first | Jumping straight to a single catalog |
-| **Listing** for marketplace products | Calling every result an “agent” |
-| **Skill** for installable methodology packages | Calling every plugin a “skill” |
-| **Connect** for wiring local tools | “Install Agent-net” when you mean connect |
+| **Listing** for marketplace products | Calling every result an "agent" |
+| **Skill** for installable methodology packages | Calling every plugin a "skill" |
+| **Connect** for wiring local tools | "Install Agent-net" when you mean connect |
 | **Present** matches | **Hire** / **settle** in discovery copy |
 | **Agent-net** in prose | Mixing AgentNet / agent-net randomly in the same paragraph |
 

agentnet_cli-0.4.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 TheAgent-net
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.