claude-plugin-suite

# Plugin Suite

Fourteen domain-expert plugins for Claude Code and Cowork. Each one encodes how a
specialist in that field actually works — the order they do things in, the question that
splits the field fastest, and the point at which they say they do not know.

Browse the full catalogue with live pricing at
**[codestudioplugin.com](https://www.codestudioplugin.com)** —
plans for every plugin are listed on the
[pricing page](https://www.codestudioplugin.com/pricing). Each plugin's
tool server includes free tools for evaluating it before buying; a paid
licence unlocks the rest. Every plugin is also published to
[Open VSX](https://open-vsx.org/namespace/code-studio) as a VS Code
extension — in Cursor, Windsurf, VSCodium or Gitpod, search *code-studio*
in the Extensions panel and install.

Installable as a marketplace:

```
/plugin marketplace add farssaadeldin7-ux/claude-plugin-suite
/plugin install diagnose-by-sound@plugin-suite
```

## The plugins

| Plugin | For | The judgement it encodes |
| --- | --- | --- |
| [`diagnose-by-sound`](plugins/diagnose-by-sound) | Workshop service advisers | Characterise the noise before naming a cause; report calibrated confidence, not a guess |
| [`ghost-post-preview`](plugins/ghost-post-preview) | Social managers | Name the most likely reason a post underperforms; never fabricate an engagement number |
| [`professor-mind-reader`](plugins/professor-mind-reader) | University students | Answer at the level the rubric verb demands; find the sentence that satisfies each criterion |
| [`five-minute-fluency`](plugins/five-minute-fluency) | Competitive players | Three changes maximum, ranked by rating gain per unit of practice |
| [`trail-split`](plugins/trail-split) | Expedition leaders | Every critical system has a named owner and a stated backup, or the plan is not finished |
| [`podcast-video-studio`](plugins/podcast-video-studio) | Content agencies | A clip that needs context is disqualified however good it was in the room |
| [`customer-sales-support`](plugins/customer-sales-support) | SaaS founders | An AI support agent is only as good as the docs; "I don't know — here's a person" is a first-class answer |
| [`haptic-feedback-mapper`](plugins/haptic-feedback-mapper) | Creative studios | A haptic that fires for something ignorable is worse than the screen it replaced |
| [`mental-health-chatbot`](plugins/mental-health-chatbot) | Telehealth platforms | Support, not crisis intervention — escalation is always on and never a severity judgement |
| [`neural-link-intention-layer`](plugins/neural-link-intention-layer) | UI/UX designers | Eliminate, then batch, then automate — in that order |
| [`generative-digital-twin`](plugins/generative-digital-twin) | Studio heads | A style is defined by what you never do; the "never" list matters most |
| [`emotional-resonance-analyzer`](plugins/emotional-resonance-analyzer) | Advertising and marketing video editors | Flat stretches are the problem, not low stretches; real retention data always wins |
| [`code-to-visual-interpreter`](plugins/code-to-visual-interpreter) | Creative technologists | Structure, modulation, surface — and a seeded PRNG or the piece is unreviewable |
| [`predictive-resource-allocation`](plugins/predictive-resource-allocation) | VFX and 3D studios | Find the binding constraint first; buying hardware is the last remedy, not the first |

Audiences, the skill each user must bring, and the monetisation shape are in
[`docs/AUDIENCES.md`](docs/AUDIENCES.md).

## Design rules

These are enforced by review, and partly by `scripts/validate.mjs`.

1. **No overclaiming.** If the premise implies a capability that does not exist — reading
   minds, measuring an audience that was never asked, predicting a number from text — the
   plugin says so in its first paragraph and reframes as what it honestly is. A user who
   trusts a meaningless number is worse off than one who got nothing.
2. **Thresholds, not vibes.** "Under 15% separation, do not present a winner" beats
   "consider carefully". Every judgement in a skill should be checkable.
3. **The limits section is mandatory.** Every skill states what it cannot answer and when
   to say so.
4. **References carry the tables.** SKILL.md holds the procedure; lookup tables,
   taxonomies and worked examples live in `references/` and are pointed at from the step
   where they become relevant.
5. **British spelling. No emoji, no hype vocabulary.** The validator warns on both.

## Layout

```
.claude-plugin/marketplace.json   the marketplace manifest
plugins/<id>/                     one directory per plugin
  .claude-plugin/plugin.json      plugin manifest
  skills/<id>/SKILL.md            the procedure
  skills/<id>/references/*.md     tables, taxonomies, worked examples
  .mcp.json, mcp/                 only where a plugin ships a tool server
packages/suite-runtime/           shared MCP + licensing runtime, vendored into plugins
services/billing/                 the Stripe-backed licensing service the runtime talks to
scripts/                          validate, vendor, build
docs/                             architecture, audiences, licensing
```

## Working on it

```bash
node scripts/validate.mjs        # structure, manifests, frontmatter, dead references
node scripts/vendor-runtime.mjs  # after editing packages/suite-runtime
node scripts/build.mjs           # .plugin archives into dist/
node scripts/build-vsix.mjs      # VS Code extensions staged into dist/vsix/
```

CI runs all of these on every push. See [`docs/ARCHITECTURE.md`](docs/ARCHITECTURE.md) for how
to add a plugin, and [`docs/LICENSING.md`](docs/LICENSING.md) for the free/paid split.

### Publishing to Open VSX

Each plugin also ships as a VS Code extension: a thin `extension.cjs` that
registers the plugin's MCP tool server through VS Code's MCP server definition
provider API (VS Code 1.102+), with the whole zero-dependency `mcp/` directory
bundled inside the `.vsix`. The skills ship too: the bundled server publishes
each one as an MCP prompt, which VS Code surfaces as a slash command
(`/mcp.<plugin>.<skill>`). Listing is open; the skill body itself requires an
active paid licence, same as the gated tools, since the `.vsix` is a public
download.

One-time setup, in this order:

1. Create an [Eclipse Foundation account](https://accounts.eclipse.org/) and
   log in to [open-vsx.org](https://open-vsx.org) with it.
2. Sign the Publisher Agreement (open-vsx.org → your avatar → Settings →
   the agreement prompt).
3. Create an access token (Settings → Access Tokens) and store it:
   `gh secret set OVSX_PAT --repo farssaadeldin7-ux/claude-plugin-suite`

Then publish from the Actions tab: run the **publish-openvsx** workflow
(optionally naming specific plugin ids). It packages every extension with
`vsce`, creates the `code-studio` namespace if needed, and uploads each
`.vsix` with `ovsx`, skipping versions that are already published. To build
locally instead: `node scripts/build-vsix.mjs --package`.

The plugins also publish to npm as `@farseman/<id>` packages with the
**publish-npm** workflow (runnable as `npx @farseman/<id>`; needs the
`NPM_TOKEN` repository secret described at the top of
`.github/workflows/publish-npm.yml`), and to the official MCP Registry with the
**publish-mcp-registry** workflow: `scripts/build-mcpb.mjs` packages each
one as an .mcpb bundle attached to a GitHub release, and the workflow
submits each listing under the `io.github.farssaadeldin7-ux` namespace,
authenticated with the job's own GitHub OIDC token — no stored secrets.

The same extensions publish to Microsoft's VS Code Marketplace with the
**publish-vsmarketplace** workflow. That marketplace has no trusted
publishing, so it needs a Personal Access Token stored as the `VSCE_PAT`
repository secret — the one-time setup is described at the top of
`.github/workflows/publish-vsmarketplace.yml`.

## Status

Version 0.1.3. All fourteen plugins ship working MCP servers built on the shared
runtime, each gating its licensed tools behind the billing service and keeping open
tools for evaluation before buying.

## Licence

Source-available, not open source. The code is published so it can be read and
evaluated; publication grants no rights to copy, modify, redistribute or create
derivative works from it. Paid plugin tiers are governed by the commercial terms
shown at the point of purchase. See [LICENSE](LICENSE).