agentmachinist 0.1.0__tar.gz

agentmachinist-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,28 @@
+# Test suite for AgentMachinist itself. No secrets needed: the tests
+# never touch the network (gh and harness subprocesses are faked; git
+# tests run against local repos in tmp dirs).
+
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+
+      - name: Install dependencies
+        run: uv sync
+
+      - name: Run tests
+        run: uv run pytest

agentmachinist-0.1.0/.github/workflows/machinist-approve.yml

@@ -0,0 +1,31 @@
+# AgentMachinist — Phase 2 convenience: convert a '/machinist-execute'
+# comment on a machinist draft PR into the 'machinist:approved' label.
+#
+# Only comments from the repo owner, org members, or collaborators are
+# honored; anyone else commenting the command is ignored.
+
+name: Machinist Approve
+
+on:
+  issue_comment:
+    types: [created]
+
+permissions:
+  pull-requests: write
+  issues: write
+
+jobs:
+  approve:
+    if: >-
+      github.event.issue.pull_request
+      && startsWith(github.event.comment.body, '/machinist-execute')
+      && contains(fromJSON('["OWNER", "MEMBER", "COLLABORATOR"]'), github.event.comment.author_association)
+    runs-on: ubuntu-latest
+    steps:
+      - name: Apply approval label
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          gh pr edit ${{ github.event.issue.number }} \
+            --repo ${{ github.repository }} \
+            --add-label "machinist:approved"

agentmachinist-0.1.0/.github/workflows/release.yml

@@ -0,0 +1,31 @@
+# Publishes agentmachinist to PyPI when a GitHub Release is published.
+#
+# Uses PyPI Trusted Publishing (OIDC) — no API tokens stored anywhere.
+# One-time setup on pypi.org is required first; see README "Releasing".
+
+name: Release to PyPI
+
+on:
+  release:
+    types: [published]
+
+permissions:
+  contents: read
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write   # OIDC token for PyPI Trusted Publishing
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+
+      - name: Build sdist and wheel
+        run: uv build
+
+      - name: Publish to PyPI
+        run: uv publish --trusted-publishing always

agentmachinist-0.1.0/.gitignore

@@ -0,0 +1,19 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+dist/
+build/
+
+# Environments
+.venv/
+
+# Tooling
+.pytest_cache/
+.ruff_cache/
+
+# macOS
+.DS_Store
+
+# Machinist runtime state (consumer repos keep specs; this repo doesn't run itself)
+.machinist/runs/

agentmachinist-0.1.0/.machinist/specs/issue-1-spec.md

@@ -0,0 +1,62 @@
+# Spec: Create a friendly user-guide for AgentMachinist (#1)
+
+## Summary
+
+Write a beginner-friendly "Getting Started with AgentMachinist" guide as a new `docs/getting-started.md`, walking a newcomer from zero to their first harness-generated spec PR, and link it from `README.md`. The guide documents only what actually ships in v0.1 (`machinist init` and `machinist spec <n>`), clearly marks `watch`/`run`/`status` as upcoming, and is backed by drift tests so its commands and config examples can never silently diverge from the code.
+
+## Requirements
+
+The issue asks for "a Getting started with AgentMachinist guide that will allow anyone to be able to leverage this build system." Interpretation chosen: a single in-repo Markdown guide (no docs-site generator), aimed at a developer who knows git and GitHub but has never seen AgentMachinist, documenting the current v0.1 behavior truthfully rather than the full three-phase vision as if it were done.
+
+1. A guide exists at `docs/getting-started.md` and covers, in order: what AgentMachinist is (the three-phase issue → spec → approve → execute pipeline, and that the agent never merges), prerequisites, installation, repository setup with `machinist init`, running a first task with `machinist spec <n>`, reviewing and approving via the `machinist:approved` label or `/machinist-execute` comment, local vs. CI spec generation, a full `machinist.yaml` configuration reference, harness selection, troubleshooting, and current v0.1 limits.
+2. Every `machinist <subcommand>` the guide mentions is a real command registered on the Click group in `src/machinist/cli.py` (`init`, `spec`, `watch`, `run`, `status`), and every flag shown (`--force`, `--workflows/--no-workflows`, `--version`) exists.
+3. Every fenced ```yaml block in the guide validates against `MachinistConfig` from `src/machinist/config.py` (all fields have defaults, so partial top-level snippets validate too; `extra="forbid"` catches typos).
+4. The configuration reference documents every key in the packaged template `src/machinist/templates/machinist.yaml`, including defaults and the validated ranges from `config.py` (`timeout_minutes` 1–240, `spec_timeout_minutes` 1–60, `poll_interval_seconds` ≥ 10, `repo` shaped `owner/repo`).
+5. The troubleshooting section covers the real failure modes and quotes the actual error text users will see: missing config (`machinist.yaml not found. Run 'machinist init' first.` from `config.py`), missing `gh` (`github.py`), missing harness executable (`harness/base.py`), harness timeout, empty spec (`phases/spec.py`), and a leftover workspace (`workspace <path> already exists; remove it (or 'git worktree remove' it) and retry` from `workspace.py`).
+6. Commands not yet implemented (`watch`, `run`, `status` — all raise "not implemented" in `cli.py`) are presented in a clearly labeled "What's next" section, matching the milestones in `docs/superpowers/specs/2026-08-16-agentmachinist-design.md`, never as working features.
+7. `README.md` links to `docs/getting-started.md` near the top; existing README content is otherwise unchanged.
+8. Drift tests in a new `tests/test_docs.py` enforce requirements 1–3 and 7, and the full suite stays green.
+
+## Proposed approach
+
+**New: `docs/getting-started.md`** — the guide itself, ~250–350 lines, friendly second-person prose. Section plan, grounded in the code:
+
+1. **What is AgentMachinist?** — reuse the ASCII pipeline diagram style from `README.md`; emphasize the human-in-the-loop guarantees (spec approved before code, PR reviewed before merge).
+2. **Before you begin** — prerequisites with verification commands: `git`, authenticated `gh` (`gh auth status`), `uv`, and at least one harness CLI (`claude`, `opencode`, `pi`, `codex` — the `default_command` values in `src/machinist/harness/*.py`).
+3. **Install** — `uv tool install` per README's Install section; verify with `machinist --version` (works via `click.version_option(package_name="agentmachinist")` in `cli.py`).
+4. **Set up your repository** — run `machinist init`; explain each artifact it writes (`machinist.yaml`, `.machinist/specs/`, `.github/workflows/machinist-spec.yml`, `machinist-approve.yml`) and the printed "Next steps"; cover `--no-workflows` and `--force`; note the `ANTHROPIC_API_KEY` secret is only needed for the CI path.
+5. **Your first agent task** — create an issue, label it `agent-task`, run `machinist spec <n>`; narrate what happens using `phases/spec.py` as ground truth: isolated worktree under `~/.machinist/workspaces`, harness runs in read-only print mode, spec lands at `.machinist/specs/issue-<n>-spec.md` on branch `agent/issue-<n>`, draft PR titled `Spec: <title> (#<n>)` with `Closes #<n>`.
+6. **Review and approve** — read the spec in the PR's Files changed; apply `machinist:approved` or comment `/machinist-execute`; note the OWNER/MEMBER/COLLABORATOR restriction from `machinist-approve.yml`.
+7. **What's next (v0.1 status)** — `run`, `watch`, `status` are stubs today; link the design doc's milestones.
+8. **Configuration reference** — one annotated full-config yaml block (kept identical in spirit to `src/machinist/templates/machinist.yaml`) plus a prose walkthrough of each section, including workspace strategies/cleanup policies and the test gate.
+9. **Troubleshooting** — table of symptom → cause → fix using the real exception messages listed in requirement 5.
+
+**Edit: `README.md`** — add one line under the intro paragraph: `New here? Start with the [Getting Started guide](docs/getting-started.md).` Nothing else moves.
+
+**New: `tests/test_docs.py`** — follows the existing test style (plain functions, stdlib + project imports, like `tests/test_cli.py`):
+- `test_guide_exists_with_required_sections` — asserts the file exists and contains the required section headings.
+- `test_readme_links_to_guide` — asserts `docs/getting-started.md` appears in `README.md`.
+- `test_guide_subcommands_are_real` — regex `machinist ([a-z][a-z-]*)` over the guide; every captured subcommand must be in `main.commands` (import `main` from `machinist.cli`).
+- `test_guide_yaml_blocks_validate` — extract every ```yaml fenced block, `yaml.safe_load` it, and `MachinistConfig.model_validate` it; mirrors the existing `test_init_template_round_trips_through_schema` pattern so schema drift fails loudly. Guide convention (stated in a comment): yaml snippets are always rooted at the top level.
+- `test_guide_uses_real_label_names` — asserts `agent-task` and `machinist:approved` appear, guarding against label renames leaving the docs stale.
+
+Per the project's TDD convention, `tests/test_docs.py` is written first (red), then the guide and README link make it green.
+
+## Testing plan
+
+- **Automated:** `uv run pytest` (the repo's own `machinist.yaml` test gate; `pyproject.toml` sets `testpaths = ["tests"]`, `-q`). The five new tests in `tests/test_docs.py` prove requirements 1–3, 5 (heading/section presence), 7, and 8; the existing 59 tests must stay green.
+- **Manual smoke:** in a scratch git repo, follow the guide verbatim through section 4 (`uv tool install` → `machinist --version` → `machinist init` → inspect written files) confirming every command and output matches. The `machinist spec` walkthrough is verified against `phases/spec.py` and `tests/test_spec_phase.py` behavior rather than a live run, since a live run creates a real PR.
+- **Review check:** diff the guide's config reference against `src/machinist/config.py` field-by-field to confirm defaults and ranges (requirement 4).
+
+## Out of scope
+
+- No docs-site generator (MkDocs/Sphinx), hosting, or publishing pipeline — one Markdown file only.
+- No screenshots, video, or diagrams beyond ASCII.
+- No documentation of `watch`/`run`/`status` behavior beyond the roadmap note; no changes to CLI code, templates, or workflows.
+- No restructuring of `README.md` beyond adding the link; no changes to the design doc under `docs/superpowers/specs/`.
+- No translations.
+
+## Open questions
+
+1. Is `agentmachinist` actually published to PyPI? `README.md` offers both `uv tool install agentmachinist` and the `git+https://github.com/vscarpenter/AgentMachinist` fallback; the guide should lead with whichever actually works today.
+2. Should the guide live at `docs/getting-started.md` (proposed) or replace/absorb parts of `README.md`? The proposal keeps README as the terse front door and the guide as the narrative walkthrough.

agentmachinist-0.1.0/AgentMachinist-Prompt.md

@@ -0,0 +1,37 @@
+You are an expert systems engineer and developer tools architect. I want you to help me build a local-first, open-source agentic build and CI/CD system called **AgentMachinist**. 
+
+AgentMachinist enables a solo developer working on a Mac to bridge GitHub issues with local coding harnesses (like Claude Code, OpenCode, PI, or Codex). 
+
+Please review the core architecture below and help me implement the initial project structure, configuration files, and automation scripts.
+
+---
+
+### Core Architecture & Workflow Requirements
+
+1. **The Harness Abstraction Layer (`machinist.yaml`)**
+   - Create a configuration schema and parser that defines which coding harness to use (`claude-code`, `opencode`, `pi`, `codex`), timeout settings, and workspace rules.
+
+2. **Phase 1: GitHub Issue Ingestion & Spec Generation**
+   - Write a script or GitHub Action workflow template that triggers upon GitHub issue creation (or when an `agent-task` label is applied).
+   - The script should invoke the configured harness to read the issue and generate an implementation spec and plan saved to a dedicated directory (e.g., `.machinist/specs/issue-<number>-spec.md`).
+   - It must automatically create a new git branch (`agent/issue-<number>`), commit the spec file, and **open a Draft Pull Request** on GitHub referencing the original issue.
+
+3. **Phase 2: Human Review & Approval Mechanism**
+   - Define how approvals are tracked (e.g., transitioning the Draft PR to "Ready for Review" or detecting a specific label/comment like `/machinist-execute`).
+
+4. **Phase 3: Local Execution Daemon / CLI (`machinist`)**
+   - Build a lightweight local command-line interface (written in Python, Node, or Go—let's discuss or use a clean Python/Click or Go structure) that can run on my Mac.
+   - The CLI should have commands like:
+     - `machinist init`: Sets up `machinist.yaml` and local directories.
+     - `machinist watch`: Polls or listens for approved PRs/labels on GitHub.
+     - `machinist run <issue-number>`: Pulls the approved spec branch locally, invokes the local coding harness (e.g., executing Claude Code or the chosen CLI tool headlessly or interactively with the spec), runs tests, and pushes the implementation commits back to the PR branch.
+
+---
+
+### Your Immediate Task
+1. Propose the optimal technology stack (e.g., Python or TypeScript) for the local CLI and GitHub integration.
+2. Outline the directory structure for the AgentMachinist repository.
+3. Write the initial code for `machinist.yaml` schema, the core CLI entrypoint, and the GitHub API wrapper for handling Draft PR creation.
+
+Let's start step-by-step. Give me the project layout and the core bootstrapping code first.
+

agentmachinist-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Vinny Carpenter
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

agentmachinist-0.1.0/PKG-INFO

@@ -0,0 +1,131 @@
+Metadata-Version: 2.5
+Name: agentmachinist
+Version: 0.1.0
+Summary: Local-first agentic build & CI/CD: bridge GitHub issues to local coding harnesses
+Project-URL: Homepage, https://github.com/vscarpenter/AgentMachinist
+Project-URL: Repository, https://github.com/vscarpenter/AgentMachinist
+Project-URL: Issues, https://github.com/vscarpenter/AgentMachinist/issues
+Author-email: Vinny Carpenter <vscarpenter@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agents,ci,claude-code,developer-tools,github
+Requires-Python: >=3.12
+Requires-Dist: click>=8.1
+Requires-Dist: pydantic>=2.7
+Requires-Dist: pyyaml>=6.0
+Description-Content-Type: text/markdown
+
+# AgentMachinist
+
+Local-first agentic build & CI/CD for solo developers. AgentMachinist bridges
+GitHub issues to local coding harnesses — Claude Code, OpenCode, PI, or
+Codex — through a three-phase, human-in-the-loop pipeline that runs on your Mac.
+
+New here? Start with the [Getting Started guide](docs/getting-started.md).
+Prefer a visual tour? Open [`docs/onboarding.html`](docs/onboarding.html) in a
+browser — a self-contained illustrated handbook of the pipeline and its
+principles.
+
+```
+ GitHub issue (label: agent-task)
+        │
+        ▼
+ Phase 1 · SPEC        harness writes .machinist/specs/issue-<n>-spec.md
+        │              → branch agent/issue-<n> → draft PR (Closes #<n>)
+        ▼
+ Phase 2 · APPROVE     you review the spec; apply label machinist:approved
+        │              (or comment /machinist-execute on the PR)
+        ▼
+ Phase 3 · EXECUTE     local daemon implements the spec in an isolated
+                       worktree, runs your tests, pushes to the PR branch,
+                       and marks it ready for review
+```
+
+The agent never merges anything. You approve the spec before code is written,
+and you review the PR before it lands.
+
+## Install
+
+```sh
+uv tool install agentmachinist        # or: uv tool install git+https://github.com/vscarpenter/AgentMachinist
+```
+
+Prerequisites: [`gh`](https://cli.github.com) (authenticated), `git`, and at
+least one coding harness CLI (`claude`, `opencode`, `pi`, or `codex`).
+
+## Quickstart
+
+In the repository you want agents to work on:
+
+```sh
+machinist init          # writes machinist.yaml, .machinist/, and GitHub workflows
+machinist spec 42       # Phase 1 for issue #42 (or let `watch` pick it up)
+machinist watch         # daemon: polls for labeled issues and approved PRs
+machinist run 42        # Phase 3 for an approved spec
+```
+
+## Configuration (`machinist.yaml`)
+
+```yaml
+version: 1
+harness:
+  name: claude-code            # claude-code | opencode | pi | codex
+  command: null                # optional executable override
+  timeout_minutes: 30          # Phase 3 implementation budget
+  spec_timeout_minutes: 10     # Phase 1 spec budget
+github:
+  repo: null                   # "owner/repo"; null = derived from origin
+  labels:
+    trigger: agent-task
+    approved: "machinist:approved"
+  poll_interval_seconds: 60
+workspace:
+  root: ~/.machinist/workspaces
+  strategy: worktree           # worktree | clone
+  cleanup: on_success          # always | on_success | never
+  branch_prefix: agent/
+tests:
+  command: null                # e.g. "pytest -q"; null skips the test gate
+```
+
+Unknown keys are rejected — typos fail loudly instead of being ignored.
+
+## How approval works
+
+The single source of truth is the `machinist:approved` label on the draft PR.
+Apply it by hand, or comment `/machinist-execute` on the PR — the bundled
+`machinist-approve.yml` workflow converts that comment into the label (only
+for repo owners, members, and collaborators). Draft → Ready for Review is
+reserved as the *agent's* signal that implementation is complete.
+
+## Spec generation: local or CI
+
+Both paths run the same `machinist spec <n>` command:
+
+- **Local (default):** `machinist watch` sees the `agent-task` label and
+  generates the spec on your machine using your existing harness login.
+- **CI:** the bundled `machinist-spec.yml` workflow runs it in GitHub Actions
+  when an issue is labeled — works while your Mac sleeps, but requires an
+  `ANTHROPIC_API_KEY` repository secret.
+
+## Status
+
+v0.1 (M3): all three phases work end-to-end — `init`, `spec`, `run`,
+`status`, and the `watch` daemon (`--once` for a single cron-friendly pass).
+The pipeline has dogfooded itself: its own getting-started guide was specced,
+approved, implemented, test-gated, and merged by the pipeline (issue #1 →
+PR #3). See `docs/superpowers/specs/` for the design.
+
+## Releasing (maintainer notes)
+
+Publishing uses [PyPI Trusted Publishing](https://docs.pypi.org/trusted-publishers/)
+— no tokens. One-time setup: on pypi.org under *Publishing*, add a pending
+publisher for project `agentmachinist` (owner `vscarpenter`, repo
+`AgentMachinist`, workflow `release.yml`, environment `pypi`). After that,
+each release is: bump `version` in `pyproject.toml`, commit, then create a
+GitHub Release for tag `v<version>` — the release workflow builds and
+publishes automatically.
+
+## License
+
+MIT — see [LICENSE](LICENSE).

agentmachinist-0.1.0/README.md

@@ -0,0 +1,114 @@
+# AgentMachinist
+
+Local-first agentic build & CI/CD for solo developers. AgentMachinist bridges
+GitHub issues to local coding harnesses — Claude Code, OpenCode, PI, or
+Codex — through a three-phase, human-in-the-loop pipeline that runs on your Mac.
+
+New here? Start with the [Getting Started guide](docs/getting-started.md).
+Prefer a visual tour? Open [`docs/onboarding.html`](docs/onboarding.html) in a
+browser — a self-contained illustrated handbook of the pipeline and its
+principles.
+
+```
+ GitHub issue (label: agent-task)
+        │
+        ▼
+ Phase 1 · SPEC        harness writes .machinist/specs/issue-<n>-spec.md
+        │              → branch agent/issue-<n> → draft PR (Closes #<n>)
+        ▼
+ Phase 2 · APPROVE     you review the spec; apply label machinist:approved
+        │              (or comment /machinist-execute on the PR)
+        ▼
+ Phase 3 · EXECUTE     local daemon implements the spec in an isolated
+                       worktree, runs your tests, pushes to the PR branch,
+                       and marks it ready for review
+```
+
+The agent never merges anything. You approve the spec before code is written,
+and you review the PR before it lands.
+
+## Install
+
+```sh
+uv tool install agentmachinist        # or: uv tool install git+https://github.com/vscarpenter/AgentMachinist
+```
+
+Prerequisites: [`gh`](https://cli.github.com) (authenticated), `git`, and at
+least one coding harness CLI (`claude`, `opencode`, `pi`, or `codex`).
+
+## Quickstart
+
+In the repository you want agents to work on:
+
+```sh
+machinist init          # writes machinist.yaml, .machinist/, and GitHub workflows
+machinist spec 42       # Phase 1 for issue #42 (or let `watch` pick it up)
+machinist watch         # daemon: polls for labeled issues and approved PRs
+machinist run 42        # Phase 3 for an approved spec
+```
+
+## Configuration (`machinist.yaml`)
+
+```yaml
+version: 1
+harness:
+  name: claude-code            # claude-code | opencode | pi | codex
+  command: null                # optional executable override
+  timeout_minutes: 30          # Phase 3 implementation budget
+  spec_timeout_minutes: 10     # Phase 1 spec budget
+github:
+  repo: null                   # "owner/repo"; null = derived from origin
+  labels:
+    trigger: agent-task
+    approved: "machinist:approved"
+  poll_interval_seconds: 60
+workspace:
+  root: ~/.machinist/workspaces
+  strategy: worktree           # worktree | clone
+  cleanup: on_success          # always | on_success | never
+  branch_prefix: agent/
+tests:
+  command: null                # e.g. "pytest -q"; null skips the test gate
+```
+
+Unknown keys are rejected — typos fail loudly instead of being ignored.
+
+## How approval works
+
+The single source of truth is the `machinist:approved` label on the draft PR.
+Apply it by hand, or comment `/machinist-execute` on the PR — the bundled
+`machinist-approve.yml` workflow converts that comment into the label (only
+for repo owners, members, and collaborators). Draft → Ready for Review is
+reserved as the *agent's* signal that implementation is complete.
+
+## Spec generation: local or CI
+
+Both paths run the same `machinist spec <n>` command:
+
+- **Local (default):** `machinist watch` sees the `agent-task` label and
+  generates the spec on your machine using your existing harness login.
+- **CI:** the bundled `machinist-spec.yml` workflow runs it in GitHub Actions
+  when an issue is labeled — works while your Mac sleeps, but requires an
+  `ANTHROPIC_API_KEY` repository secret.
+
+## Status
+
+v0.1 (M3): all three phases work end-to-end — `init`, `spec`, `run`,
+`status`, and the `watch` daemon (`--once` for a single cron-friendly pass).
+The pipeline has dogfooded itself: its own getting-started guide was specced,
+approved, implemented, test-gated, and merged by the pipeline (issue #1 →
+PR #3). See `docs/superpowers/specs/` for the design.
+
+## Releasing (maintainer notes)
+
+Publishing uses [PyPI Trusted Publishing](https://docs.pypi.org/trusted-publishers/)
+— no tokens. One-time setup: on pypi.org under *Publishing*, add a pending
+publisher for project `agentmachinist` (owner `vscarpenter`, repo
+`AgentMachinist`, workflow `release.yml`, environment `pypi`). After that,
+each release is: bump `version` in `pyproject.toml`, commit, then create a
+GitHub Release for tag `v<version>` — the release workflow builds and
+publishes automatically.
+
+## License
+
+MIT — see [LICENSE](LICENSE).