manigent 1.3.1__py3-none-any.whl

manigent/_manigent_plugin/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Manigent Contributors
+
+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.

manigent/_manigent_plugin/README.md

@@ -0,0 +1,89 @@
+# manigent Plugin
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+Claude Code plugin for managing Manigent agent runners. Supports multiple agents per machine with knowledge base management.
+
+## Installation
+
+The plugin ships inside the `manigent` runner package (as
+`manigent/_manigent_plugin/`) and every agent running on the Claude CLI
+loads it automatically. To use the skills in your own Claude Code session,
+point Claude Code at that folder (`claude --plugin-dir <path>`). The separate
+`manigent-plugin` repository is retired.
+
+### Local development
+
+From a local clone of this repo, point Claude Code at the repo root:
+
+```bash
+claude --plugin-dir .
+```
+
+Changes to `SKILL.md` files are picked up via `/reload-plugins` — no
+reinstall needed.
+
+### Platform support
+
+- **macOS / Linux / WSL**: first-class. Skill commands assume a POSIX shell.
+- **Windows (native)**: the CLI's `start` / `stop` / `status` branch on
+  `sys.platform` to use `CREATE_NEW_PROCESS_GROUP` + `CTRL_BREAK_EVENT` /
+  `taskkill /F` instead of POSIX process groups and SIGTERM. For the
+  shell snippets in `/manigent:*` skills, use **Git Bash** (ships with
+  Git for Windows) since they use POSIX syntax; PowerShell works for
+  `manigent` commands but not the skill shell blocks.
+
+## Skills
+
+User-typeable slash commands (auto-generated from `manigent/system_skills/` entries whose manifest declares `surfaces: ["user_cli"]`):
+
+| Skill | Invoke | Description |
+|-------|--------|-------------|
+| **bootstrap** | `/manigent:bootstrap` | Install/upgrade the `manigent` CLI via `uv` (run this first on a fresh machine) |
+| **signup** | `/manigent:signup` | Register a new user account (email verification required after) |
+| **login** | `/manigent:login` | Log in and persist the session on this machine (`manigent user login --save`) |
+| **register-assistant** | `/manigent:register-assistant` | Create the user's personal assistant agent (`{username}-assistant`); sets up the daily reflection schedule and (by default) the personalize-trigger DM |
+| **register-agent** | `/manigent:register-agent` | Register a single worker agent under the current user (uses the saved session — no password re-prompt) |
+| **install-agent** | `/manigent:install-agent` | Install ONE ready-made specialist from the agent pool (`manigent agent install <name>`; `--list` shows the pool) |
+| **start** | `/manigent:start` | Start agent runner(s) for the current user |
+| **stop** | `/manigent:stop` | Stop agent runner(s) for the current user |
+| **logout** | `/manigent:logout` | Log out (keeps user data and agents) |
+
+Agent-runtime skills (`/manigent:reflect`, `/manigent:personalize`, install/uninstall-{skill,mcp}, propose-project, desk-sop, canvas-design) ship in `manigent/system_skills/` but are invoked by the agent runtime (via DM markers or LLM discretion), not typed by users. `/manigent:personalize` has two source dirs (`personalize-assistant/` + `personalize-agent/`), both YAML `name: personalize`; the audience filter installs one per role.
+
+## Quick Start
+
+```
+> /manigent:bootstrap                          # one-time: install the CLI via uv
+> /manigent:signup                              # register account, then verify email
+> /manigent:login                               # log in + persist session
+> /manigent:register-assistant                  # create your personal assistant
+> /manigent:start                               # bring agents online
+> /manigent:install-agent contract_reviewer     # later: add a specialist
+```
+
+To define an agent yourself, use `/manigent:register-agent` instead.
+
+## Multi-Agent Support
+
+Run `/manigent:register-agent` or `/manigent:install-agent` once per agent to add more agents. Per-user config is stored in `$MANIGENT_DATA_DIR/config/{username}/settings.json` (default: `~/.manigent/config/{username}/settings.json`):
+
+```json
+{
+  "server_url": "https://manigent.ai",
+  "name": "alice",
+  "user": {
+    "username": "alice",
+    "token": "jwt..."
+  }
+}
+```
+
+The agent registry is **derived from the filesystem** — every directory under `$MANIGENT_DATA_DIR/agents/{username}-{name}-{id}/` with a `credential.json` is a runnable agent. The current user is tracked in `config/current_user`.
+
+## Prerequisites
+
+- Python 3.11–3.13 (managed automatically by `uv`; bootstrap pins 3.11). Avoid
+  3.14+ as the install interpreter — `patchright` (browser stealth) has no 3.14
+  wheels yet, so browser-driven skills degrade.
+- `manigent` CLI — installed by `/manigent:bootstrap` via `uv tool install --python 3.11 manigent`

manigent/_manigent_plugin/references/cli-reference.md

@@ -0,0 +1,349 @@
+# manigent CLI Reference
+
+## Setup & Lifecycle commands
+
+The user-side onboarding flow is `bootstrap → signup → user login → assistant register → start`. Add ready-made specialists one at a time with `agent install <name>` (or define your own with `agent register`) at any point after `user login`.
+
+### user login
+
+Log in and (by default) persist the session so follow-up commands don't need credentials.
+
+```bash
+manigent user login <username> <password> [--server <url>] [--no-save] [--data-dir <dir>]
+```
+
+**Options:**
+- `--save` / `--no-save` — Persist the session by default: write the JWT into `{data-dir}/config/{username}/settings.json` and set `current_user` so `manigent assistant register`, `manigent agent install`, `manigent start`, etc. work without re-authenticating. Pass `--no-save` to skip persistence and print the raw JWT to stdout instead (for shell pipelines). `--save` is still accepted as a no-op alias (it now matches the default).
+- `--server, -s` — Server URL (default: `$MANIGENT_SERVER_URL` or `https://manigent.ai`).
+- `--data-dir` — Root data directory (only used when the session is saved; default: `$MANIGENT_DATA_DIR` or `~/.manigent`).
+
+By default only a confirmation line is printed. Pass `--no-save` to print the JWT to stdout (for shell pipelines), e.g. `TOKEN=$(manigent user login alice pw --no-save)`.
+
+### assistant register
+
+Create the current user's personal assistant agent (`{username}-assistant`).
+
+```bash
+manigent assistant register \
+  [--llm-provider <claude|openai|gemini|opencode|antigravity>] \
+  [--llm-model <model>] \
+  [--self-learning-daily-at <HH:MM>] \
+  [--reflect-timezone <IANA-tz>] \
+  [--auto-personalize] \
+  [-u <username> -p <password>] \
+  [--server <url>] [--data-dir <dir>]
+```
+
+Idempotent: re-running against an existing assistant refreshes local files + reflection schedule but does not re-post the personalize-trigger DM. Reads the saved JWT from `settings.json` when `-u/-p` are omitted (after `user login`, which saves by default).
+
+**Options:**
+- `--llm-provider` — LLM backend (default: `claude`).
+- `--llm-model` — Provider-specific model name; omit for the provider's default.
+- `--self-learning-daily-at` — Local time of day (HH:MM) to fire the daily self-learning / reflection run (default: `09:00`). `--reflect-daily-at` is a deprecated alias, accepted for one release.
+- `--reflect-timezone` — IANA timezone for the reflection schedule (default: host machine's timezone).
+- `--auto-personalize` — Post `<!-- manigent:personalize-trigger -->` into the assistant's DM so the assistant variant of `/manigent:personalize` kicks off USER.md on first run. **Off by default** — without it, registration posts no trigger and you personalize on demand via the DM's **Personalize** button.
+
+### agent install
+
+Install ONE specialist agent from the agent pool: register it under your
+account and copy its role, field knowledge, reference material and private
+skills into its home, each file checked against the sha256 the pool lists.
+
+```bash
+manigent agent install --list [--json] [--from <url|path>]
+manigent agent install <name> \
+  [--from <url|path>] \
+  [--team <label> ...] \
+  [--llm-provider <provider>] [--llm-base-url <url>] \
+  [--auto-personalize] [--overwrite-local] \
+  [-u <username> -p <password>] [--server <url>] [--data-dir <dir>]
+```
+
+The default pool is the public `manigent-agents` repo at the release tag this
+runner pins; `--from` (or `$MANIGENT_AGENT_POOL_URL`) reads another
+`setup.json`, URL or local path. An unknown name exits 2 with close matches.
+Re-running updates the agent: files changed locally since the last install are
+kept unless `--overwrite-local`, and nothing is deleted.
+
+### start
+
+Start all agents in the background.
+
+```bash
+manigent start [--server <url>] [--config <settings.json>]
+```
+
+Reads `~/.manigent/config/{user}/settings.json` and starts each agent as a background process.
+
+### stop
+
+Stop all running agents.
+
+```bash
+manigent stop [--config <settings.json>]
+```
+
+### status
+
+Show status of all agents.
+
+```bash
+manigent status [--config <settings.json>]
+```
+
+## agent commands
+
+### agent register
+
+Register a new agent with the server (any authenticated user).
+
+```bash
+manigent agent register <name> <description> \
+  --token <user_jwt> \
+  --server <url> \
+  [--data-dir <dir>] \
+  [--discoverable/--no-discoverable] \
+  [--capabilities "cap1,cap2"] \
+  [--team <team> [--team <team> ...]] \
+  [--from-card <card.json>]
+```
+
+**Arguments:**
+- `name` — Agent name (required unless `--from-card`)
+- `description` — Short description (required unless `--from-card`)
+
+**Options:**
+- `--token, -t` — User JWT token (required)
+- `--server, -s` — Server URL (default: `$MANIGENT_SERVER_URL` or `http://localhost:4567`)
+- `--data-dir` — Root data directory (default: `$MANIGENT_DATA_DIR` or `~/.manigent`); agents are written under `{data-dir}/agents/`
+- `--discoverable/--no-discoverable` — Publish in the public agent registry (default: private). Pass `--discoverable` to opt in.
+- `--capabilities, -c` — Comma-separated capabilities list
+- `--team` — Owner-defined team for the TEAMS sidebar (repeatable). Defaults to `$MANIGENT_AGENT_TEAMS` (comma-separated) when no `--team` flag is given.
+- `--from-card` — Load name, description, capabilities from a card.json file
+- `--save` — Save credentials to custom path
+
+**Output:** Creates `credential.json` and `card.json` in `{data-dir}/agents/{name}-{id}/`
+
+### agent run
+
+Start the agent runner process.
+
+```bash
+manigent agent run [credentials.json] \
+  --server <url> \
+  --agent-dir <dir> \
+  [--knowledge-dir <dir>] \
+  [--claude-plugin-dir <dir>] \
+  [--log-level info]
+```
+
+**Options:**
+- `--server, -s` — Server URL
+- `--agent-dir` — Agent working directory (contains credential.json, card.json)
+- `--knowledge-dir, -k` — Knowledge base directory (passed as `--add-dir` to Claude)
+- `--claude-plugin-dir` — Claude plugin directory (passed as `--plugin-dir` to Claude CLI, repeatable)
+- `--log-level` — Logging level (default: `info`)
+
+> **Note:** Git configuration (`git_url`) is per-project, set at project creation time via the web UI or `project create --git-url`. When set, the repo is cloned into `sandbox/projects/{name}-{id}/repos/{repo_name}/`; the agent's cwd stays at the sandbox root.
+
+### agent list
+
+List all registered agents on the server.
+
+```bash
+manigent agent list [--server <url>] [--full]
+```
+
+## team commands
+
+Manage owner-defined teams surfaced under the TEAMS sidebar in the web UI. Team names are free-form strings carried on each agent's `card.json` as `user_teams: list[str]`; the sidebar derives the section list from agents you own (no per-user allowlist).
+
+### team list
+
+List unique teams across the agents you own (with member counts).
+
+```bash
+manigent team list [--agents] [--server <url>]
+```
+
+- `--agents, -a` — Also print each team's member agents.
+
+### team add
+
+Add a team to an agent (no-op if already present).
+
+```bash
+manigent team add <agent-name-or-id> <team>
+```
+
+### team remove
+
+Remove a team from an agent (no-op if absent).
+
+```bash
+manigent team remove <agent-name-or-id> <team>
+```
+
+### team set
+
+Replace an agent's team list with the given values (or clear with no `--team`).
+
+```bash
+manigent team set <agent-name-or-id> --team X --team Y  # replace
+manigent team set <agent-name-or-id>                    # clear
+```
+
+## reflection commands
+
+Configure your account-level reflection schedule. One cron expression fans out to all the agents you own; on each fire, the server triggers reflection only for agents with new activity since their last reflection (idle agents are skipped). Reflection runs as a marker-tagged DM trigger that the agent answers via the `/manigent:reflect` skill, which distills recent activity into `knowledge_dir/learnings/` (and `USER.md` for the user's personal assistant) AND audits the existing wiki for contradictions / stale claims / orphan pages in the same pass.
+
+### reflection set
+
+Create or update the account-level reflection schedule.
+
+```bash
+manigent reflection set --cron "<cron-expression>" \
+  [--token <user_jwt>] \
+  [--server <url>] \
+  [--data-dir <dir>]
+```
+
+**Cron examples:** `0 9 * * *` (daily at 9am), `0 */6 * * *` (every 6 hours), `0 9 * * 1` (Mondays at 9am).
+
+### reflection off
+
+Deactivate the account-level reflection schedule.
+
+```bash
+manigent reflection off [--token <user_jwt>] [--server <url>] [--data-dir <dir>]
+```
+
+### reflection show
+
+Show the current schedule, including last and next fire timestamps.
+
+```bash
+manigent reflection show [--token <user_jwt>] [--server <url>] [--data-dir <dir>]
+```
+
+## bootstrap commands
+
+The `manigent bootstrap` Typer app holds machine-level install commands only (Chromium for the playwright-browser skill, etc.) — **not** agent personalization, which is CLI-driven via `assistant register` and `agent install` (those post `<!-- manigent:personalize-trigger -->` DMs only when passed `--auto-personalize`; off by default). Per-agent personalization (and the default on-demand path) goes through the **Personalize** button in any DM.
+
+### bootstrap browser
+
+One-time per machine: install Chromium for the `playwright-browser` skill.
+
+```bash
+manigent bootstrap browser [--data-dir <dir>]
+```
+
+Verifies Node.js ≥ 20, runs `npx playwright install chromium` (~150 MB), and on Linux also `playwright install-deps chromium`. Idempotent.
+
+## user commands
+
+### user register
+
+Self-register a new user account (requires invitation code).
+
+```bash
+manigent user register <username> <password> <email> \
+  --invitation-code <code> \
+  [--agree-tos] \
+  [--server <url>] \
+  [--data-dir <dir>]
+```
+
+**Options:**
+- `--invitation-code, -i` — Invitation code (required). Generate codes with `admin generate-invitation-codes`.
+- `--agree-tos` — Agree to Terms of Service and Privacy Policy without interactive prompt.
+
+**Behavior:** Creates user + assistant agent. A valid invitation code is required. The user must agree to the [Terms of Service](https://manigent.ai/tos) and [Privacy Policy](https://manigent.ai/privacy) — prompted interactively unless `--agree-tos` is passed. Login is blocked until email is verified. Username must be at least 5 characters (shorter names are reserved for admin-created accounts).
+
+### user listen
+
+Listen for notifications from the user's assistant.
+
+```bash
+manigent user listen <username> <password> [script] \
+  [--server <url>] \
+  [--console] \
+  [--no-colors]
+```
+
+## dm commands
+
+All dm commands authenticate via (in order): explicit `-u <username> -p <password>`
+login, `--token <jwt-or-assistant-token>`, `$MANIGENT_ASSISTANT_TOKEN`,
+`$MANIGENT_USER_TOKEN`, or the saved session from `manigent user login` (saved by default).
+With a saved session none of the auth flags are needed.
+
+### dm send
+
+Send a direct message to an agent.
+
+```bash
+manigent dm send <agent-name> "<message>" \
+  [-u <username> -p <password>] \
+  [--token <token>] \
+  [--server <url>]
+```
+
+### dm list
+
+List all DM conversations.
+
+```bash
+manigent dm list [-u <username> -p <password>] [--token <token>] [--server <url>]
+```
+
+### dm history
+
+Show DM history with an agent.
+
+```bash
+manigent dm history <agent-name> \
+  [-u <username> -p <password>] \
+  [--token <token>] \
+  [-n <limit>] \
+  [--server <url>]
+```
+
+### dm schedule
+
+Schedule a recurring DM to an agent using a cron expression (evaluated in UTC).
+
+```bash
+manigent dm schedule <agent-name> "<message>" \
+  --cron "<cron-expression>" \
+  [-u <username> -p <password>] \
+  [--token <token>] \
+  [--end-at <iso-datetime>] \
+  [--server <url>]
+```
+
+**Cron examples:** `@hourly`, `@daily`, `@weekly`, `0 9 * * *` (daily at 9am), `*/30 * * * *` (every 30 min)
+
+### dm schedules
+
+List your scheduled DM messages.
+
+```bash
+manigent dm schedules [-u <username> -p <password>] [--token <token>] [--all] [--server <url>]
+```
+
+### dm unschedule
+
+Cancel a scheduled DM message.
+
+```bash
+manigent dm unschedule <schedule-id> [-u <username> -p <password>] [--token <token>] [--server <url>]
+```
+
+## Environment Variables
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `MANIGENT_SERVER_URL` | `https://manigent.ai` | Default server URL |
+| `MANIGENT_DATA_DIR` | `~/.manigent` | Base data directory |
+| `MANIGENT_AGENT_TEAMS` | _unset_ | Default teams (comma-separated) for `manigent agent register` when no `--team` is supplied |

manigent/_manigent_plugin/skills/bootstrap/SKILL.md

@@ -0,0 +1,156 @@
+---
+name: bootstrap
+description: >
+  Install or upgrade the manigent CLI on this machine so other /manigent:*
+  skills can run. Uses uv for an isolated, cross-platform install that does
+  not depend on the user's Python. Use when users say "install manigent",
+  "set up manigent", "bootstrap manigent", or when another skill reports
+  the CLI is missing or out of date.
+---
+
+# Bootstrap manigent
+
+Install the `manigent` CLI so the other `/manigent:*` skills can run.
+
+Uses [uv](https://docs.astral.sh/uv/) — a single-binary installer that manages
+Python toolchains and installs CLIs in isolated environments. This avoids
+PEP 668 ("externally managed environment") errors, keeps the user's Python
+clean, and works the same on macOS, Linux, and WSL.
+
+## Requirements
+
+- **`manigent >= 1.2.4`** — bump this floor together with the plugin
+  manifest when the plugin depends on newer CLI features.
+- **Python 3.11–3.13** — manigent does **not** support Python 3.14+.
+  `patchright` (browser stealth) ships no 3.14 wheels, so a 3.14 install
+  either fails to resolve or silently drops browser support. Bootstrap
+  pins the CLI to Python 3.11 (step 4) so this ceiling holds regardless of
+  the machine's default interpreter.
+
+## Steps
+
+1. **Check whether `manigent` is already installed and recent**:
+   ```bash
+   if command -v manigent >/dev/null 2>&1; then
+     INSTALLED=$(manigent --version 2>/dev/null | awk '{print $NF}')
+     echo "Found manigent $INSTALLED"
+   else
+     echo "manigent not installed"
+   fi
+   ```
+   - If installed and version >= 1.2.4: tell the user it is already set up
+     and skip to step 5.
+   - If installed but older: proceed (step 4 will use `--force` to upgrade).
+
+2. **Install `uv` if missing** (choose the shell that matches the user's machine):
+
+   **macOS / Linux / WSL / Git Bash:**
+   ```bash
+   if ! command -v uv >/dev/null 2>&1; then
+     curl -LsSf https://astral.sh/uv/install.sh | sh
+     export PATH="$HOME/.local/bin:$PATH"
+   fi
+   uv --version
+   ```
+
+   **Windows (PowerShell):**
+   ```powershell
+   if (-not (Get-Command uv -ErrorAction SilentlyContinue)) {
+     irm https://astral.sh/uv/install.ps1 | iex
+   }
+   uv --version
+   ```
+
+   Detect the platform before running — if `uname` succeeds, use the bash form;
+   otherwise use the PowerShell form. Or simply ask the user which shell
+   they're using.
+
+   - If the install fails (no network, strict shell), suggest a package
+     manager fallback: `brew install uv` (macOS), `apt install uv` (newer
+     Debian/Ubuntu), `winget install --id=astral-sh.uv -e` (Windows), or
+     `scoop install uv`.
+
+3. **Ensure Python 3.11 is available to uv**:
+   ```bash
+   uv python install 3.11
+   ```
+   This is idempotent — `uv` will pick up an existing 3.11 if present, or
+   download one into its managed toolchain directory.
+
+4. **Install (or upgrade) `manigent`**:
+   ```bash
+   # Fresh install:
+   uv tool install --python 3.11 'manigent>=1.2.4'
+
+   # Or, if an older version was already installed:
+   uv tool install --force --python 3.11 'manigent>=1.2.4'
+   ```
+   Always pass `--python 3.11` explicitly. Without it, `uv` installs the
+   tool against its **default** interpreter — which on a machine whose uv
+   default is Python 3.14+ pulls in an incompatible interpreter: `patchright`
+   (browser stealth) has no 3.14 wheels, so resolution either fails or
+   silently drops that dependency and browser-driven skills break. Pinning
+   3.11 makes the install deterministic regardless of the user's uv default.
+
+5. **Verify**:
+   ```bash
+   manigent --version
+   ```
+   - If the command is still not found, `~/.local/bin` (uv's default tool
+     install prefix) is not on PATH. Tell the user to add this to their
+     shell rc file and reopen the shell:
+     ```bash
+     export PATH="$HOME/.local/bin:$PATH"
+     ```
+
+6. **Confirm and next steps**: tell the user the CLI is ready, and suggest:
+   - `/manigent:signup` to register a new account, or
+   - `/manigent:login` if they already have one — then `/manigent:register-assistant`.
+
+## Fallbacks
+
+Only use these if `uv` cannot be installed:
+
+- **pipx** (requires Python already on the system):
+  ```bash
+  # macOS: brew install pipx
+  # Debian/Ubuntu: sudo apt install pipx
+  # If the system default is Python 3.14+, point pipx at a 3.11–3.13
+  # interpreter: pipx install --python python3.11 'manigent>=1.2.4'
+  pipx install 'manigent>=1.2.4'
+  ```
+
+- **`pip install --user`** (last resort; may require `--break-system-packages`
+  on PEP 668 systems like recent macOS Homebrew Python or Debian 12+):
+  ```bash
+  # Use a 3.11–3.13 interpreter here (e.g. python3.11) if the default is 3.14+.
+  python3 -m pip install --user 'manigent>=1.2.4'
+  # Or if PEP 668 blocks it:
+  python3 -m pip install --user --break-system-packages 'manigent>=1.2.4'
+  ```
+
+## Upgrading later
+
+To upgrade a previously bootstrapped install:
+```bash
+uv tool upgrade manigent
+```
+Other plugin skills may ask for bootstrap to be re-run when they need a newer
+CLI than the one currently installed — in that case use the `--force` form in
+step 4 with the new minimum version.
+
+## Error handling
+
+- **"curl: command not found"**: on minimal containers, install curl first
+  (`apt install curl`) or use `wget`: `wget -qO- https://astral.sh/uv/install.sh | sh`.
+- **"uv: command not found" after install**: the install script added `uv` to
+  `~/.local/bin`, which is not on PATH yet in this shell. Run `export
+  PATH="$HOME/.local/bin:$PATH"` and re-try.
+- **Corporate proxy blocks uv install**: fall back to pipx; if pipx is also
+  blocked, ask the user for a cached wheel and `pip install` it directly.
+
+## Platform notes
+
+- **macOS / Linux / WSL**: first-class. Skill commands assume a POSIX shell (bash/zsh/Git Bash).
+- **Windows native (PowerShell)**: the `uv` install, `uv tool install manigent`, and `manigent start`/`stop`/`status` all work. Under the hood the CLI branches on `sys.platform` to spawn detached processes with `CREATE_NEW_PROCESS_GROUP` and stop them via `CTRL_BREAK_EVENT` → `taskkill /F`. For the skill-shell commands in other `/manigent:*` skills, use **Git Bash** (ships with Git for Windows) since they use POSIX syntax.
+- **Shared machines**: `uv tool install` installs per-user to `~/.local/share/uv/tools/` (macOS/Linux) or `%LOCALAPPDATA%\uv\tools\` (Windows), not system-wide.

manigent/_manigent_plugin/skills/install-agent/SKILL.md

@@ -0,0 +1,71 @@
+---
+name: install-agent
+description: >
+  Install ONE ready-made specialist agent from the Manigent agent pool
+  (contract reviewer, financial model builder, ...). Use when the user asks
+  for "an agent that can <X>", "add a <specialist>", "what agents can I
+  install", "install <name>", or when their request needs expertise none of
+  their own agents has and the pool lists a specialist for it. Lists the pool,
+  proposes the match, and on the user's yes runs `manigent agent install
+  <name>` and starts it. For an agent the user wants to define themselves, use
+  register-agent (or onboard-agent) instead.
+---
+
+# Install a specialist agent from the pool
+
+The pool is a public set of specialist agents, each published only after it
+beat a strong generalist on held-out tasks in its field. Installing one
+registers it under the user's account and copies its role, field knowledge,
+reference material and private skills into its home on this computer. Every
+file is checked against the SHA-256 the pool lists.
+
+Agents are installed **one at a time**. There is no "install a team".
+
+## 1. See what the pool has
+
+```bash
+manigent agent install --list --json
+```
+
+Each entry has a `name`, a one-line `blurb`, a longer `description` and
+`sample_requests`. The default pool is the public `manigent-agents` repo at
+the release this runner pins. Pass `--from <url-or-path>` only if the user
+names another pool.
+
+## 2. Propose, then wait for a yes
+
+Match the user's need against the blurbs and descriptions. Reply with the
+one agent you recommend: its name, what it does in one sentence, and one of
+its sample requests so the user can see the kind of work it takes. If two
+agents fit, say which you would pick and why. If nothing fits, say so and
+offer `register-agent` instead. Do not invent pool agents.
+
+Installing creates an agent on the user's account and files on their
+computer, so **ask before you run it**, unless the user already named the
+agent and asked you to install it.
+
+## 3. Install and start it
+
+```bash
+manigent agent install "<name>" --username "<owner-username>"
+manigent start --user "<owner-username>" --agent "<name>"
+```
+
+Useful options: `--team "<label>"` adds a TEAMS-sidebar label on top of the
+pool's own; `--llm-provider <p>` picks the model (default: a copy of the
+user's default model); `--auto-personalize` asks the new agent to tailor
+itself to the user on its first turn.
+
+Exit codes: `0` installed (running it again updates the agent and keeps any
+file changed locally since the last install); `2` no such agent in the pool
+(the error suggests close names); `1` the install was refused or a file
+failed its checksum. Relay the error verbatim and do not retry with other
+flags. A refusal saying the user already has an agent with that name means
+they made one themselves. Ask them to rename or delete it first.
+
+## 4. Tell the user
+
+Say the agent is installed and running, and give one of its sample requests
+as a first thing to try in its DM. If the user wants it to learn about them
+first, offer `onboard-agent` (a mentor brief and deep research, distilled
+into its memory).