Install

The kit is written for Claude Code and installs as a plugin on 5 more hosts from the same repository. Hosts that read a rules file instead load it from a clone. On Claude Code it is two plugins — tagout, the issue → pull request lifecycle, and tagout-migrate, the .NET migration add-on, installed only to upgrade a legacy .NET application; on every host but Claude Code the manifest ships the lifecycle and the .NET migration add-on together. Every command below carries a copy button; the full capability table is on Platforms.

Plugin hosts

Claude Code

claude plugin marketplace add phmatray/tagout
claude plugin install tagout@tagout-marketplace
claude plugin install tagout-migrate@tagout-marketplace

Inside a session the same commands work as /plugin marketplace add and /plugin install.

The host the kit is written for — every gate, command and sub-agent dispatch is native here.

Codex

codex plugin marketplace add phmatray/tagout

Open /plugins, install Tagout, then review and trust its hooks in /hooks.

Codex has no Read tool, so the roseline gate never fires; the git write-gate and the auto-dev Stop gate do. Skills are invoked by name, not as slash commands.

GitHub Copilot CLI

copilot plugin marketplace add phmatray/tagout
copilot plugin install tagout@tagout-marketplace

Skills are namespaced by the plugin — /tagout:create-issue, and so on.

Copilot’s hook payloads differ from Claude Code’s, so no gate is wired; the /migrate… commands reach migrate-legacy by name.

Gemini CLI

gemini extensions install https://github.com/phmatray/tagout

AGENTS.md loads as always-on context, and /migrate and its siblings arrive as commands.

Gemini’s hook events are its own, so no gate is wired; everything else installs as an extension.

Antigravity CLI

agy plugin install https://github.com/phmatray/tagout

It reuses the Gemini extension; type a command such as /migrate-assess as a message.

Antigravity turns extension commands into skills you invoke from the chat.

pi

pi install git:github.com/phmatray/tagout

The skills load as a pi package; the issue → pull request skills work as they are.

pi loads no MCP servers from a package, so the migration pipeline, which needs RoselineMCP, is out of reach there.

Rule-file hosts

Clone the kit once — every rule file below routes its host to the skills in that clone:

git clone https://github.com/phmatray/tagout ~/.tagout

Cursor

mkdir -p .cursor/rules && cp ~/.tagout/.cursor/rules/tagout.mdc .cursor/rules/

The always-applied rule routes each request to a skill in the clone, which the agent reads and follows.

Windsurf

mkdir -p .windsurf/rules && cp ~/.tagout/.windsurf/rules/tagout.md .windsurf/rules/

An always-on rule, routing to the skills in the clone.

Cline

mkdir -p .clinerules && cp ~/.tagout/.clinerules/tagout.md .clinerules/

A project rule, routing to the skills in the clone.

Kiro

mkdir -p .kiro/steering && cp ~/.tagout/.kiro/steering/tagout.md .kiro/steering/

Copy it to ~/.kiro/steering/ instead to load it in every project.

A steering file included in every conversation, routing to the skills in the clone.

GitHub Copilot in the editor

mkdir -p .github && cat ~/.tagout/.github/copilot-instructions.md >> .github/copilot-instructions.md

Appending keeps any instructions your repository already has.

Repository instructions for Copilot Chat in VS Code, JetBrains and Visual Studio; the Copilot CLI installs as a plugin instead.

Zed, Amp, Jules, Junie, OpenCode

cat ~/.tagout/AGENTS.md >> AGENTS.md

Each of these reads an AGENTS.md at the project root; appending keeps yours.

The same routing text, read from your project’s own AGENTS.md.

MCP servers

The migration pipeline runs on RoselineMCP and consults AdrMcp; both start with dnx from the .NET 10 SDK. A plugin host starts them from the kit’s own manifest. On a rule-file host, add them to its MCP settings — most take this shape:

{
  "mcpServers": {
    "roseline": { "command": "dnx", "args": ["RoselineMCP", "--yes"] },
    "adr": {
      "command": "dnx", "args": ["AdrMcp", "--yes"],
      "env": { "DOTNET_hostBuilder__reloadConfigOnChange": "false" }
    }
  }
}

The env line matters on Linux: AdrMcp runs on the .NET Generic Host, which by default watches its whole working directory recursively to reload appsettings.json. Started from a home directory, that is one inotify watch per folder, enough to exhaust fs.inotify.max_user_watches.

Without RoselineMCP, /migrate stops at its phase-0 preflight and says why; the issue → pull request skills need neither server.

What the kit costs a session

Installing the kit adds a fixed amount to every session on Claude Code, in every repository — before any kit skill runs. Measured on 2026-11-01 (Claude Code 2.1.316, tagout and tagout-migrate 4.1.0, a 400k-context model), each profile captured twice with identical results:

Loaded at start	without the kit	`tagout`	`tagout` + `tagout-migrate`
Total	13.4k	14.2k (+0.8k)	14.8k (+1.4k)
Messages — the routing table `hooks/routing-context.sh` injects	10	834 (+824)	834 (+824)
MCP server instructions	0	0	543
Kit entries in the skill listing	—	12 skills, 2.6k	19 skills, 3.2k
Every other skill’s listing entry (61 skills)	9.8k	7.2k (−2.7k)	6.5k (−3.4k)
MCP tool definitions, deferred until used	—	—	13.3k (roseline 9.7k, adr 3.5k)

Read the last two rows together. Claude Code caps the skill listing, and the measuring host was already at the cap, so the kit’s 2.6k of entries cost almost nothing in total and shortened other skills’ descriptions by about as much — some to under 20 tokens. That is a cost in how reliably those skills trigger, not in tokens. On a host below the cap, expect the entries to add to the total instead. The deferred MCP definitions cost nothing until a roseline or adr tool is loaded.

What one run of a skill costs is a different measurement: skills/auto-dev/scripts/usage_report.py totals a run’s transcripts, sub-agents included, and token-economics.md explains where the spend goes (context re-read every turn, not output).

To measure your own host, capture /context in a scratch profile without the kit and in one with it, from a directory with no CLAUDE.md above it (memory files would land in both captures):

KIT=~/.tagout                            # the kit root: a clone, or the plugin's install directory
P=$(mktemp -d); Q=$(mktemp -d); cd "$(mktemp -d)"
CLAUDE_CONFIG_DIR="$P" claude            # log in once with /login, then quit; same for "$Q"
CLAUDE_CONFIG_DIR="$Q" claude plugin marketplace add phmatray/tagout
CLAUDE_CONFIG_DIR="$Q" claude plugin install tagout@tagout-marketplace
CLAUDE_CONFIG_DIR="$P" claude -p "/context" > without.md
CLAUDE_CONFIG_DIR="$Q" claude -p "/context" > with.md
python3 "$KIT/scripts/context-cost.py" --baseline without.md --with tagout=with.md

Uninstall

Claude Code — claude plugin uninstall tagout
Codex — remove it from the host’s own plugin list; its documentation names no command for it.
GitHub Copilot CLI — copilot plugin uninstall tagout
Gemini CLI — gemini extensions uninstall tagout
Antigravity CLI — remove it from the host’s own plugin list; its documentation names no command for it.
pi — pi uninstall git:github.com/phmatray/tagout
A rule-file host — delete the rule file you copied, and ~/.tagout once no project uses it.