Flarepoint Plugin Plaza

The fp marketplace, hosted at SlashyIsTaken/fp-pluginplaza.

A plaza of small, behavioural Claude Code plugins. They come in two families, and both intervene only at the edges of a task — before it or after it, never mid-reasoning:

• Behavioral — surface and persist the AI's state, changing nothing about what it decides (fp-honesty, fp-bump, fp-recap).
• Influential — shape how the model approaches a task, but only by setting a prior at the task edge that you've consented to (fp-barbeque).

The invariant the whole plaza keeps: never steer the model mid-reason.

The whole plaza installs as one Claude Code marketplace. Every plugin carries the fp- prefix (for Flarepoint) and lives in its own directory under plugins/; they all share one substrate (shared/fpbase) so they look and behave the same way and reuse the same tested code.

Install

/plugin marketplace add SlashyIsTaken/fp-pluginplaza
/plugin install fp-honesty@flarepoint

The only requirement is node on your PATH. If node is missing, the plugins stay quiet instead of erroring.

Plugins

Behavioral: Surface, never steer

fp-honesty: see how much of an answer is grounded vs. guessed

Models state guesses and facts in the same confident tone. fp-honesty tags every load-bearing claim with its basis, so you can tell at a glance how much of an answer is actually grounded.

• Four levels: 🟢 verified · 🟡 inferred · 🟠 recalled · 🔴 guess. Each tag sits inline next to the claim it applies to, and the response ends with a one-line basis: tally.
• A backstop hook checks each verified tag against the tools the model actually used that turn, so the grade can't be inflated.
• Pure annotation. It reports how grounded a claim is and changes nothing else. It never adds caveats, hedging, or extra caution because of a tag.
• Modes: full (inline tags and a tally), footer (tally only), off. Control with /fp-honesty:mode.

fp-bump: size the version bump to the change, applied when you release

fp-bump keeps a project's version in step with the size of its changes. It separates two things most tools combine: sizing a change, which happens as you commit, and bumping the version, which happens once, when you release.

• Sizes each commit. When you commit, fp-bump asks the model to read the staged diff and rate it patch, minor, or major. This only records the rating; it does not change the version yet.
• Keeps a running level. Ratings add up and the largest one wins, so ten small commits still come to a single pending bump, not ten of them.
• Bumps once, at release. When you run /fp-bump:release (or say "cut a release"), the pending level becomes one version change and the ledger resets.
• Finds the version anywhere: package.json, pyproject.toml, Cargo.toml, VERSION, or version.txt.
• Modes: suggest (propose and confirm, the default), auto (apply directly), off. Control with /fp-bump:mode. It works on commits made through Claude Code.

fp-recap: resume a previous session, with the steps ahead laid out

fp-recap is about picking a session back up. The built-in summary is one-off prose that disappears; fp-recap saves a resume note that survives, so your next session opens with where you left off and what comes next.

• Captures where you left off. After each response, fp-recap reads the session's tool log and saves a short, structured note: the goal you set, the files changed, and the commands run.
• Lays out the steps ahead. It also captures the likely next moves, taken from what you said you'd do next, or your last unfinished request as the anchor to continue from.
• Resumes next time. At the first prompt of your next session in that project, the note is surfaced once, so you can carry on without re-explaining.
• Stays local. The note lives in the project's git-ignored personal store, as a readable file. Ask for it any time with /fp-recap:mode show.
• Modes: on (concise note, the default), verbose (more files and commands, plus files read), off. Control with /fp-recap:mode. It proposes the next steps and waits; it never starts work on its own.

Influential: Shape how a task is approached, at its edge

fp-barbeque: get grilled toward mutual understanding before code is written

Used to its fullest, AI writes code faster than you can absorb it — and code you can't reason about, debug, or defend is close to useless. fp-barbeque keeps you in the loop on the tasks where that matters: on exploratory work it has the model grill you toward mutual understanding before it builds, so the scope is yours to check or hold back and the result is yours to own.

• Fires on exploratory tasks. Refactors, design and architecture decisions, features with fuzzy scope, anything ambiguous. The model decides whether a task qualifies; trivial, mechanical, or already-specified work is built straight away.
• Grills toward your understanding. It surfaces the real forks and tradeoffs, states the scope explicitly, and prefers the option-dialog over open-ended questions — aiming for you to understand the approach well enough to debug and own it, not just for the model to feel confident.
• The model judges convergence. When understanding is mutual it recaps the agreed scope in one line and proceeds. The recap is the handshake; push back on it and it keeps grilling.
• An edge prior, not a gate. Its whole footprint is one prior set at the start of a task. It never blocks a tool, never interjects mid-solve, never watches the conversation after.
• Modes: on (grill first, the default — installing it is the opt-in), off (build straight away). Control with /fp-barbeque:mode.

How it's built

fp-pluginplaza/
├── .claude-plugin/marketplace.json   the hub manifest — lists every plugin
├── shared/fpbase/                    the substrate (ONE canonical copy)
│   ├── src/   provenance · state · mode · audit · queue · inject · statusline
│   └── test/  31 tests, no dependencies
└── plugins/
    └── fp-honesty/
        ├── .claude-plugin/plugin.json
        ├── hooks/
        │   ├── _fpbase  →  symlink to ../../../shared/fpbase/src
        │   └── inject.js · audit.js · honesty.js · ...
        ├── skills/fp-honesty/SKILL.md
        └── commands/mode.md

Base sharing is a symlink, not a build step. Each plugin symlinks shared/fpbase/src into its own hooks/_fpbase. When Claude Code installs a plugin from this repo it dereferences that symlink and copies the base content into the plugin's cache, so an installed plugin is fully self-contained. There is no build, no vendoring, and no chance of a stale copy. The filesystem is the single source of truth.

Adding a plugin

A new plugin is mostly behaviour, not plumbing:

1. plugins/<name>/ with a .claude-plugin/plugin.json, a skills/<name>/SKILL.md, and whatever hooks/ it needs.
2. ln -s ../../../shared/fpbase/src plugins/<name>/hooks/_fpbase if it uses the base.
3. Add an entry to .claude-plugin/marketplace.json.

Develop & test

npm test    # runs the base suite + every plugin's suite, via node --test

No install step is required to run the tests — everything uses Node built-ins.

License

MIT