Install the Claude Code plugin

Dossier ships as one Claude Code plugin — the loop runs with the same primitives it’s built on (subagents, skills, hooks, MCP). Installing it gives an agency operator everything needed to onboard, serve, and audit a client’s knowledge base without bespoke setup. This guide installs it and verifies it’s live.

Prerequisites

Claude Code installed and authenticated.
A Dossier knowledge repo to serve. If you don’t have one yet, follow Run your first loop to provision one — or point the plugin at the DXA reference KB in the repository to try it.

Install

Add the Dossier marketplace.

The marketplace is git-hosted, so this needs no registry:
```
/plugin marketplace add twofoldtech-dakota/dossier
```
Install the plugin.
```
/plugin install dossier@dossier-marketplace
```
On enable, Claude Code prompts you for this client’s tenant config — see Tenant configuration below.

Verify it’s active.

Open the agent and skill pickers to confirm the Dossier team loaded — everything is namespaced to dossier, so it never collides with your other tools:

/agents          # lists dossier:knowledge-architect, dossier:extraction-engineer, …
/dossier:        # the skill picker — author-okf, ingest-client, verify-kb, …

Then check the MCP server connected:

/mcp             # dossier-okf should appear, scoped to your client's repo

To try the plugin from a clone without installing it into your global config, launch Claude Code pointed at the plugin directory:

claude --plugin-dir ./plugin/dossier

What the plugin gives you

One install delivers four things:

Component	What it does
6 agents	The expert team you run a client KB with: `knowledge-architect`, `ingestion-engineer`, `extraction-engineer`, `mcp-engineer`, `qa-reviewer`, `log-auditor`.
4 skills	The repeatable client procedures: `ingest-client`, `author-okf`, `scaffold-vertical`, `verify-kb`.
MCP server (`dossier-okf`)	A tenant-scoped GraphRAG server over one client’s OKF repo — `search_concepts`, `get_concept`, `get_related`, `list_concepts`, `kb_health`.
Audit hook	A `PostToolUse` hook that captures every mutating tool call to `journal/traces/` — the raw layer of the learning loop.

The agents and skills appear as dossier:extraction-engineer, /dossier:author-okf, and so on. The audit hook captures Edit, Write, MultiEdit, and Bash calls — the deterministic capture that later distills into curated decisions.

Tenant configuration

When you enable the plugin, Claude Code prompts for three values that scope the MCP server to one client. They are the isolation boundary — one server = one tenant = one OKF repo — and they map directly onto dossier-mcp’s CLI flags:

Prompt	Maps to	Meaning
Client OKF repo	`--repo`	Absolute path to this client’s OKF git repo. The only directory the server reads.
Client / tenant id	`--client`	Namespaces the silo; surfaced on every served fact.
Known external concept ids	`--known-external-ids`	Optional, comma-separated ids that live outside the repo (e.g. `knowledge-model`) so cross-references aren’t flagged as dangling. Never a read backdoor — nothing outside the configured repo is ever served.

To serve a different client, install the plugin under a second scope or run a second server pointed at that client’s repo. Two clients are never served from one server — the file boundary, not a query filter, is the silo.

The plugin’s MCP server resolves @dossier/mcp from npm. The packages aren’t published to a registry yet, so until they are, point the server’s command/args at a local build instead — the flags are identical:

{
  "mcpServers": {
    "dossier-okf": {
      "command": "node",
      "args": [
        "/abs/path/to/packages/mcp/dist/cli.js",
        "--repo",   "${user_config.okf_repo}",
        "--client", "${user_config.client_id}"
      ]
    }
  }
}

Publishing @dossier/mcp (and the CLIs) is the one remaining step to make npx-based install work out of the box.

Day-1 flow for a new client

Once installed, the plugin orchestrates the loop end to end:

Provision the tenant — dossier-runtime provision stands up the client’s siloed OKF repo. Optionally seed a vertical with /dossier:scaffold-vertical.
Ingest their sources — /dossier:ingest-client (or dossier-runtime run over a --source-dir) pulls sites and files into clean, provenance-stamped markdown.
Extract to OKF — /dossier:author-okf and the extraction-engineer turn that markdown into atomic concepts with typed edges.
Verify — /dossier:verify-kb and the qa-reviewer adversarially audit OKF compliance, atomicity, link integrity, and provenance before it ships.
Serve & query — the dossier-okf MCP server, pointed at the client’s repo, answers agent queries with explainable GraphRAG.

The metric is Time-to-Live-Wiki per client. The loop compounds from there: every decision the log-auditor records makes the next run smarter.

Troubleshooting

Run /mcp to see its status. The most common cause is the unpublished-package gap above: if npx -y @dossier/mcp can’t resolve, point the server at a local build (see the caution above). Confirm the build exists with node ./packages/mcp/dist/cli.js --help.

If kb_health reports dangling edges to ids you expect to be external (like knowledge-model), add them to Known external concept ids so they’re recognized as living outside this repo. This never widens what the server reads.

Confirm the plugin enabled with /plugin. Everything is namespaced — agents are dossier:*, skills are /dossier:*. If you’re testing a local checkout, make sure you launched with claude --plugin-dir ./plugin/dossier.

Run your first loop in 15 minutes — the loop, hands-on.
The dossier-runtime verb set — the full command reference.
What is Dossier? — the loop and the three faces, explained.