feat(publish): generate Claude Code plugin + marketplace from personas

.claude-plugin/marketplace.json

@@ -0,0 +1,64 @@
+{
+  "description": "Install and run portable, versioned expert personas in Claude Code.",
+  "name": "truecast",
+  "owner": {
+    "name": "Inder Singh"
+  },
+  "plugins": [
+    {
+      "description": "An infrastructure/platform engineer who owns the production boundary",
+      "name": "infrastructure",
+      "source": "./personas/infrastructure"
+    },
+    {
+      "description": "A product manager who keeps you building the right thing",
+      "name": "product-manager",
+      "source": "./personas/product-manager"
+    },
+    {
+      "description": "A product marketer who makes the value obvious to the one person it's for",
+      "name": "product-marketer",
+      "source": "./personas/product-marketer"
+    },
+    {
+      "description": "A product researcher who turns raw signal into knowledge the team can trust",
+      "name": "product-researcher",
+      "source": "./personas/product-researcher"
+    },
+    {
+      "description": "An independent adversarial check who assumes it's broken and finds it before a user does",
+      "name": "qa",
+      "source": "./personas/qa"
+    },
+    {
+      "description": "A founder-led seller who owns the COMMERCIAL TRUTH for a pre-/early-revenue product",
+      "name": "sales",
+      "source": "./personas/sales"
+    },
+    {
+      "description": "A security engineer who tries to get in before an attacker does",
+      "name": "security-engineer",
+      "source": "./personas/security-engineer"
+    },
+    {
+      "description": "A software architect who makes the system the best-engineered AND simplest-that-lasts",
+      "name": "software-architect",
+      "source": "./personas/software-architect"
+    },
+    {
+      "description": "An engineer who turns the plan into code you can trust",
+      "name": "software-engineer",
+      "source": "./personas/software-engineer"
+    },
+    {
+      "description": "A UI/UX designer who makes the product usable first, then makes it feel inevitable",
+      "name": "ui-ux-designer",
+      "source": "./personas/ui-ux-designer"
+    },
+    {
+      "description": "A seed-stage VC who underwrites the founder and the insight before the metrics",
+      "name": "vc-seed",
+      "source": "./personas/vc-seed"
+    }
+  ]
+}

CHANGELOG.md

@@ -10,6 +10,19 @@ All notable changes to truecast are documented here. The format follows
 
 ## [Unreleased]
 
+### Added
+- **`truecast publish` + plugin install.** `publish` generates, from each persona, a native Claude Code
+  plugin (`agents/<name>.md` + `.claude-plugin/plugin.json`) plus a repo-root `.claude-plugin/marketplace.json`
+  — turning any repo into an installable marketplace. Users then install a teammate with no restart:
+  `/plugin marketplace add <owner/repo>` → `/plugin install <name>@<marketplace>` → `/reload-plugins`.
+  Flags: `--check` (drift gate for CI), `--settings` (ride-along snippet for a consuming repo, no
+  `autoUpdate` by design), `--dry-run`, `--repo`, `--marketplace`. Writes only inside your repo, into
+  git-tracked files you review in the diff; nothing is uploaded. The official catalog is published this way.
+- **Two new official personas: `product-researcher` and `vc-seed`** — joining product-manager,
+  software-engineer, software-architect, security-engineer, qa, infrastructure, product-marketer,
+  ui-ux-designer, sales (eleven total). `vc-seed` distills a seed-stage investor's lens (the Pull, earned
+  secrets, revealed preferences, the dinner test), grounded in Nikunj Kothari's open-source Nock (MIT).
+
 ### Changed
 - Dependency bumps (Dependabot): runtime — zod 3→4, pino 9→10, write-file-atomic 6→8, commander 14→15;
   toolchain — TypeScript 6, @types/node 25, vite 8, vitest 4, **@biomejs/biome 1→2** (config migrated to

README.md

@@ -6,9 +6,10 @@ Install portable, versioned **expert personas** — a product manager, an archit
 — into any project, run them in Claude Code, and keep your own customizations when the author improves
 them.
 
-**Status:** working end-to-end — `install` · `update` · `list` · `remove` · `doctor` · `prompt`, with a
-per-persona ownership ledger, atomic updates, and a sandboxed git/GitHub fetch. Verified driving real
-Claude Code sessions (as a subagent and as a standalone agent). Pre-1.0; the self-improving loop is next.
+**Status:** working end-to-end — `install` · `update` · `list` · `remove` · `doctor` · `prompt` · `publish`,
+with a per-persona ownership ledger, atomic updates, and a sandboxed git/GitHub fetch. Verified driving real
+Claude Code sessions (as a subagent and as a standalone agent); `publish` generates a Claude Code plugin
+marketplace (validated with `claude plugin validate`). Pre-1.0; the self-improving loop is next.
 
 ## What a persona is
 A persona is a small, greppable corpus + an identity, split into two owners:
@@ -20,6 +21,24 @@ A persona is a small, greppable corpus + an identity, split into two owners:
 
 A bundled example: [`personas/product-manager/`](personas/product-manager/).
 
+## Install a teammate as a plugin (no restart)
+
+Install straight into a live Claude Code session:
+
+```
+/plugin marketplace add wastedcode/truecast
+/plugin install product-manager@truecast
+/reload-plugins
+```
+Now talk to the teammate by name. You only type `@truecast` at install; it's the marketplace the plugin
+comes from, like an npm scope. Swap `product-manager` for any of the eleven official personas:
+`product-researcher`, `vc-seed`, `software-engineer`, `software-architect`, `security-engineer`, `qa`,
+`infrastructure`, `product-marketer`, `ui-ux-designer`, `sales`.
+
+The first time you run a plugin teammate with no job set, it asks what the project needs and writes its own
+`mandate.md`. Want a global, versioned copy you update on your terms, with an ownership ledger that keeps
+your edits when the author ships changes? Use the `truecast` CLI below.
+
 ## Get the `truecast` CLI
 ```sh
 npm install -g @wastedcode/truecast    # installs the `truecast` command
@@ -34,7 +53,10 @@ npm link                                   # puts `truecast` on your PATH
 Requires Node ≥ 20. **Pre-1.0:** the CLI and the programmatic API may change between `0.x` minors — see
 [docs → Stability](docs/README.md#stability-pre-10).
 
-## Install a persona
+## Install a persona with the CLI
+The plugin path above is the fast lane. The CLI is the control lane: a global, versioned copy you update
+deliberately, with a per-persona ownership ledger so your customizations survive an update.
+
 ```sh
 cd your-project
 truecast install <git-url-or-path>[@version][#subpath]
@@ -45,22 +67,22 @@ truecast install ./personas/product-manager                       # local path
 truecast install https://github.com/you/persona@1.2.0             # a GitHub release tag
 truecast install https://github.com/you/monorepo#personas/pm      # a persona in a sub-directory
 ```
-The official personas (`product-manager`, `software-engineer`, `software-architect`, `security-engineer`,
-`qa`, `infrastructure`, `product-marketer`, `ui-ux-designer`, `sales`) live in this repo under
-[`personas/`](personas/) — install any of them with `…/truecast#personas/<name>`.
+The eleven official personas (`product-manager`, `product-researcher`, `vc-seed`, `software-engineer`,
+`software-architect`, `security-engineer`, `qa`, `infrastructure`, `product-marketer`, `ui-ux-designer`,
+`sales`) live in this repo under [`personas/`](personas/) — install any with `…/truecast#personas/<name>`.
 Then write the persona's job for this project in `.truecast/agents/<name>/instance/mandate.md`.
 
 ## Using a persona
 
-Installing generates a native Claude Code **subagent** at `~/.claude/agents/<name>.md` and symlinks the
+A CLI install generates a native Claude Code **subagent** at `~/.claude/agents/<name>.md` and symlinks the
 craft into your project. Its body carries an **index of the persona's skills** (each with a one-line
-summary and the path to Read), so the persona pulls the right skill on demand — verified: given an
-open-ended task it Reads the matching `SKILL.md` files itself, then applies them.
-
-You can run a persona three ways.
+summary and the path to Read), so the persona pulls the right skill on demand. Verified: given an
+open-ended task it Reads the matching `SKILL.md` files itself, then applies them. (A plugin install ships
+the same body; only the delivery differs.)
 
-### 1. As a Claude Code subagent (`@agent-<name>`)
-Restart Claude Code after installing, then bring it into a normal session:
+### As a Claude Code subagent (`@agent-<name>`)
+Restart Claude Code after a CLI install (the plugin path above needs no restart), then bring it into a
+normal session:
 
 ```
 > have the product-manager pressure-test this idea: an AI that auto-prioritizes my to-dos
@@ -69,7 +91,7 @@ Claude delegates to the subagent (it's listed under `/agents`, and you can `@age
 explicitly). The subagent runs with the tools the persona declares (`tools` in its `persona.toml`),
 reads its `mandate.md` for the project job, and Reads the skills it needs.
 
-### 2. As a standalone `claude` (the persona *is* the main agent)
+### As a standalone `claude` (the persona *is* the main agent)
 Run a full `claude` session that *is* the persona — its whole craft loaded as the system prompt.
 `truecast prompt` emits that composed prompt; pipe it into `claude`:
 
@@ -83,7 +105,7 @@ Now the whole session thinks like the persona. `--allowed-tools` restricts it to
 declares (a main agent otherwise has the full toolset); `--model` matches its `modelHint`. (`truecast
 prompt <name>` just prints the system prompt — `--append-system-prompt-file <file>` works too.)
 
-### 3. As persistent, programmable agents (claudemux)
+### As persistent, programmable agents (claudemux)
 [claudemux](https://github.com/wastedcode/claudemux) runs real, login-backed `claude` sessions you drive
 by name and that tell you when a turn is *actually* done. Flags after `--` are forwarded straight to
 `claude`, so you launch a persona as a full standalone agent and talk to it over time:
@@ -104,6 +126,31 @@ Each persona is its own session, addressed by name — `tmux attach` to watch it
 team (`claudemux spawn architect … / spawn security …`) and coordinate them from one place. The CLI maps
 1:1 to a Node library if you'd rather drive it from code (`create({ name, cwd, extraArgs: [...] })`).
 
+## Contribute a persona to the catalog
+
+truecast runs **one curated catalog**, the marketplace this repo publishes, so a user adds it once and
+installs everything as `<name>@truecast`. To get your persona in, **open a PR here** with your
+`personas/<name>/core/` (the source: `agent.md`, `skills/`, `knowledge/`, `persona.toml`). You don't
+generate plugin files or run `publish`; a maintainer publishes it into the catalog when your PR lands.
+Start from [`docs/authoring-personas.md`](docs/authoring-personas.md) and [`CONTRIBUTING.md`](CONTRIBUTING.md).
+
+## Ride a teammate along in a repo
+
+Put a teammate in a project so everyone working in it gets the same one, with nothing to install by hand.
+Add this to the repo's `.claude/settings.json` and commit it:
+
+```json
+{
+  "extraKnownMarketplaces": {
+    "truecast": { "source": { "source": "github", "repo": "wastedcode/truecast" } }
+  },
+  "enabledPlugins": ["product-manager@truecast"]
+}
+```
+When someone opens the repo in Claude Code and trusts the folder, Claude Code offers to install the
+teammate for them. The expert travels with the code, not with each person's setup. Only commit this for a
+marketplace you control, and review what a marketplace ships before you trust a folder.
+
 ## Managing personas
 ```sh
 truecast list [--check] [--project]   # what's installed; running vs latest; what's attached here
@@ -123,6 +170,9 @@ commands; they're the persona's private craft). Every file truecast writes is tr
 ledger** (`owned.json`), under a per-persona lock, so concurrent installs never collide and truecast
 never clobbers a file it doesn't own.
 
+`publish` is the parallel path. Instead of materializing into `~/.claude`, it generates the committed
+plugin and marketplace files that Claude Code installs from.
+
 ## Docs
 [`docs/`](docs/) — [install](docs/install.md), [managing personas](docs/managing-personas.md),
 [authoring personas](docs/authoring-personas.md), and a shipped-vs-planned status table. (Kept in step

docs/README.md

@@ -4,8 +4,8 @@ Reference docs, kept in step with what's actually shipped. **Convention: a featu
 it's documented here.**
 
 > truecast — *the expert teammates Claude Code doesn't ship with.* Install portable, versioned expert
-> **personas** into any project, summon them with `@agent-<name>`, and keep your edits when the author
-> improves them.
+> **personas** into any project — as a plugin (`/plugin install <name>@truecast`, no restart) or via the
+> `truecast` CLI — and keep your edits when the author improves them.
 
 ## Status
 | area | state |
@@ -14,15 +14,17 @@ it's documented here.**
 | `update` · `list` · `remove` — CLI + programmatic | ✅ shipped |
 | `doctor` — inspect + repair (drift/dangling/stale/orphan) | ✅ shipped |
 | `prompt` — emit a persona's composed system prompt | ✅ shipped |
+| `publish` — generate a Claude Code plugin + marketplace from personas (`--check`/`--settings`) | ✅ shipped |
+| install a teammate as a plugin (`/plugin marketplace add` → `/plugin install`, no restart) | ✅ shipped |
 | run a persona: subagent · standalone `claude` · claudemux fleet | ✅ shipped |
 | persona format (`core/` + `instance/`, `persona.toml`) | ✅ shipped |
 | skills as the persona's craft (in-body index, Read on demand) | ✅ shipped |
-| bundled persona: `product-manager` | ✅ shipped |
+| 11 official personas (product-manager · product-researcher · vc-seed · software-engineer · software-architect · security-engineer · qa · infrastructure · product-marketer · ui-ux-designer · sales) | ✅ shipped |
 | security: containment + clobber/drift guards + adversarial suite | ✅ shipped |
 | robustness: per-persona write-through ledger + lock, atomic swaps, `--force` | ✅ shipped |
 | pinning a project to a fixed version (`--pin`) | ⏳ planned |
 | `sync` (re-materialize the surface from the cache) | ⏳ planned |
-| `publish` · `conform` | ⏳ planned |
+| `conform` (lint/validate a persona for publishing) | ⏳ planned |
 | self-improving "gate" (the `learn` loop) | ⏳ v1 |
 
 ## The model in 30 seconds
@@ -34,7 +36,8 @@ A persona splits into two owners:
   **never touched by an update.** *You only ever edit `instance/`.*
 
 ## Pages
-- [install](install.md) — install a persona (CLI + programmatic), and exactly what it writes.
+- [install](install.md) — install a persona: as a plugin (no restart) or via the CLI, and exactly what
+  each writes.
 - [managing personas](managing-personas.md) — `update` · `list` · `remove` · `doctor`: keep personas
   current, see what's installed, detach or purge them, and inspect/repair the home.
 - [authoring personas](authoring-personas.md) — how to build one; the `persona.toml` format.

docs/authoring-personas.md

@@ -42,3 +42,9 @@ Bash, Edit, Write, NotebookEdit` — and is surfaced for approval before any wri
 ## Validate
 The schema + every referenced file are checked at install. The repo also tests the bundled persona
 against the schema in `src/schema/default-persona.test.ts` — mirror that pattern for your own persona.
+
+## Publishing
+truecast runs one curated catalog. To make your persona installable, **open a PR adding
+`personas/<name>/core/` to this repo** — a maintainer generates and publishes the plugin files into the
+official marketplace; you don't run `publish` or commit any generated files. See the README's
+*Contribute a persona to the catalog* section and [`CONTRIBUTING.md`](../CONTRIBUTING.md).

docs/install.md

@@ -2,6 +2,23 @@
 
 Install a persona into the current project (plus a one-time global cache).
 
+## As a plugin (fastest — no restart)
+
+Install a teammate straight into a live Claude Code session:
+
+```
+/plugin marketplace add wastedcode/truecast
+/plugin install product-manager@truecast
+/reload-plugins
+```
+Talk to it by name afterward. You only type `@truecast` at install; it names the marketplace the plugin
+comes from, like an npm scope. Any of the eleven official personas works: `product-manager`,
+`product-researcher`, `vc-seed`, `software-engineer`, `software-architect`, `security-engineer`, `qa`,
+`infrastructure`, `product-marketer`, `ui-ux-designer`, `sales`.
+
+The CLI below is the control path: a global, versioned copy you update deliberately, with an ownership
+ledger that protects your edits. Use it when you want that control; use the plugin when you want speed.
+
 ## CLI
 ```sh
 cd your-project
@@ -28,7 +45,7 @@ source (a `..` escape is refused).
 - `--as <name>` — *(planned)* install under a different local name.
 
 After install, write the job in `.truecast/agents/<name>/instance/mandate.md`, then **restart Claude
-Code** to load `@agent-<name>`.
+Code** to load `@agent-<name>`. (The plugin path above needs no restart.)
 
 ## Programmatic (TypeScript)
 The CLI is a thin wrapper over a typed function — orchestrators (e.g. Posse) call it directly:

personas/infrastructure/.claude-plugin/plugin.json

@@ -0,0 +1,9 @@
+{
+  "author": {
+    "name": "Inder Singh"
+  },
+  "description": "An infrastructure/platform engineer who owns the production boundary",
+  "displayName": "Infrastructure",
+  "name": "infrastructure",
+  "version": "1.1.0"
+}