Plugin Quick Start

Plugin

The Archcore plugin adds four slash commands, built-in agents, and write guardrails to Claude Code, Cursor, Codex CLI, and GitHub Copilot CLI.

Prerequisite (all hosts): install the Archcore CLI globally. That is one curl line on macOS/Linux and one PowerShell line on Windows. See the CLI install guide. The plugin calls archcore from your PATH in every supported host.

Then install the plugin (below). Two hosts need one more step: Cursor users register MCP from the docs/cursor.mcp.example.json template, and Copilot users wire the project with archcore init --agent copilot.

1. Install the plugin

claude plugin marketplace add archcore-ai/plugin
claude plugin install archcore@archcore-plugins

Or from within Claude Code:

/plugin marketplace add archcore-ai/plugin
/plugin install archcore@archcore-plugins

Requires Cursor 2.5+. Open Cursor → Plugins, paste https://github.com/archcore-ai/plugin into the Search or paste link field, and click Add Plugin. Cursor reads the repo’s marketplace.json and installs Archcore.

Then copy docs/cursor.mcp.example.json (from the plugin) into ~/.cursor/mcp.json (user-scoped) or .cursor/mcp.json (project-scoped):

{
  "mcpServers": {
    "archcore": {
      "type": "stdio",
      "command": "archcore",
      "args": ["mcp", "--project", "${workspaceFolder}"]
    }
  }
}

Keep the --project ${workspaceFolder} argument. Without it, every other Cursor window reads one project’s .archcore/.

Requires Codex CLI 0.117.0+.

codex plugin marketplace add archcore-ai/plugin
codex
# then run /plugins, open Archcore, and select Install plugin

MCP is auto-registered via the plugin’s .codex.mcp.json. Enable Codex’s hooks feature for full coverage, with codex --enable hooks or in ~/.codex/config.toml:

[features]
hooks = true

Before Codex 0.129.0 the key is spelled codex_hooks = true. Without the feature, commands, MCP tools, and agents work normally, but the write guard, code-alignment injection, and post-write checks won’t fire.

Two steps, both required:

copilot plugin install archcore-ai/plugin:plugins/archcore
archcore init --agent copilot --project "$PWD"

Step 2 is not optional. On Copilot the plugin ships no MCP server, so a project that skips it has no document tools at all. archcore init --agent copilot writes the project MCP entry, the hooks, and the usage hint.

Copilot CLI only. VS Code agent mode has no self-serve plugin install.

Restart your host so the session-start hook can run.

2. Verify

Open your project in a fresh conversation and type:

/archcore:

Autocomplete should list four commands: init, plan, document, and review. If it doesn’t, see plugin troubleshooting.

The session should also open with an Archcore recap of your documents and relations. On an empty repository it opens with a nudge to run /archcore:init.

3. Make your repo legible (optional)

If .archcore/ doesn’t exist yet, run:

/archcore:init

The command detects repo scale (small, medium, or large) and shape, composes a scale-appropriate seed, shows it in one preview, and creates it on a single confirm. Nothing is written before you confirm. The same confirm wires host configs, so CLI-only teammates get a working repository. It also offers to import existing CLAUDE.md, AGENTS.md, or .cursorrules. Run this once per project.

Already have an .archcore/ directory? Skip ahead to step 4.

4. Record your first decision

Use /archcore:document for a decision you’ve already made:

/archcore:document use PostgreSQL as our primary database

If .archcore/ doesn’t exist yet, the MCP server initializes it on the first call, so you do not run archcore init yourself.

The skill classifies the request as a settled decision, creates an ADR with rationale and consequences, then offers a follow-up cascade:

Standard chain (adr → rule → guide): if PostgreSQL becomes the mandated database, codify it as a rule and write the how-to guide.
Architecture chain (adr → spec → plan): if the decision needs formal specification and an implementation plan.

The ADR alone is a valid endpoint. Accept a cascade only if it fits, and each step pauses for your review.

Check the result:

ls .archcore/

You should see one or more linked documents, all validated.

5. See the context the agent now has

Ask the agent to change something under a path your new documents cover, for example src/db/. Before the edit runs, the plugin puts the rules, ADRs, and patterns tied to that path in front of it:

[Archcore Context] Before editing src/db/pool.ts:
- rule: Primary Database [db/postgresql.rule.md]
- adr: Use PostgreSQL [db/use-postgresql.adr.md]

This needs no command. It happens on every source-file edit.

6. Try a multi-step plan

For something bigger, use /archcore:plan:

/archcore:plan event-driven orders

The skill computes a route from your repository, announces it, then creates the documents that route names, with the relations wired between them. For a single new capability that is usually one spec and one plan. A request that changes no capability creates no document at all.

Name a path first to run it directly instead:

sdd: the full package, prd → spec → plan.
sources (mrd → brd → urd): market research and discovery.
iso (brs → strs → syrs → srs): the formal ISO 29148 links.
research: an investigation, producing one rnd.

For example: /archcore:plan iso payment gateway compliance.

7. Review before you merge

When the branch is ready:

/archcore:review

review compares the branch diff with .archcore/ in both directions and tells you which side is stale: the document or the code.

What you get

Four commands route to the right document type for you. See Skills for the full catalog.
Before any source-file edit, the CLI finds the relevant rules, ADRs, specs, and patterns and injects them into context.
Two built-in agents ship with the plugin: archcore-assistant for multi-document flows and archcore-auditor for reviews.
Guardrails block direct .archcore/*.md writes, validate every mutation, and flag cascade staleness.

Next steps

Plugin overview: what ships in the box.
Skills: outcome, examples, and flags for each of the four commands.
Document types: the vocabulary you’re using.