killer-release
/killer-release
Get a release right the first time and prove it installs. You lead: ask a few setup questions (what kind of release, how far to go, where to test-install, release notes), then bump every place the version appears in one commit on a local branch, check the changelog against what really changed with a blind reviewer, build the artifacts in a clean copy, and install them from scratch in an empty sandbox with the network off, where the installed tool must print the new version and run. A script-run gate checks versions, changelog, tag, tests, build, every install and AI attribution. Tagging, pushi
- Author
- Real-Fruit-Snacks ↗
- Repository
- killer-skills ↗
- Licence
- MIT
- Last repository change
- 12.11.2026
Assessment and security
- Files in this package
- 7
- Scripts
- 3
- HTML comments
- 0
- URLs in SKILL.md
- 0
No signals detected. Repository changed on 12.11.2026, without references to retired models or APIs.
MIT, open: use and modify while retaining author attribution.
- 3 scripts in this package. Review them before installing, as Claude may execute them.
Scripts: scripts/kit.py, scripts/release.py, scripts/run.py
What it does and when to use it
Get a release right the first time and prove it installs. You lead: ask a few setup questions (what kind of release, how far to go, where to test-install, release notes), then bump every place the version appears in one commit on a local branch, check the changelog against what really changed with a blind reviewer, build the artifacts in a clean copy, and install them from scratch in an empty sandbox with the network off, where the installed tool must print the new version and run. A script-run gate checks versions, changelog, tag, tests, build, every install and AI attribution. Tagging, pushi
Original author description
Get a release right the first time and prove it installs. You lead: ask a few setup questions (what kind of release, how far to go, where to test-install, release notes), then bump every place the version appears in one commit on a local branch, check the changelog against what really changed with a blind reviewer, build the artifacts in a clean copy, and install them from scratch in an empty sandbox with the network off, where the installed tool must print the new version and run. A script-run gate checks versions, changelog, tag, tests, build, every install and AI attribution. Tagging, pushi
How it works
- The rules that make it work
- 1. Setup: ask, don't make the user remember options
- 2. Map the release
- 3. Bump
- 4. Changelog
- 5. Build
- 6. The clean install: the core check
- 7. Notes
- 8. The gate
- 9. Publish
SKILL.md preview
---
name: killer-release
description: "Get a release right the first time and prove it installs. You lead: ask a few setup questions (what kind of release, how far to go, where to test-install, release notes), then bump every place the version appears in one commit on a local branch, check the changelog against what really changed with a blind reviewer, build the artifacts in a clean copy, and install them from scratch in an empty sandbox with the network off, where the installed tool must print the new version and run. A script-run gate checks versions, changelog, tag, tests, build, every install and AI attribution. Tagging, pushing and publishing are written down as exact commands and run one at a time, only after the user's OK. Use whenever the user wants to cut, prepare, ship, tag or publish a release, bump a version, write release notes, or asks whether a version is ready to ship, even if they never say 'killer-release'. For checking a deploy to production (migrations, feature flags, rollback), engineering:deploy-checklist fits better."
---
# Killer Release
You are the **lead**. You get a release ready so it's right the first time: the version bumped everywhere it appears, a changelog and notes that match what changed, the artifacts built, and those artifacts installed from scratch where nothing of the project can help them. Then you stop. A release counts as ready when the script's gate passes, and the core of that gate is a clean install that printed the new version. Your word, or an agent's, that it works isn't part of it.
`scripts/release.py` in this skill's folder does the work and keeps the books: the release shape, the version sites, the changes, the bump, the build, the clean installs, the gate and the publish plan. Run it with `py` on Windows (or `python` if there's no `py`) and `python3` elsewhere. If none of those works on Windows, use `~/.cache/killer-skills-python/python.exe`; the Windows installer puts Python there when it's missing. `release.py <command> --help` lists the options. Exit 0 means fine, 1 means a check failed, 2 means bad input or setup.
## The rules that make it work
- **It installs, or it isn't ready.** `smoke` installs the built artifacts in an empty sandbox (no project source, its own home, the network off, the user's Python and npm settings hidden) the way a user would, and the installed tool must print the new version and run a real command. The version is read from the command that asks for it, never from an installer's output. A command that resolves to a copy outside the sandbox fails, because it tests the wrong thing.
- **Every version site moves together.** `bump` finds them all (manifests, `__version__`, version constants in the source of any language (an HTML page's inline scripts too), README pins and version badges, release files named with the version (`tally-0.3.0.tgz`) and `v<version>` in the project's own URLs, the version a `--version` example in the docs prints, lock files, the changelog heading) and changes them in one commit; `versions` and the gate fail on any that disagree. A constant that looks like a version but holds another one is listed apart for you to check: it may be what `--version` prints.
- **The changelog says what changed, no more.** `changelog-check` maps entries to commits and back; a blind reviewer judges each claim against the diff. An unsupported entry gets fixed or kept as a decision the user sees.
- **Build from commits, in a clean copy.** `build` runs from the release branch in a fresh sandbox. The bytes the clean installs passed are the bytes the publish plan uploads; the gate checks the hashes, and a branch that moved after the build means build and install again.
- **Nothing outward without a yes, one step at a time.** `publish-plan` writes the commands and runs nothing. Each tag, push and upload runs through `publish --step N --yes` only after the user said yes to that step in this session. `guard` catches a tag or push the run didn't make.
- **No AI attribution, anywhere.** `release.py commit` refuses a message that credits an AI, and the gate fails on one in any commit since the last release tag (one made with plain git too), the notes or the changelog. The history must read as the user's own work.
- **Agents are blind and work in sandboxes.** Start them fresh (`general-purpose`), never with `fork`. They get the claim and the facts, never the script's suspicions or your reasoning.
- **Report what wasn't checked:** platforms nobody installed on, an install that needed the network, a remote tag check skipped offline.
## 1. Setup: ask, don't make the user remember options
Look first: do section 2 up to and including `versions` (none of it changes the project), so the defaults fit. Skip anything the user already said ("ship a patch, just prepare it"). Ask the rest with AskUserQuestion, in at most two calls.
**Call 1**
| Header | Question | Options (the first is the default) |
|---|---|---|
| Version | What kind of release? | The kind `changes` suggests first, marked (Recommended) (none marked when it says it can't tell): **Major** when options, commands or files went away or a commit says BREAKING (on 0.x that's a minor) · **Minor** for new options, commands or features · **Patch** when it's only fixes. Then the others, and **A specific version**: type it under Other |
| Landing | How far should it go? | **Prepare everything, I'll publish (Recommended)**: a local branch, its commits, the artifacts built and test-installed, the publish commands written down · **Publish after I OK each step**: at the end I ask before each tag, push and upload · **Check only**: no changes, a report on whether it's ready |
| Smoke | Where should the built release be test-installed? | **This machine, in a clean sandbox (Recommended)** · **Also through the project's CI on a branch**: only if a workflow exists; pushing the branch needs your OK |
| Notes | Release notes? | **Draft them from the changelog (Recommended)** · **The changelog section as it is** · **None** |
**Call 2**, only for what applies:
| Header | Question | Options |
|---|---|---|
| Newcomer | Should a fresh agent follow the install instructions as a first-time user? Ask when the README or notes have install steps. | **Yes (Recommended)**: its stuck points become findings · **No** |
| Network | The package needs dependencies that aren't on this machine. How should the clean install get them? Ask when the package has dependencies. | **From a folder I'll name (Recommended)**: still offline · **From the network**: the report says the install went online |
If AskUserQuestion isn't available, or the user said "just run it", use the defaults and say so in one line.
**Defaults:** the kind `changes` suggests (when it can't tell and nobody can be asked, the step it gives from the changelog's last release, else minor, recorded with `decide`) · prepare everything · this machine · draft notes · a first-time installer when there are install steps · the network off.
**Check only** means: `bump` without `--apply`, the changelog checked and reviewed but not fixed, the current commit built and installed, the gate, and the report. Nothing in the project changes. Pass `--landing check` to `init` and the script refuses to change anything.
## 2. Map the release
1. **Init:**
```
py <skill-dir>/scripts/release.py init --repo <project> [--package <folder>] [--test "<test command>" ...] [--registry <name>] [--landing prepare|publish|check] [--notes draft|as-is|none] [--branch <name>] [--env NAME=VALUE ...]
```
It prints the run folder (`~/.claude/killer-release/<project>/<date>-<slug>/`), the version and where it comes from, every version site, the examples it leaves alone, the constants that look like a version but don't match it (read each one: if it's what `--version` prints, it goes in the bump with `--also`), the last release and the commits since, the entry points (for a .NET tool, the command its package declares, with a note when the assembly or the README uses another name), likely build commands, the test commands CI runs (the gate runs every one; a step that only prepares for them, like `dotnet restore` before `dotnet test --no-restore`, is listed as `first:` and runs in the same sandbox before the tests that need it, and so is a job's build when its test reads a file the build makes (`python tools/build-standalone.py`, then `python tests/test_download.py dist/index.html`); CI lines it can't run as written, a pipe or a matrix value, are named with why), whether CI publishes on a tag (it reads `.github/workflows`), the registry the release goes to, the smoke recipes that fit, and tag signing. `references/checks.md` says what each kind of site is. A registry counts only when the project shows it publishes there (a publish workflow, a link to its page there, an install line in the docs that fetches it); a `pyproject.toml` alone doesn't, and then the notes and the publish plan point at the built artifacts. If the user says where it goes, pass `--registry pypi` (or npm, crates, rubygems, nuget, none). A monorepo with no top-level manifest needs `--package`. `init` reads files and git; it runs nothing of the project's.
2. **The side-effect check.** Before anything runs the project's code or its installer (`changes` runs its `--help`), search them for writes environment variables don't redirect: the Windows registry and the user's PATH; services, scheduled tasks and startup entries; global installs and absolute paths into the real home; anything that reaches the network. For each one, find its own setting (an install folder, a dry-run flag) and use it, pointed into the sandbox with `{home}`. A setting every sandbox needs (the folder a tool keeps its data in, when it asks the system for the home folder and ignores `HOME`) goes to the whole run: `release.py env -w <run> NAME={home}/<folder>`, or `--env` at `init`. From then on the reviewer's copy, the builds, the clean installs and the gate's tests all get it; `sandbox <name> --env` and `smoke --env` add to it for one sandbox. When `init` prints a `Home folder:` warning, the project has such calls (.NET's `Environment.GetFolderPath`, say), and on Windows no sandbox can redirect them: find the program's own override (a variable or an option its code reads) and give it with `--env` before anything runs. If it has none, don't run that code. Put the commands not to run in every sandbox block. If even `--help` isn't safe to run, use `changes --no-help`.
3. **Changes:** `release.py changes -w <run>`. Commits since the last release, files by area, and the user-visible surface: `--help` options before and after (run in a sandbox; name the command with `--help-cmd "<command>"` when it finds none), dependencies, commands, files and documented settings added or removed. It suggests a kind of release, and its `Compared against` line says what it compared. With no tag, it lists all of history, and the suggestion comes from the commits since the version was last set (the surface is compared with that commit) and the changelog's Unreleased entries. When those show nothing new or breaking, it doesn't suggest a patch: with no tag it can't tell what users already have, so it says `can't tell from history` and gives the changelog's last release against the manifest's version (0.2.0 in the changelog, 0.3.0 in `package.json`: a minor step, and 0.3.0 may never have been released). Ask the user then, with no option marked (Recommended). When there is a tag but nothing to diff (no command whose `--help` it can compare, as for a web page), it reads the changelog's Unreleased section, or its newest section if that's for a version after the tag: new, added, feature or layout in an entry suggest a minor, and `Compared against` names the section it read.
4. **Versions:** `release.py versions -w <run>`. A site that already disagrees (`DIFF`) is a finding to fix in the bump. A changelog section for a release not made yet is marked `next`, not `DIFF`, and the PASS line names it: if that version is this release, plan it with `bump <version>`.
5. **Learn the build and the tests.** Read the README, CONTRIBUTING and the CI config. If a release workflow exists, it's the truth about what ships: build the same way it does.
6. **Guard:** `release.py guard -w <run>` before and after each phase. It fails on a tag, a push or a commit to the user's branch that this run didn't make. If one shows up, find what did it, undo it, and tell the user.
7. **Announce** in one line, then carry on:
> killer-release: greet-tool 0.1.0 -> 0.2.0 (minor) · 4 version sites · 5 commits since v0.1.0 · build `python -m build`, clean installs with pip and the archive · notes drafted · prepare only, nothing published.
## 3. Bump
```
py <skill-dir>/scripts/release.py bump -w <run> <patch|minor|major|X.Y.Z> [--pre rc] [--also <file>:<line> ...]
```
The preview shows every edit as a diff and changes nothing. Read it: every site there, the examples left alone, the changelog section dated. It also lists each constant that looks like a version but holds another one (`const string Version = "0.1.0"` beside a manifest at 0.2.0). `bump` never changes one by itself, because it can't tell a stale copy of the project's version from some other version; open the file, and if it is the project's, add it with `--also <file>:<line>`. Then the same command with `--apply` switches to a new local branch, `killer-release/v<version>`, and commits the edits as "Release <version>: bump the version". It refuses uncommitted changes to tracked files: ask the user where they belong, don't commit them yourself. It leaves test files alone, but names every test line that still holds the old version (a test that expects `--version` to print `tool 0.3.0`, say): update each one on the release branch with `release.py commit`, or make the test read the version, before the gate runs the tests. Lock files that record the project's own version are rewritten by their own tool (`npm version`) in a sandbox, or listed for the user. When the version comes from tags, there's nothing to edit; the tag is the bump. When every site already says the new version (a release that was prepared but never tagged: `bump <version>` with that version), `--apply` cuts the release branch with no commit, so the changelog and notes can still be committed on it with `release.py commit`.
## 4. Changelog
1. On the release branch, write or fix the version's section in the changelog's own style. `bump` dated it or turned `Unreleased` into it, but never writes entries. Each entry is something a user can notice. Say breaking changes first and call them breaking.
2. `release.py changelog-check -w <run>` maps each entry to the commits and surface changes behind it, and each change to its entries. It reads the changes up to the release branch's head, `changes.json` and the commits made on the branch since, so a packaging fix committed there backs its entry; the bump commit and the changelog's own edits are left out. Its `Changes read up to` line says what it read. Look at every NOTHING BEHIND IT and NO ENTRY. The matching is by words, so it's a lead, not a verdict.
3. **Release reviewer:** `release.py sandbox -w <run> review`, then the brief from `references/briefs.md`. One fresh agent (`general-purpose`, `run_in_background: false`, description "Review the changelog"). Then `release.py collect -w <run> --sandbox review --as reviewer`. Its unsupported, overstated and unclear entries and its missing changes become findings `F1`...; the gate waits on every unsupported, overstated and missing one.
4. For each finding, fix the changelog and run `release.py update -w <run> F1 --status fixed`, or keep it with `--status kept --note "<why>"`. That records the decision for the user itself, so don't run `decide` for it too (the report lists a repeated decision once).
5. Commit through the script, so no AI credit gets in: `release.py commit -w <run> -m "Release <version>: changelog: <what and why>" CHANGELOG.md`. Rerun `changelog-check` after big changes.
## 5. Build
```
py <skill-dir>/scripts/release.py build -w <run> [--artifacts "dist/*" ...] [--twice] [--tag-in-sandbox] [--net] -- <build command>
```
It builds the release branch's commit in a fresh sandbox and copies what it made into `<run>/artifacts/` with a `SHA256SUMS.txt` beside them. It finds wheels, sdists, `npm pack` tarballs, `.nupkg` packages, zips, `target/release` binaries and the like by itself; name anything else with `--artifacts`. When the project has a pack step (a project file with `PackAsTool` or `GeneratePackageOnBuild`, `dotnet pack` in CI or as the build command), the package is the release file, and the executables the build leaves in `bin/` and `obj/` are left out and named in a note. Read the warnings: an artifact whose name lacks the new version means the build reads the version from somewhere `bump` didn't touch. `--twice` builds again in another sandbox and says whether the bytes match. A build that needs the network (Python's build isolation fetches its backend) fails offline: install the backend, or pass `--net` and say so.
## 6. The clean install: the core check
For each way users install the release, follow `references/recipes.md`:
```
py <skill-dir>/scripts/release.py smoke -w <run> --install <pip|npm|dotnet-tool|archive|script|binary> [--then "<a real command>"] [--expect "<text>"] -- <tool> --version
```
It prints PASS or FAIL with what it ran and what came out. The version is looked for in the output of the first command that asks for one (`--version`, `-V`, `version`), so an installer that runs first and names the version it installed doesn't count; with no such command it refuses to start, because the version wouldn't be checked. If the user chose the network for dependencies, add `--net`; if they named a folder, `--wheelhouse <folder>`. On FAIL, fix the cause on the release branch, commit with `release.py commit`, build again and install again. Never weaken the check to pass it: `--net`, `--wheelhouse` and `--no-version-check "<why>"` are for releases that really need them, and each one shows in the report. Several recipes per release are normal (a wheel and an installer, Windows and POSIX installers).
**First-time installer** (if chosen): `release.py sandbox -w <run> newcomer --empty` makes a sandbox holding only the artifacts. Brief it from `references/briefs.md` and send one fresh agent (description "Install as a newcomer"), then `release.py collect -w <run> --sandbox newcomer --as installer`. Its stuck points and guesses become findings; fix the docs or keep them as decisions.
**Through CI** (if chosen): the branch push is outward. Record it with `release.py wait -w <run> "Push the release branch to run CI" --command "git push -u origin <branch>"`, and run it only after the user's OK.
## 7. Notes
`release.py notes -w <run>` drafts `<run>/notes.md` from the changelog section, with a compare link (`--as-is` for the section alone). Its Install section is the README's install lines for users, moved to the new version (never a developer setup: a requirements file, an editable install, a folder of wheels); without one, the registry the release goes to, when `init` found one; otherwise the built artifacts, the command that installs each kind (`npm install -g ./<file>` for an npm tarball, `pip install ./<file>` for a wheel or sdist, `dotnet tool install --global --add-source . <PackageId> --version <version>` for a .NET tool's package, `gem install ./<file>`, `unzip` or `tar -xzf` for an archive), then the version check the clean install ran; failing that, a placeholder that starts "Fill this in before publishing". So draft it after the clean install, and write any placeholder yourself. Edit it in the project's voice: what a user gets first, plain words, nothing the changelog doesn't back up. Skip this step for "None".
## 8. The gate
```
py <skill-dir>/scripts/release.py check -w <run> [--test "<test command>" ...] [--net]
```
It prints PASS, FAIL or SKIP for each item in `references/checks.md` (versions, changelog, tag, tree, tests, build, smoke, attribution, outward, review) and exits 1 if any fails. Fix and run it again. The tests item runs every test command CI runs (a Python suite and `node --test`, say), each in a fresh sandbox, and every `--test` command you gave (repeat `--test` for several; they run in order, so nothing has to be chained through a shell); the run remembers them. A test command CI runs after a preparing step (`dotnet restore`, then `dotnet test --no-restore`) runs after that step in its sandbox, and so does a `--test` command that is the same one; a preparing step that fails fails it. A CI test command whose tool isn't installed here fails it: install the tool, or pass `--no-ci-tests "<why>"`. A command that exits 0 having run no tests fails too, with why: a release isn't checked by tests that didn't run. `--no-tests "<why>"` is for a project with no tests. Each passing command says how many tests its runner counted ("7 tests passed"), or that the count wasn't read for that runner. Everything each test command printed is kept in `<run>/gate-logs/`, and the item prints the path: open it, and check the command ran the tests you think it ran. The report lists every test command the gate ran with its log, and CI's test lines it didn't run with why.
## 9. Publish
`release.py publish-plan -w <run>` writes `<run>/publish.md`: the exact commands, in order, to land the branch, tag the checked commit (signed if the project signs its tags), push the tag, upload to the registry the project uses (`twine upload`, `npm publish`, `cargo publish`, `gem push`, or `dotnet nuget push <package> --source <NuGet>` for a .NET package; none when it shows none: then the release is the built files, the plan says where they are, and for a `.nupkg` that it stays a file, with the command that installs it from its folder) and create the GitHub release with the checked artifacts and the notes. When CI publishes on a tag push, the plan is "push the tag; CI does the rest" and names the workflow. Nothing runs, and each step is recorded as waiting.
- **Prepare everything, I'll publish:** stop here. Show the plan.
- **Publish after I OK each step:** for each step in order, ask with AskUserQuestion, showing the step's exact commands: **Run step N (Recommended)** · **Stop here**: the rest stays in publish.md. On a yes, `release.py publish -w <run> --step N --yes`. It refuses unless the gate passed for this exact commit and the earlier steps are done, and checks the remote doesn't have the tag before pushing it. Never pass `--yes` for a step the user didn't say yes to in this session.
## 10. Report
Run `release.py report -w <run>`. It writes `<run>/report.md` and `<run>/summary.json`: the result, the gate, the clean installs, the artifacts and their hashes, the changes, the review findings, decisions to check, what's waiting for the user's OK, and what wasn't checked. Then give the user, in chat: the headline, what the clean installs printed, the decisions to check, the publish steps waiting, and a link to `report.md`. Then `release.py clean -w <run>` deletes the sandboxes.
## Running unattended
killer-goal runs this skill overnight, and a user may start it and walk away. Then:
- **The setup answers come with the request.** Don't ask: use what was given and the defaults for the rest, and say so in one line.
- **When killer-goal names a branch, commit there** instead of making a new `killer-release/v<version>` branch. Pass it to `init --branch <name>` (or `bump --apply --branch <name>`); when that branch is the current one, the bump commits on it.
- **Questions that come up later don't stop the run.** Take the safe choice, carry on, and record it with `release.py decide -w <run> "<text>"`. They're listed under "Decisions to check" in the report. With dependencies missing for the clean install and no folder of them named, install them from the network (`smoke --net`) and record that with `decide`; the report says the install went online.
- **Nothing outward-facing happens unattended:** no push, pull request, publish, tag, upload or settings change, and never `publish`. Prepare it, record it with `release.py wait -w <run> "<text>" --command "<cmd>"` (`publish-plan` does this for every step), and it's listed under "Waiting for your OK".
- **Finish with `release.py report`,** so `summary.json` is there for whoever reads the run in the morning, and end with one line: `killer-release: <done | partial | blocked> · <headline> · <path to report.md>`.
## When things go wrong
- **The clean install printed the old version:** a site `bump` missed, a version read from a generated file, or a stale artifact. Find where the build gets its version, fix it on the release branch, commit, build and install again. When it's a constant `init` listed as looking like a version, run the same bump again with `--apply --also <file>:<line>`: it commits that line on the release branch, at the version the run already chose.
- **A .NET tool's command isn't found:** the package installs the command its project file declares (`ToolCommandName`, else the assembly's name). `init` and `smoke` say when the assembly or the README uses another name; fix whichever is wrong on the release branch.
- **The fix is more than the version or the changelog:** a small packaging fix that the release can't ship without (a file left out of the package, an entry point, a version read from the wrong place) goes on the release branch, one commit each through `release.py commit`, and gets its own changelog entry if users would notice. Anything bigger is the blocker: stop and report it.
- **A dependency isn't available offline:** use `--wheelhouse` with a folder made from the release's own requirements, or `--net` with a decision saying why.
- **The command ran from outside the sandbox:** the release didn't install a command where users would find it (a missing entry point, a bin not linked). That's a real bug in the release; fix it.
- **The gate says the build is stale:** the branch moved after the build (a changelog fix, say). Build and install again; that's the point.
- **`bump --apply` refuses uncommitted changes:** ask the user whether they belong in this release. Never commit them to their branch or stash them for them.
- **The tag already exists**, locally or on the remote: someone released this version. Ask; usually the next version is the answer.
- **The project signs commits or tags:** commits use the user's git config as it is, and the plan uses `git tag -s`. Never bypass signing; if it can't sign unattended, stop and record it.
- **The real project changed and you didn't do it:** `guard` says what. Undo it, tell the user, and say which step did it.
- **An agent wrote no usable `reply.json`:** send the same brief to a fresh agent once. If that fails too, note the gap in the report.
Files in this package (7)
- SKILL.md 26 KB
- references/briefs.md 9 KB
- references/checks.md 12 KB
- references/recipes.md 9 KB
- scripts/kit.py 122 KB
- scripts/release.py 286 KB
- scripts/run.py 19 KB
Versions
The database has no other skills named killer-release.
Database snapshot: 13.11.2026 · package version 52b1e036a1ad (SHA-256 digest of the entire package)
Downloads in the last 30 days: 0 · ranking
Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.
Similar skills
- 100hatch3r-release
Cuts a release with version bump, changelog, tagging, and deploy verification. Use when preparing a release, cutting a version, or deploying to production. - 100release-this
Orchestrates the full powerball-harness plugin release with build, validation, version bump, CHANGELOG, tag, and GitHub Release. Use when releasing this plugin. - 100releasing
Full release lifecycle — version bump, CHANGELOG, rich release notes, tag, publish. Use when user says "release", "tag and release", "publish version", "cut a release", "new version". - 96release
Cut a prismantis release - version bump, changelog, verify, tag and push. Use when asked to "release", "bump the version", "ship 0.x" or "publish". - 86release
Prepare a ShapeBridge release - bump versions in all three manifests, move the changelog, tag, and explain the draft-release check. Use when asked to release, cut a version, bump the version or publish installers. - 100release-version
Use when releasing a new version - guides through version bump, changelog generation, commit grouping, tagging, and GitHub CI tracking. Triggers on "发布新版本", "release", "发版", or version release requests.