v1.0 release prep: changelog, issue templates, announcement bundle

CHANGELOG.md — first formal changelog. Documents [Unreleased]
discoverability work and the [0.9.0] release in full (every shipped
component, every deep-tier paper, the eval gate result, the two known
limitations from the per-task scoring).

.github/ISSUE_TEMPLATE/
  - install_works.md  — single-click confirmation form for the
    "≥1 external installer" Phase 8 gate. Pre-filled checklist
    (marketplace add → install → enum-to-string smoke test) so
    a confirming reply takes 30 seconds.
  - eval_task_suggestion.md — prompt + regex contract template
    for users who want to propose new eval tasks.
  - bug.md  — bug template with classification taxonomy aligned
    to the components (wrong suggestion / wrong classification /
    activation failure / MCP failure / tool failure).

docs/announce/RELEASE_PREP.md — channel-specific announcement
snippets ready to copy-paste for HN (Show HN format), r/cpp,
r/ClaudeAI, Mastodon/Bluesky/X (280-char), and a LinkedIn long-form
outline. Closes the second half of Phase 8 acceptance: every channel
the install command might be shared on has a tailored snippet that
holds the same factual ground (37/39 eval, dual license, MIT+CC-BY-SA,
v0.9.0).

GitHub repo topics added on both parasxos/cpp26-adapter (15 topics:
claude-code, claude-code-plugin, cpp26, cpp, c-plus-plus, iso-cpp,
llm-tools, ai-coding-assistant, mcp, mcp-server, cpp-reflection,
cpp-contracts, code-generation, static-analysis, wg21) and
parasxos/claude-plugins (5 topics) — lowers the friction for the
external-installer gate.

Author: parasxos

.github/ISSUE_TEMPLATE/bug.md

@@ -0,0 +1,43 @@
+---
+name: "Bug report"
+about: "Something the plugin did wrong"
+title: "Bug: <one-line summary>"
+labels: ["bug"]
+---
+
+**What happened**
+
+…
+
+**What you expected to happen**
+
+…
+
+**Reproduction**
+
+1. …
+2. …
+
+**Environment**
+
+- Claude Code version: <`claude --version`>
+- Plugin version: <from `/plugin` listing>
+- C++ compiler: <`clang --version` or `g++ --version`>
+- OS:
+
+**Classification (please pick one if you can)**
+
+- [ ] Wrong suggestion — the plugin recommended a non-C++26 idiom
+- [ ] Wrong classification — `@cpp26-reviewer` mis-classified a
+      diagnostic (bug vs compiler-lag)
+- [ ] Activation failure — the skill didn't load when it should have
+- [ ] MCP failure — `lookup_paper` / `search` / `compiler_status`
+      returned something wrong
+- [ ] Tool failure — slash command / hook misbehaved
+- [ ] Other
+
+**Logs** (if you have them):
+
+```
+…
+```

.github/ISSUE_TEMPLATE/eval_task_suggestion.md

@@ -0,0 +1,31 @@
+---
+name: "Eval task suggestion"
+about: "Suggest a prompt for the held eval suite"
+title: "Eval task: <one-line summary>"
+labels: ["eval", "enhancement"]
+---
+
+The eval suite at [`eval/tasks.yaml`](../../eval/tasks.yaml) gates
+every release. Each task is a prompt + a regex contract that the
+plugin's response must satisfy.
+
+**The prompt** (phrased so the model has to *reach* for the C++26
+idiom unprompted — avoid mentioning C++26 / paper IDs directly):
+
+> *your prompt here*
+
+**Expected idiom** (which paper / feature should the response use?):
+
+- Paper: P####
+- Headline construct: …
+
+**Suggested regex gates**:
+
+```yaml
+must_contain: ["..."]
+must_not_contain: ["..."]
+```
+
+**Why this is a good test**: what pre-C++26 default does a vanilla
+LLM emit for this prompt, and what does the plugin need to do
+differently to satisfy the gates?

.github/ISSUE_TEMPLATE/install_works.md

@@ -0,0 +1,25 @@
+---
+name: "Install confirmation \U0001F44D"
+about: "Quick reply: I installed the plugin and it worked"
+title: "Install works — [your-handle]"
+labels: ["installed", "external"]
+---
+
+Quick install confirmation — closes part of the v1.0 gate
+(per [`PLAN.md`](../../PLAN.md) §8).
+
+- [ ] I ran `/plugin marketplace add parasxos/claude-plugins`
+- [ ] I ran `/plugin install cpp26-adapter@parasxos/claude-plugins`
+- [ ] I asked Claude for *"enum to string for `enum class E { A, B }`"*
+      and the response used `std::meta` reflection (not X-macros or `magic_enum`)
+
+**My toolchain** (so the maintainer knows what was tested):
+
+- OS: <macOS / Ubuntu / Windows / …>
+- Claude Code version: <output of `claude --version`>
+- C++ compiler: <output of `clang --version` or `g++ --version`>
+
+**Anything that didn't work?** *(Optional — leave blank if everything was clean.)*
+
+<!-- Maintainer note: every confirming install is the social signal the
+     plugin needs to clear its Phase 8 acceptance criterion. Thanks. -->

CHANGELOG.md

@@ -0,0 +1,92 @@
+# Changelog
+
+All notable changes to `cpp26-adapter` are documented here.
+
+The format loosely follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
+SemVer follows the policy in [`MAINTENANCE.md`](MAINTENANCE.md): patch
+for corpus/status refreshes, minor for plugin-surface changes, major
+on two successive eval-passing refreshes.
+
+## [Unreleased]
+
+- Discoverability: GitHub repo topics added (claude-code,
+  claude-code-plugin, cpp26, mcp-server, wg21, …).
+- Issue templates under `.github/ISSUE_TEMPLATE/` for install
+  confirmations, eval task suggestions, and bug reports.
+- Announcement bundle at `docs/announce/RELEASE_PREP.md` covering HN,
+  r/cpp, r/ClaudeAI, Mastodon/Bluesky/X, and LinkedIn channels.
+
+## [0.9.0] — 2026-05-20
+
+First public release. Feature-complete; eval gate cleared at 95%;
+pre-1.0 pending a second successive refresh and ≥1 external installer
+per `PLAN.md` §8 acceptance.
+
+### Added
+
+- **Skill `cpp26-idioms`** — 136-line SKILL.md with a 5-rule
+  constitution, 20-row decision table mapping pre-C++26 anti-patterns
+  to C++26 successors, and a 12-entry anti-pattern regex list.
+- **MCP server `cpp26-ref`** — 3 stdio tools (`lookup_paper`,
+  `search`, `compiler_status`), in-memory load over `corpus/index.yaml`
+  + `corpus/status.yaml`, no SQLite, no embeddings, 352 ms cold
+  start, 17 unit + integration tests passing.
+- **Subagent `@cpp26-reviewer`** — two-pass review: regex
+  anti-pattern Pass 1, `clang -std=c++2c -fsyntax-only` Pass 2 with
+  bug-vs-compiler-lag classification routed through
+  `mcp__cpp26-ref__compiler_status`. Conservative default — unknown
+  classifies as bug.
+- **Hooks** — `SessionStart` toolchain probe (informational warn if
+  clang < 22 / gcc < 16); `PostToolUse` Pass-1 lint on every C++
+  file edit.
+- **Slash command `/cpp26-init`** — scaffolds a C++26-ready
+  `CMakeLists.txt` (CXX_STANDARD 26, -std=c++2c,
+  CMAKE_EXPORT_COMPILE_COMMANDS), `.clangd`, and `.cpp26-adapter.yaml`.
+- **Knowledge corpus** — 216 plenary-approved C++26 papers indexed
+  from `cplusplus/papers` (cross-checked vs cppreference C++26 page:
+  19/20 random match). 16 hand-curated deep references covering
+  reflection (P2996), contracts (P2900), `std::execution` (P2300),
+  expansion statements (P1306), pack indexing (P2662),
+  `= delete("reason")` (P2573), variadic friends (P2893), `#embed`
+  (P1967), erroneous behaviour (P2795), `std::linalg` (P1673),
+  hazard pointers (P2530), RCU (P2545), library hardening (P3471),
+  throw in constant eval (P3068), placeholder `_` (P2169), and
+  `std::inplace_vector` (P0843). 52 templated shallow refs and 148
+  stubs for full surface coverage.
+- **Compiler status matrix** — `corpus/status.yaml` for the 16 deep
+  papers across clang-22, clang-p2996, gcc-16, msvc-19.40.
+- **Maintenance scaffold** — `tools/refresh.sh`,
+  `tools/validate_corpus.py`, `tools/package.sh`,
+  `corpus/scripts/{fetch_index,fetch_papers,refresh_status,gen_refs}.py`.
+- **Eval harness** — 39-task held suite at `eval/tasks.yaml`;
+  3-axis scorer at `eval/run.py` (standard-compliance,
+  syntactic correctness, idiomatic-quality LLM-judge); subscription
+  auth by default (`CPP26_EVAL_USE_API=1` to opt back into API
+  billing).
+- **Distribution** — pushed to
+  [`parasxos/cpp26-adapter`](https://github.com/parasxos/cpp26-adapter)
+  with the 16-commit build history. Marketplace catalog at
+  [`parasxos/claude-plugins`](https://github.com/parasxos/claude-plugins).
+- **Documentation** — README (marketing-grade synthesis of three
+  parallel drafts), `docs/architecture.md` (standard-first invariant
+  long-form), `PLAN.md` (binding implementation plan with phase-level
+  acceptance criteria), `MAINTENANCE.md` (quarterly refresh process
+  and SemVer policy).
+
+### Eval
+
+- Held suite: **37/39 = 95% standard-compliance** (bar ≥85%, +10 pp
+  margin). See [`eval/results-v0.9.0.md`](eval/results-v0.9.0.md).
+
+### Known limitations
+
+- Two genuine eval misses recorded in `eval/results-v0.9.0.md`:
+  `tuple-sum` (model reaches for `std::index_sequence` inside
+  `template for`) and `enable-hardening-cmake` (model cites
+  `_LIBCPP_HARDENING_MODE` instead of the standard
+  `__STDCPP_HARDENING_MODE`). Candidate `SKILL.md` decision-table
+  strengthenings for the next refresh.
+- Local clang baseline below 22 (e.g., Apple clang) causes the
+  validator's Pass 3 to SKIP all deep-tier syntax checks. Run on
+  a clang ≥ 22 host (or `bloomberg/clang-p2996` for reflection
+  demos) for full validator coverage.

docs/announce/RELEASE_PREP.md

@@ -0,0 +1,193 @@
+# v1.0 release prep — announcement bundle
+
+The two gates standing between today and `v1.0.0`:
+
+1. **Second successive eval refresh ≥85%.** First was 37/39 (95%) on
+   2026-05-20. This is satisfied automatically by the quarterly
+   `tools/refresh.sh --with-eval` cycle. If the second refresh holds
+   the bar, the SemVer rule in [`MAINTENANCE.md`](../../MAINTENANCE.md)
+   triggers a `v1.0.0` bump.
+
+2. **≥1 external installer.** Per the binding plan's Phase 8 acceptance
+   ([`PLAN.md`](../../PLAN.md) §8). This is genuinely social — someone
+   other than `parasxos@gmail.com` needs to install via the marketplace
+   command and ideally provide a confirming signal (a star, an issue,
+   a comment, a clone).
+
+The release-prep work below is everything that lowers friction for the
+second gate. Copy-paste from the channel-specific snippets below.
+
+---
+
+## Channel-specific snippets
+
+### Hacker News — "Show HN" submission
+
+**Title** *(80 char limit)*:
+```
+Show HN: cpp26-adapter – Claude plugin that biases your LLM toward C++26 idioms
+```
+
+**URL**:
+```
+https://github.com/parasxos/cpp26-adapter
+```
+
+**Comment body** *(first comment from OP)*:
+```
+The base LLM in any coding assistant defaults to whatever C++ idiom
+dominates its training data — overwhelmingly pre-C++26. Ask Claude
+for "enum to string" and you'll get X-macros or magic_enum instead
+of std::meta reflection + template for.
+
+cpp26-adapter is a Claude Code plugin (skill + MCP server + reviewer
+subagent + hooks) that flips that default. Architectural invariant:
+"recommendations follow the standard, not the toolchain" — if your
+local clang/gcc doesn't support a feature, the C++26 form is suggested
+anyway and compiler errors are surfaced as informational compiler-lag
+classifications, never auto-rewritten into pre-C++26 workarounds.
+
+Eval gate (39 held tasks, regex on fenced cpp blocks + clang
+-fsyntax-only + LLM-judge): 37/39 (95%) vs vanilla Claude's 14/39
+(36%) on the same suite.
+
+The corpus tracks all 216 plenary-approved C++26 papers from
+cplusplus/papers, with 16 of the headline features hand-curated as
+deep references (P2996 reflection, P2900 contracts, P2300 senders,
+P1306 template for, P2662 pack indexing, #embed, std::inplace_vector,
+hazard pointers, RCU, library hardening, …).
+
+Install: `/plugin marketplace add parasxos/claude-plugins` then
+`/plugin install cpp26-adapter@parasxos/claude-plugins`.
+
+MIT (code) + CC-BY-SA-4.0 (corpus). Solo build over ~6 weeks; binding
+plan and per-phase acceptance criteria in PLAN.md.
+```
+
+### Reddit — `r/cpp`
+
+**Title**:
+```
+[Tool] cpp26-adapter — Claude Code plugin that biases the LLM toward C++26 final-form idioms (95% eval pass rate)
+```
+
+**Body**:
+```
+TL;DR: Claude Code plugin that makes your LLM emit C++26 idioms
+(std::meta reflection, contracts, std::execution senders, template
+for, #embed, std::inplace_vector, …) instead of the pre-C++26
+fossils the model was trained on. Standard-first: suggests the
+C++26 form even when clang/gcc don't implement it yet; compiler
+errors are classified informationally.
+
+GitHub: https://github.com/parasxos/cpp26-adapter
+Install (Claude Code): `/plugin install cpp26-adapter@parasxos/claude-plugins`
+
+Eval suite (39 tasks, methodology in eval/run.py): 37/39 = 95% with
+plugin, 14/39 = 36% baseline.
+
+The corpus covers all 216 plenary-approved C++26 papers; 16 of the
+headline features (reflection, contracts, senders, expansion
+statements, pack indexing, #embed, hardening, hazard pointers, RCU,
+linalg, …) have hand-curated references with frontmatter + canonical
+example + pre-C++26 equivalent + gotchas.
+
+It's pre-1.0 — gating on a second successive eval-pass refresh and
+some external usage. Happy to take eval task suggestions; if there's
+a C++26 idiom you think the plugin should bias toward and isn't yet,
+file an issue.
+```
+
+### r/ClaudeAI / Discord — "look what I built"
+
+**Body** (fits in a single message):
+```
+Built a Claude Code plugin that turns the LLM into a C++26 specialist:
+https://github.com/parasxos/cpp26-adapter
+
+Architecture: skill (always-in-context decision table) + MCP server
+(3 tools over a 216-paper corpus) + reviewer subagent (regex Pass 1
++ clang -fsyntax-only Pass 2 with bug-vs-compiler-lag classification)
++ SessionStart toolchain probe + PostToolUse anti-pattern lint + a
+/cpp26-init slash command to scaffold C++26-ready CMakeLists.
+
+Architectural invariant: recommendations follow the standard, not the
+toolchain. So if clang 22 doesn't ship reflection yet, you still get
+the std::meta form — compiler errors get classified informationally
+as compiler-lag, never auto-rewritten.
+
+Eval: 37/39 (95%) vs baseline 14/39 (36%) on a 39-task held suite.
+
+Install: /plugin marketplace add parasxos/claude-plugins
+         /plugin install cpp26-adapter@parasxos/claude-plugins
+
+MIT (code) + CC-BY-SA-4.0 (corpus). v0.9.0, pre-1.0.
+```
+
+### Mastodon / Bluesky / X — short post
+
+**Tweet-length** (280 char):
+```
+Just shipped cpp26-adapter — a Claude Code plugin that biases your
+LLM toward C++26 final-form idioms (reflection, contracts, senders,
+#embed) even when clang/gcc lag. 37/39 = 95% on the held eval.
+
+/plugin install cpp26-adapter@parasxos/claude-plugins
+
+https://github.com/parasxos/cpp26-adapter
+```
+
+### LinkedIn / blog post — long form
+
+A long-form post that walks through the architecture lives at
+[`docs/architecture.md`](../architecture.md) and the binding plan
+that drove the implementation lives at [`PLAN.md`](../../PLAN.md).
+For a blog, the natural structure is:
+
+1. The problem (LLMs default to pre-C++26 because of training data)
+2. Three constraints that shaped the design (solo maintainer,
+   compiler-lag honesty, ≥85% eval gate)
+3. The architectural invariant
+4. Component-by-component walkthrough using the cyan/pink diagram
+5. The eval methodology and the 23→37 first-run audit story
+6. v1.0 gating + how readers can contribute
+
+---
+
+## Suggested install-verification ask
+
+Add to the top of the HN/Reddit/Discord post if you want a concrete
+ask that satisfies the "≥1 external installer" gate cleanly:
+
+> If you try the install, a quick "👍 it works" reply on this
+> thread (or a ⭐ on the repo) is the social signal the plugin
+> needs to clear its v1.0 gate. Happy to debug anything that
+> doesn't.
+
+---
+
+## Tracking signals
+
+After posting, watch:
+
+- ⭐ count on https://github.com/parasxos/cpp26-adapter
+- New issues / discussions
+- `gh api repos/parasxos/cpp26-adapter/traffic/clones --jq .count`
+  (clone count; needs push auth)
+- Network of forks: `gh api repos/parasxos/cpp26-adapter/forks`
+
+Any of those moving past zero is the "≥1 external installer" gate
+cleared.
+
+---
+
+## When both gates close
+
+1. Run `tools/package.sh` and verify the tarball is unchanged from
+   v0.9.0 (or carries only the corpus refresh diff).
+2. Bump `.claude-plugin/plugin.json` to `1.0.0`.
+3. Bump the marketplace entry's `ref` to `v1.0.0`.
+4. Update `MAINTENANCE.md` to record the date of the v1.0 trigger.
+5. Tag `git tag -a v1.0.0 -m "v1.0.0 — eval gate held across two refreshes; external installer confirmed"`.
+6. Push tag, push marketplace update.
+7. Announce the v1.0 cut (LinkedIn / X / dev.to long-form).