Portable skills for Claude Code, Codex, OMP, and Pi, built from one shared workflow. Install Arsenal once, then add only the specialist skills you need.

Each runtime has its own adapter under plugins/arsenal/skills/arsenal/references/adapters/, so agent discovery, model resolution and resume syntax stay runtime-specific while the workflow stays shared. Pi uses its builtin scout, oracle and reviewer agents and needs no agent installation.

What's in the arsenal

| Plugin | What it does | You type | |--------|--------------|----------| | arsenal | One entry point: clarify, select and apply the skills the task needs. | /arsenal add OAuth login | | brief | The what & why. Interview → product spec + task list. | /brief add OAuth login | | propose | The how. Alternatives, tradeoffs, risks, plan. One page or a few, hard ceilings. | /propose OAuth token storage | | ship | The build. Implements a clear request or approved spec and reports verification. | /ship docs/brief/oauth-login/ | | issue | The 1am bug, logged so you can pick it up cold. | /issue log this bug | | next | Monday morning: what's open, what's next, exact resume command. | /next | | trace | Progress ledger that writes itself. A hook, not a habit. | nothing | | websearch | Evidence-backed web search via Exa. | /websearch <question> |

One entry point

Use /arsenal in Claude Code, $arsenal in Codex, or /arsenal-mode in OMP and Pi.

• Without a description: a short adaptive form clarifies the outcome and whether you want advice, a document or implementation.
• With a description: Arsenal reads the available context first and asks only route-changing questions.
• It selects an installed skill, reads its complete instructions and applies them.
• After each result it reassesses what remains, within your authorization.

| What is missing or requested | Route | |---|---| | Product decisions need a specification | brief | | A consequential technical choice needs resolution | propose | | Implementation is clear and authorized | ship | | External evidence | websearch | | GitHub issue memory | issue | | Unfinished work or activity history | next or trace | | A real phased roadmap | Arsenal's optional roadmap branch |

There is no complexity score and no mandatory brief → propose → ship sequence. A bug does not automatically create an issue; a small clear change goes straight to ship. A proposal still needs explicit acceptance. Advice-only requests never become implementation.

The specialist skills remain directly usable. Their procedures are not copied into Arsenal. Install each needed plugin separately: Arsenal does not bundle or silently install its dependencies. Missing skills are reported, with installation or an explicitly labeled fallback offered.

Work stays solo unless you approve delegation. No mandatory roadmap, HTML or new state file.

The loop closes by itself: brief records the Git base and work branch and offers one issue per task; ship branches from origin/<base>, commits and pushes each closed unit, shows you where to see the result, ends with the next command, proposes the PR when the spec is shipped and, after the merge, closes the issues and realigns base. Every authoring skill verifies an external fact (version, API, price, date, behaviour of a tool) through websearch before stating it. Each of these steps runs on a detected capability (git, gh, web search, a browser) and prints the manual equivalent when it is missing, so an older brief or a host without gh works unchanged.

Optional continuous Arsenal mode for OMP and Pi

Install dependencies in plugins/ship/runtime with Bun. For OMP, add the absolute extension.ts path to its extensions configuration and restart OMP. For Pi 0.84+, install the local package with pi install ./plugins/ship/runtime; it loads pi-extension.ts.

Use /arsenal-mode on to route every request through the Arsenal skill and /arsenal-mode off to return to native behavior. /arsenal-mode status shows the current state. The mode never changes the active tools, filesystem scope, shell access, network access, or native approval policy. Specialist skills remain directly available through each harness's native skill commands. OMP reserves /trace for its own dashboard; use /skill:trace for Arsenal's ledger.

The lineage

Plain names, old discipline. propose is the RFC tradition (RFC 1, 1969, Rust, Oxide) plus Nygard's one-page decision records. brief is the PRD tradition (Cagan) sized by the short-doc school (Google, Shape Up, Linear).

The classic failure is letting the what and the how bleed together. One checkable artifact per question - that's the whole point.

Why I built this

brief pins the what and why. propose settles the how. ship builds. The gates gave me a precision I never had; and when I just want to move, ship takes a one-line prompt. Discipline when the stakes call for it, out of the way when they don't.

Mirko

Quick install

Claude Code

# Inside Claude Code:
/plugin marketplace add mirkobozzetto/arsenal

# Install the whole pipeline:
/plugin install arsenal@arsenal
/plugin install brief@arsenal
/plugin install propose@arsenal
/plugin install ship@arsenal
/plugin install issue@arsenal
/plugin install next@arsenal
/plugin install trace@arsenal
/plugin install websearch@arsenal

# ...or just one:
/plugin install ship@arsenal

Then use the entry point or a specialist directly:

/arsenal
/arsenal implement the agreed OAuth login
/arsenal compare token storage approaches, do not implement
/arsenal create a phased roadmap for a meeting-notes app
/brief add OAuth login
/propose OAuth token storage
/ship docs/brief/oauth-login/
/next

Per-plugin setup, flags, and dependencies live in each plugin's README.

Pi

Install the complete Arsenal package from npm:

pi install npm:[email protected]

Or install the pinned GitHub release:

pi install git:github.com/mirkobozzetto/[email protected]

Start a fresh Pi session, then run /arsenal-mode on. The package also installs every Arsenal skill, available through Pi's native /skill:<name> commands. Use /arsenal-mode off for native Pi behavior.

OMP: local development

To use the current checkout without stale marketplace copies, run this from the repository root after reviewing any existing links in the destination:

mkdir -p "$HOME/.omp/agent/skills"
for skill in arsenal brief propose ship issue next trace websearch; do
  ln -sfn "$PWD/plugins/$skill/skills/$skill" "$HOME/.omp/agent/skills/$skill"
done

Start a new OMP session. /skill:arsenal loads the native skill; /arsenal uses the optional controller when the extension above is configured. The native ask tool provides the clarification form in interactive sessions. Other skills follow the same /skill:<name> syntax, including /skill:trace. Do not force-reinstall a marketplace plugin whose recorded install path is your source checkout: OMP may remove that path while replacing the installation.

Codex

# Add the repository marketplace:
codex plugin marketplace add https://github.com/mirkobozzetto/arsenal

# Install the plugins you need:
codex plugin add arsenal@arsenal
codex plugin add brief@arsenal
codex plugin add propose@arsenal
codex plugin add ship@arsenal
codex plugin add issue@arsenal
codex plugin add next@arsenal
codex plugin add trace@arsenal
codex plugin add websearch@arsenal

In Codex, invoke a skill with $arsenal, $brief, $propose, $ship, $next, or the corresponding skill name. In Claude Code, use the / forms shown above.

next and trace bundle lifecycle hooks for both runtimes. Codex asks you to review and trust those hooks before running them. ChatGPT does not run plugin hooks, so both skills remain available there on demand without automation.

Good to know

• Published as I actually use them - adapt to your setup.
• Web lookups go through Exa MCP; propose also taps GitNexus when present, greps when not.
• ship uses the smallest meaningful verification permitted by your project instructions and reports what was actually checked.
• Commits and pushes are not automatic. Request Git delivery explicitly; ship --commit requests progressive commits.
• issue needs an authenticated gh CLI.
• Other agents (pi, oh-my-pi, Cursor): copy plugins/<name>/skills/<name>/ into the agent's skill directory and wire its MCPs.
• Codex and Claude Code: both use the native plugin manifests included in each plugin folder.
• Companion: espresso, the token-economy side. arsenal is what you build with; espresso keeps it cheap.

License

MIT: see LICENSE.