Getting Started — Plugin-Led

There are two ways to go from an empty workspace to a living map. This is the plugin-led one: you stay in the AI host you already use, the architect plugin interviews you into a system landscape with a board per system, and the code plugin fills each board from its repo. You describe; the plugins draw.

Prefer to draw the landscape yourself on the canvas? That's the other door — Getting Started — Hands-On. Both end in the same place.

The whole path fits in one picture:

It works solo — you wear both hats — or split across a team, with an explicit handoff in the middle:

Before you start

• A workspace in the portal — fresh is fine; every workspace ships with a Root Board
• Claude Code or Codex — the architect plugin doesn't run on Cursor yet
• Workspace admin permission (or an admin who can mint you an MCP access token)
• The repos you'll map, cloned locally

Note

Both plugins answer to short names like /login, so when they share a host, prefix them: /pmap-architect:login, /pmap-code:analyze. This page writes commands short.

Step 1: Connect the architect plugin

/plugin marketplace add provenmap/pmap-claude
/plugin install pmap-architect@provenmap   # then restart Claude Code

Run /login: the browser opens, you pick the workspace and a read_write scope, and we store the minted token for you — it never appears in the chat. The Architect Workbench → Connect covers admin-minted tokens and container-backed sessions.

Step 2: Set up the estate

One command:

/pmap-architect:setup-workspace

It asks whether you're mapping an estate that exists or founding something new, then how you want to tell the story — describe it in conversation, point it at folders of repos for a shallow inventory, or share architecture docs. Scanning only ever runs on folders you name.

Every system you mention gets a kind — has a repo, exists without one, third-party SaaS, or planned — so the landscape reflects your estate honestly instead of assuming everything is code you own. Then you get the plan: a sketch, a table, and one go-ahead.

Expand

On your go-ahead the plugin draws the system landscape on your Root Board, mints an app board for every repo-backed system, and either completes each repo binding with you in the session or hands the rest off as a checklist for the developers. As boards land you get View board links straight into the portal.

Expand

The full day-zero story — founding mode, graduation, resumable interviews — lives in The Architect Workbench.

Step 3: Fill each board from its repo

This is the handoff — or, solo, the hat-switch. The app boards are empty on purpose: their content comes from the code, not the interview.

In each repo, install the code plugin from the same marketplace (pmap-code@provenmap — Cursor works too for this one), then:

cd <the-repo>
/login       # browser: pick the app board minted for this repo
/analyze     # map the repo into a structured graph, locally
/sync        # push it onto the board

/analyze reasons inside your coding session — services, APIs, databases, queues — and needs no model provider. /sync pushes the result onto the board, and the landscape node for that system now opens into its real internals. (Credentials handed to you instead? /configure wires them manually.)

Expand

Repeat per repo — one binding maps one repo, so each board tracks exactly one codebase. Deeper layers, incremental re-runs, and every flag: the plugins guide.

Tip

If the architect sketched a target architecture before the repo connected, the first push doesn't erase it — analysis reconciles reality against the sketch, and every disagreement surfaces as an intent. The plan and the code argue in the open.

Step 4: Keep the loop running

From here the two plugins hand work back and forth:

• The architect authors what should change — /author-intent, /adopt-adr, or a PRD dropped into the session — and releases the drafts. (The Architect Workbench walks every workflow.)
• Developers pull released intents with the code plugin's /intents, implement with the intent's context in hand, and the work comes back verified, not just reported. (Intents covers the flow.)
• After code changes, /analyze → /sync again — only the diff moves, so the boards keep tracking reality.

Extras when you're ready

• Insights — /insights runs your workspace's insight skills in-session, no model provider needed. See Hands-On → Generate insights.
• Publish — share read-only board snapshots at a stable URL. See Publishing Boards.
• Chat — let the whole org ask the landscape questions in the portal. See Hands-On → Turn on Chat and Org-Level Intelligence.

You're done — checklist

• Connected the architect plugin (/login)
• Ran /setup-workspace — landscape drawn, app boards minted, bindings completed or handed off
• In each repo: code plugin /login → /analyze → /sync
• (Optional) Authored a first intent and pulled it with the code plugin's /intents

What's next