# Install and manage

Installing copies the newest published version of a skill into a folder Claude Code reads. After that the copy is yours to move, switch off or remove, and `sync` keeps the team's side current.

## Installing

```sh
npx -y terum-skills@latest install <ref>
```

Install always installs the latest version. There is no pinning: a ref carrying `@<version>` is refused.

| Ref | Meaning |
| --- | --- |
| `deploy-check` | A skill in your configured team. An unambiguous id prefix works too. |
| `acme/deploy-check` | The same, naming the team. |
| `<owner>/<repo>/<skill>` | A skill in a GitHub repository. A machine that has joined nothing runs setup for it first; one bound to another repository refuses. |

Or install a whole list:

```sh
npx -y terum-skills@latest install member ajayw36
npx -y terum-skills@latest install project docs-site
```

`install member` installs the skills that person stands behind (their profile), not whatever happens to sit on their machines. `install project` installs every skill a [team project](https://www.terum.ai/docs/team-admin#profiles-and-team-projects) lists. Both ask for the destination once.

## Where the copy goes

An interactive install asks where to put the copy: Global (`~/.claude/skills`, or `%USERPROFILE%\.claude\skills` on Windows) or a project you registered, and nothing else. `--into global` or `--into <project root>` answers in advance. `install project` preselects the registered project whose `origin` matches the team project's repository.

::: figure install-flow
Install copies the newest version from the team clone into Global or a registered project and records it in the placements ledger.
:::

Install never registers a project, and an `--into` path you have not registered is refused. Registering is its own verb:

```sh
npx -y terum-skills@latest project add [path]
```

The folder's `.claude/skills` becomes a Library root, read by `ls --local`, `publish`, `eval` and the install question. No verb registers the folder you happen to be standing in. `project remove` forgets a registration and touches no files.

## What install asks and writes

**Tool grants.** A skill that requests `allowed-tools` lists them and asks you to approve. The answer is remembered per skill and grant set, so the same grants never ask twice and changed grants ask again.

**A folder already there.** Install asks before replacing it, and moves your copy to `.claude/old-skills/<name>` beside the skills root. Nothing scans or empties that folder; clean it up by hand.

**Your profile.** The skill is added to your profile without a question, as `publish` does. `profile --remove <skill>` takes it off.

On your machine, an install writes the version folder, a row in the placements ledger (`~/.terum/skills/config.json`), and the team's committed receipts for that version, so the copy shows its score offline. In the team repository it commits to your own people file: the install, and how many skill folders this machine holds. The ledger is the only authority for a path this tool may later remove.

A folder you already have, whose bytes match a published version, can be recorded without copying:

```sh
npx -y terum-skills@latest install --adopt ~/.claude/skills/deploy-check
```

Adopt refuses a folder that has been edited or sits under a different name. It still asks the tools question, and it does not add the skill to your profile.

## Removing a skill

```sh
npx -y terum-skills@latest uninstall-skill deploy-check
```

`uninstall-skill member <handle>` and `uninstall-skill project <name>` undo the bulk forms. A preview lists every folder that goes before you confirm. An unchanged copy is removed outright, because the team repository still holds those bytes. A copy you edited is moved to `~/.terum/skills/quarantine`, never deleted. Your profile is untouched.

`prune` is the only thing that permanently deletes quarantined items, after listing them and asking.

## Keeping current

```sh
npx -y terum-skills@latest sync
```

Every read is fetch-free, so a teammate's publish reaches you only when something fetches. `sync` fetches each team clone and hard resets it to `origin/main`. The fetch uploads nothing and places nothing: an installed copy stays at its version until you run `install` again. When a GitHub team's repository is gone, `sync` looks for where it went and offers to [follow it](https://www.terum.ai/docs/team-admin#leaving-or-moving-a-machine).

`sync --hook` is the same fetch, run by the optional Claude Code session-start hook. It skips a clone fetched within the last hour, and it also refreshes Terum's own bundled skills, edit-hook script and hook entry. See [Claude Code integration](https://www.terum.ai/docs/claude-code#the-session-start-hook).

`reconcile` matches Library folders that have no install record against the team, by bytes. An identical folder is offered as a recorded install, one that shares a name but differs is offered as a publish of the next version, and one with the right bytes under another name is reported. `reconcile --list` asks nothing, and reconcile runs by itself after `project add`.

## Managing folders

| Command | What it does |
| --- | --- |
| `skill move <path> --to <root>` | Moves the folder to another Library root. |
| `skill copy <path> --to <root>` | Copies it; the original stays. |
| `skill rename <path> --to <name>` | Renames the folder and its `name:` field. |
| `skill delete <path>` | Removes it after you type its name. |
| `skill fix <path>` | Applies the mechanical hygiene repairs. |
| `skill category <path> --to <name>` | Rewrites its category. |
| `skill enable <path>` / `skill disable <path>` | Switches it on or off for Claude Code on this machine. |

For move and copy, `--to` is `global` or a registered project root. The folder must sit directly under a Library `.claude/skills` directory, and symlinks are refused. Deleting an installed copy goes through uninstall; deleting a folder you never installed moves it to quarantine.

The on/off switch writes Claude Code's own `skillOverrides` setting and keeps no state of its own, so it always agrees with Claude Code's `/skills` menu. Nothing moves on disk. See [the per-machine switch](https://www.terum.ai/docs/claude-code#the-per-machine-switch).

## Finding things

| Command | Shows |
| --- | --- |
| `ls` | The team's members, then each shared skill with its author, category, installs and latest version. |
| `ls --local` | Your Library by root, including folders that could not be read as skills. |
| `ls member <handle>` / `ls project <name>` | What a member authored and installed, or what a project lists. |
| `search <term>` | Shared skills whose name, description or category contains the term. |
| `status` | This machine: CLI version, team, handle, clone state and roster size. |

These read local files and the clone and never fetch, so a listing can be behind the team. When the clone has not been fetched within the hour, they say so and suggest `sync`.
