Knowledge management for markdown knowledge bases ("brains"): a Claude Code skill, and the km command and GitHub Action that keep a brain consistent.
- Answer a question from the brain, with sources, also from its open pull requests. GitHub reads use
gh, or GitHub MCP tools whereghis not signed in. - Save a note, decision or meeting transcript with validated frontmatter, in the right folder.
- Update or supersede a page, lint the brain, mount peer brains as submodules.
- Contribute to a brain you only read, as a pull request.
- Set up a shared team brain: one maintainer merges, the team reads the repo, CI validates every PR, keeps each folder's
_index.mdgenerated and reachable, builds a per-audience bundle for AI tools, and demotes accepted docs whose review date has lapsed.
As a Claude Code plugin:
/plugin marketplace add pasrom/km
/plugin install km@km
/km init # bootstrap a personal knowledge repo
/km init --team # bootstrap a shared team brain
/km What do we know about thermal management? # search and summarize
/km We decided to use LTC6813 # save content (auto-detects type)
/km update sensor-fusion: add calibration # modify a document
/km brain add https://github.com/org/team-brain.git # mount another brain
/km @all Zephyr RTOS # search all mounted brains
/km upgrade # move the brain to the installed km version
/km queue # what waits for review: docs and open PRs
/km check my setup # what this computer still needs for the brain (km doctor)
/km sync # bring this copy and a fork up to the upstream brain
/km help # all commandsCross-repo brains: other knowledge repos are mounted as git submodules under brains/. Each brain keeps its own access permissions, is read at the commit the brain pins (km sync keeps the checkout there; a pin moves only through a pull request), and every answer cites [brain@commit].
km validate [FILE ...] frontmatter, links, the gate, index completeness; --signoff-since BASE: every changed doc signed off
km gen-index [--check] regenerate every '## Documents' list in _index.md
km demote [--apply] demote served docs past their review date
km demote DOC... send accepted docs back to review now, e.g. in the commit that changes them
km serve build the per-audience bundle under dist/served/
km promote ... move a note into the brain as a review doc
km approve DOC... --by WHO sign review docs off; ai:<model> where CONVENTIONS allow an AI sign-off
km repin DOC... pin a doc's sources and translates to their current content
km repin --cites DOC... (--file URL=PATH ... | --dir LOCAL=URLPREFIX ...)
re-pin the external files a doc cites against local copies
km cite add DOC URL --file COPY [--title T] [--version V]
record an external file (SharePoint, OneDrive) by the sha256 of a local copy
km cites check [DOC...] (--file URL=PATH ... | --dir LOCAL=URLPREFIX ...)
compare cited files with local copies: current, stale, unchecked
km init DIR [--team ...] create a brain from the templates
km upgrade move a brain's km pins to this version
km doctor [--offline] check this computer is set up for the brain
km sync [--quiet] [--offline] [--max-age 15m]
bring this copy, a fork and the mounted brains up to the upstream brain
km list [PATH...] [filters] docs from their frontmatter: --status, --signoff, --due DATE, --json
km ready REPO N [--head SHA] whether a pull request's km:ready label counts for /km queue
km sync keeps a copy from going stale. Its upstream is the remote named upstream where one exists, else the parent of a fork (asked of gh), else origin. It fetches, and then only ever fast-forwards: the default branch when it is checked out and the tree has no uncommitted changes; a fork's default branch on the host (gh repo sync; a plain push, which git refuses unless it is a fast-forward, only where gh is not installed); the mounted brains, to the commit the brain pins when they are behind it (a pin never moves here, that stays with the host's automation and a reviewed pull request). A work branch, a dirty tree, a branch that diverged or a mount moved past its pin is reported with how far behind it is, never rebased, reset or moved back. --quiet prints only what changed or needs attention, --max-age 15m makes a repeated run free, and an unreachable remote is a note, not a failure. The plugin runs km sync --quiet --max-age 15m when a Claude Code session starts in a brain (hooks/hooks.json), so what it reports is in Claude's context from the first prompt; outside a brain, without network or without km the hook is silent.
km ready decides for /km queue whether a km:ready label counts: applied last by a person other than the pull request's author, it does; applied by the author, a bot or an app, when the pull request touches no control file and every doc it changes is at approval level ai at its head and, where it was there, at the base. If your change touches no control file and every changed page is at level ai, your own label is enough; images, PDFs or a script next to the pages do not stop it. Control files are what CI runs or reads and what steers an agent, an editor or a hook on a contributor's machine, by a structural rule (in src/km/ready.py): any path with a segment that starts with a dot (.github/, .gitmodules, .pre-commit-config.yaml, .claude/, .vscode/, .husky/, .envrc, ...), any file at the top of the repository that is not a doc (schema.local.yaml, CLAUDE.md, a Makefile, a README), CLAUDE.md, AGENTS.md, GEMINI.md and CONVENTIONS.md at any depth, scripts/ (where a brain from the copy-in days keeps the km scripts its CI runs), dist/ and the gate's forbidden_terms_file, on either side of a rename; also a changed submodule, and any symlink in the brain. Files in the doc folders (images, PDFs, a generator script in _media/) are not control files. An _index.md whose text outside its ## Documents list is unchanged is left aside; any other _index.md change is level human, since km validate checks no sign-off on an index. The levels are read from GitHub with gh, without checking the pull request out, with the brain's settings from schema.local.yaml at the base. Anything it cannot read or decide counts as level human. It prints one line and exits 0 when the label counts, 1 when not (also for a broken local schema.local.yaml, which the line names).
km doctor reads what to expect from the brain alone: its origin and upstream (the same upstream km sync follows: on a fork, both the checked-out branch and the fork's default branch on the host must have everything the upstream brain has), the brains it mounts (.gitmodules), the km version it pins, and the plugins its .claude/settings.json enables (enabledPlugins, with the marketplaces in extraKnownMarketplaces). A brain lists its plugins there for Claude Code anyway, which offers to add the marketplace when the folder is trusted. It also checks that the pre-commit hook is installed, that text files keep LF line endings, and, for a brain on GitHub, that gh is signed in, that git pushes to an https origin with gh's login (gh auth setup-git), and whether you push to the brain or through a fork. A brain may mount a repository some of its readers cannot read: a mount this computer leaves out (git config submodule.<name>.update none, or set inactive) is then a note, not a failure, and km sync does not check it out; one never initialised that cannot be read is a note too, which names that setting (km sync would try to check it out). Each check that fails names its fix; it needs no PyYAML, so it also runs on a computer that is half set up.
Every command takes --root DIR; the default is the git work tree around the current directory. Install a release by its commit (git ls-remote https://github.com/pasrom/km refs/tags/v1.23.0 shows it), not by the tag: pip install git+https://github.com/pasrom/km@<commit> # v1.23.0, or run it without installing: uvx --from git+https://github.com/pasrom/km@<commit> km validate # v1.23.0.
Brains carry no km code (the one exception, the script of the mounted-pins workflow, is below; the approve-fork-ci and review-request-guide workflows are km's shell, kept up to date the same way). km init writes CONVENTIONS.md, CLAUDE.md, schema.local.yaml, inbox/, a .gitattributes that keeps text files LF, and a pre-commit hook pinned to a km version. km init --team adds domain folders with generated indexes, a README, and CI that installs km through this repository's GitHub Action:
- uses: pasrom/km@<commit> # v1.23.0, installs the km CLI at that commit
- run: km validate
- run: km gen-index --checkThe team brain's ci workflow also runs on workflow_dispatch: a pull request that a workflow opens with GITHUB_TOKEN starts no pull_request run, so such a workflow (a pin bump, say) dispatches ci on its branch and the pull request gets its check. km upgrade adds the trigger to a km ci workflow that lacks it.
On a pull request, and on such a dispatched run, the ci workflow runs km validate --signoff-since against the base branch: every doc the pull request adds or changes must be signed off at its level (km approve, or for a doc a person signs off, status: review with the AI review in reviewed_by), so an unsigned doc cannot be merged while the check is green. A copy of an approved doc at a new path is no exception: the approval binds the text, not the path, so the copy needs a sign-off of its own in the pull request; a moved doc keeps its approval while its approved text is the one it had and the old path no longer holds it (a stub belongs in a commit of its own after the move). A new doc goes in review first and is approved in a separate commit. km upgrade turns it on in a km ci workflow that lacks it.
A team brain also gets approve-fork-ci. A fork pull request from a member with read access waits for "Approve and run" before ci starts; this workflow, on pull_request_target and without checking out the fork's code, approves that run when the pull request touches no control file, by the rule km ready uses: no path with a segment that starts with a dot (.github/, .gitignore, .claude/, ...), no file at the top that is not Markdown, no agent instructions or CODEOWNERS at any depth, nothing under scripts/ or dist/, no symlink or submodule. A script or other file in a doc folder (a generator in _media/) does not stop it: km's ci runs nothing from the checkout, and from km 1.11.0 on km keeps the checkout off sys.path; beside a pin to an older km, km init leaves the workflow out and km upgrade does not add it, removes km's copy, keeps an earlier data-only one and warns about one the brain changed. Every pull request from the branch must target the default branch and never have changed its base, with exactly one open. It approves only a ci run made for this event, since a fork's run names no pull request and a closed one or an older base could share it. Anything else waits for a person. km upgrade adds it only to a team brain whose ci.yml is km's as YAML reads it, but for its action pins and branch name (a ci with steps of the brain's own would run fork code unreviewed: it gets a note instead). Like bump-mounted-pins it replaces a copy that is still a version km shipped, so security fixes reach the brain, and leaves one the brain changed with a note; to take km's version, delete the copy and run km upgrade. It also notes a copy that sits beside a ci.yml that is not km's.
A team brain also gets review-request-guide. The maintainer merges pull requests labelled km:ready; the AI review (/km pr, recorded in reviewed_by) and the sign-off at each doc's level come first, a doc at level human signed off by any team member who knows its subject. When a maintainer is requested as reviewer on a pull request that is not km:ready, this workflow (on pull_request_target, reading the head commit's docs from the API without checking out or running them, and parsing only their frontmatter) posts one comment, updated on later requests and turned into a short note once the pull request is labelled km:ready, that lists the changed docs with no AI review recorded and those not signed off with their level, and the next steps. It leaves the review request in place. A fork author can request a reviewer only with the triage role or higher. It does nothing until the repository variable KM_MAINTAINERS names the maintainers' GitHub logins (spaces or commas between them). km upgrade adds it to a team brain that lacks it and replaces a copy that is still a version km shipped, like approve-fork-ci.
A team brain also gets automerge, off until the repository variable KM_AUTOMERGE is 1, and with km 1.20.0 or later pinned in ci.yml (the version the pin's comment names, else the one src/km/__init__.py names at that commit; an older or unknown one merges nothing, with a notice). Then a pull request that needs no person's judgement lands without the maintainer: after ci completes on a pull request, when km:ready is applied, when a draft is marked ready, or run by hand with a number, it asks km automerge and merges by rebase, at exactly the head it judged, only when all of these hold: the pull request is open, not a draft, and its base is the default branch and was never changed; it is labelled km:ready and the label counts on km ready's levels path, no control file changed and every changed doc at level ai at its head and at the default branch's tip (levels and schema.local.yaml read there), whoever set the label (a label that counts only because another person set it, on a doc at level human or a control file, stays the maintainer's merge); narrower than km ready, every other changed file is a media file (images, PDF, CSV, TSV; SVG counts as media, it is never rendered by CI or the bot, only a person opening the file in a browser would run what it holds), so a script beside a page, a hook or a Makefile waits for a person; the last Last reviewed: line of its body is the full head sha; the default branch's ci.yml runs the sign-off check, and on exactly the head commit (its check runs and commit statuses, not the pull request's checks, which follow a later push) every check run of ci passed, its sign-off job validate among them, and every other check passed or was skipped, only the newest run of each check name counting (a fork's ci run waiting for approval is no check), the ci run is the pull request's own (not a dispatched one), and the head carries the default branch's ci.yml (the same blob, so a branch from before a change to ci.yml is brought up to date first); a failed ci check run of another check suite on the same commit keeps blocking until a new push; no reviewer's latest review requests changes; and nothing of this moved while it was read. Otherwise it posts one comment, updated in place, with one line per condition that does not hold. It never checks out or runs the pull request's code: km runs at the commit the default branch's ci.yml pins, in a job with a read-only token, and a separate job that runs no km reads the pull request and the default branch again and merges. The act job reads the pull request, its reviews and the default branch again right before the merge. A merge made with GITHUB_TOKEN starts no workflow, so no push run of ci (the served bundle) or main-guard follows it until the next push to main by a person; likewise a km:ready label a workflow applies with GITHUB_TOKEN starts no run. Optionally it merges with a GitHub App's token instead, whose merge starts ci and main-guard on main once its App and environment are set up as in GitHub Apps for the team workflows. Only the act job uses that environment, and only to merge; it mints a token for this repository alone with Contents write only, merges with it and comments with GITHUB_TOKEN; with the secrets missing or no token minted it merges with GITHUB_TOKEN and then fails the run, as no push run follows. The push runs end there: ci on a push starts no automerge run. km upgrade adds it only beside km's own ci.yml, and replaces a copy that is still a version km shipped, like approve-fork-ci.
A team brain also gets bump-mounted-pins, a workflow that moves the pins of the mounted brains (submodules) by pull request, in place of Dependabot's submodule updates, which need an organisation-wide grant for private submodules and stop every submodule of a group on one refusal. On weekday mornings it walks each mount's tracked branch (its branch =, else the repository's default branch) back from the tip to the newest commit whose CI on that branch did not fail (runs of a side branch or a tag do not count; a commit without a run of its own, such as a bot's, inherits the state of the nearest older commit that has runs; a pin never moves backwards), sets the gitlinks without cloning, force-pushes chore/bump-mounted-pins with a lease and opens or updates the pull request, which lists short shas only, and dispatches ci on it. A brain without mounts stops after reading .gitmodules. It reads the mounts with a GitHub App (Contents and Actions: read) whose secrets CI_APP_CLIENT_ID and CI_APP_PRIVATE_KEY live in an environment mounted-pins restricted to main; GitHub Apps for the team workflows says how to set it up. Its script, .github/scripts/bump-mounted-pins.py, is the one piece of km code a brain carries: the job that holds the app token installs nothing, so it cannot run the km package. km upgrade adds both files when missing and replaces a copy that is still a version km shipped, unchanged but for the action pins its Dependabot moves (a pin moved past the template's version is kept), so later fixes reach the brain; a copy the brain edited is its own, left alone with a note.
The pre-commit hook works the same way (repo: https://github.com/pasrom/km, rev: <commit> # frozen: v1.23.0, id: km-validate); a team brain's km entry also lists id: km-gen-index, which rewrites a stale _index.md list and so fails the commit (stage the index and commit again) instead of CI's km gen-index --check later. km upgrade adds it to a team brain once its pin moves to a km that has the hook. Every pin names a release by its commit, so a tag moved later cannot change what a brain runs; the version rides along as a comment, and km upgrade checks that the commit is that release's. km's own dependencies are pinned to exact versions. km init and km upgrade look a release's commit up by its tag once, so a release tag here must never be moved or deleted; a repository ruleset on v* makes sure of it. Dependabot and pre-commit autoupdate --freeze propose newer versions; /km upgrade moves the pins and turns a brain from the copy-in days into one that pins km.
A team brain also keeps direct pushes off main, which the host may not enforce for a private repository on a free plan: its pre-commit config adds no-commit-to-branch for main from pre-commit/pre-commit-hooks and a pre-push hook that refuses git push origin main (pre-commit install installs both, the config names both hook types and needs pre-commit 3.2 or newer; pre-commit checks the first ref of a push only and skips a push whose commits the remote already has on another ref, so a push of several refs at once or a first push of main gets past it), and a main-guard workflow fails and opens an issue when a commit reaches main without a merged pull request, except the first push into an empty repository (it creates main, which is then the only branch, and no pull request was ever opened). km upgrade adds whichever a team brain lacks, and replaces a main-guard copy that is still a version km shipped. The plugin itself refuses the file-edit tools (Edit, Write, MultiEdit, NotebookEdit) inside a mounted brain (a brain checked out as a submodule of a brain, found through git, not by path) and in a mount that is not checked out yet: a correction goes through a pull request against that brain, in a throwaway clone, as the skill describes; a shell edit is not caught.
Two team workflows use a GitHub App, each its own, kept apart in its own environment. Both environments hold secrets of the same names, CI_APP_CLIENT_ID (the App's client ID) and CI_APP_PRIVATE_KEY (its private key), so the names alone do not say which App a secret belongs to: the environment does. Each workflow's header repeats the steps for its own App, so a brain's copy describes itself at the km version it pins.
| Workflow | Environment | App permissions | Installed on | Needed |
|---|---|---|---|---|
bump-mounted-pins |
mounted-pins |
Contents: read, Actions: read | the owner of the brain, for the mounted repositories (or all) | before the first mount; until then the workflow does nothing |
automerge |
automerge |
Contents: read and write (a merge needs no more) | this brain only | optional; without it the merge starts no workflow |
Set each one up in this order:
- Create the GitHub App with the permissions in the table, install it as the table says, and generate a private key. Never give one App both roles: the read App reaches the mounted repositories, the write App only this brain.
- Settings, Environments, New environment, named as in the table; Deployment branches: selected branches, the default branch only (
mainformounted-pins, as its workflow names it). Create it before the workflow first names it: GitHub creates a missing environment on a workflow's first run, open to every branch. For an existing one, check its branches first. - In that environment, add the secrets
CI_APP_CLIENT_IDandCI_APP_PRIVATE_KEYof that workflow's App. - What the workflow itself still needs: for
bump-mounted-pins, the two repository settings its header lists (Actions may create pull requests; a review of the most recent push); forautomerge, the repository variableKM_AUTOMERGE_APPset to1(unset, no job names the environment).
km doctor notes a missing mounted-pins environment in a brain with mounts, and either environment when it is open to more than the default branch.
The runner is a setting of the brain: runner: <label> in schema.local.yaml (one runner label, my-runner say; unset, ubuntu-latest, GitHub's runners). km init --team --runner my-runner writes it; to change it later, edit the line and run km upgrade. km writes the label into the runs-on line of every job of the team workflows (ci, staleness, main-guard, approve-fork-ci, review-request-guide, automerge, bump-mounted-pins). The label is a literal in the workflow, not a variable, because a fork's pull request runs ci.yml as the pull request has it, the base branch's unless the fork changes it, and GitHub passes that run no repository or organisation variables unless "Send secrets and variables to workflows from fork pull requests" is on, which sends the secrets as well (observed on 2026-11-18: a fork's pull request ci run in a private repository with that option off ran on ubuntu-latest although the repository had KM_RUNNER set). km 1.22 read the variable KM_RUNNER instead, so a fork's ci fell back to GitHub's runners; km reads that variable nowhere now. The shipped workflows stay km's on any label. ci.yml is km's on the brain's runner (or ubuntu-latest, or km 1.22's line): with the setting, km upgrade moves km's ci.yml from another label to it; without the setting, a label set by hand makes ci.yml the brain's own, so km upgrade neither adds nor widens approve-fork-ci and automerge beside it and says how to take the label into the setting. An expression km did not write stays the brain's own until it is replaced by hand. A staleness.yml with a job besides km's demote keeps every runs-on, with a note.
Moving from km 1.22: km upgrade rewrites the runs-on: ${{ vars.KM_RUNNER || 'ubuntu-latest' }} line of km's ci.yml and staleness.yml, and the shipped workflows, to the brain's runner, and says so. A brain that set KM_RUNNER puts its value into schema.local.yaml as runner:, runs km upgrade (again) and deletes the variable; km doctor notes a KM_RUNNER it can still read, a workflow still reading it, and a team workflow on another runner than the setting. A ci.yml or staleness.yml that names a label by hand while schema.local.yaml names none is left as it is, with a note to move the label into the setting. Where the KM_RUNNER line was in use and no setting exists, the upgrade's first line says that every job now runs on ubuntu-latest, with the variable's value and the runner: line to add where gh can read it. bump-mounted-pins reads its own variable MOUNTED_PINS_RUNNER before the setting: it runs on a schedule and by hand, never on a pull request, so the variable always reaches it.
A plain Ubuntu 24.04 VM with git, curl and tar is enough for every workflow but bump-mounted-pins: its jobs run in a container, so its runner needs docker, usable by the runner's user; without docker set the repository variable MOUNTED_PINS_RUNNER to ubuntu-latest, and bump-mounted-pins stays on GitHub's runners. Each job that runs gh, jq or yq first fetches the ones the runner lacks (mikefarah's yq v4: Ubuntu's yq package is another program), pinned by version and sha256, into the job's temp folder, without sudo; that step runs only on a self-hosted runner (runner.environment), never on GitHub's. A runner image that has gh, jq and mikefarah's yq saves those downloads. Where the step fetches gh, that gh runs in jobs that hold a write GITHUB_TOKEN (automerge's act without the App, main-guard's issue), as a pinned action would. automerge's act job never fetches them where it merges with the App (KM_AUTOMERGE_APP): its token is not handed to a downloaded tool, so there the runner's image must have gh and jq, or nothing is merged and the run fails. The km action installs its Python with actions/setup-python, which needs a writable tool cache, network access to GitHub and PyPI, and a system its builds are made for (the Ubuntu versions of GitHub's runners, x64 or arm64; Ubuntu 24.04 is one). Those Linux builds find their libpython through a path into GitHub's tool cache, /opt/hostedtoolcache, fixed when they were built; in another tool cache, as a runner's own _work/_tool, they start only with their lib folder on LD_LIBRARY_PATH. setup-python sets that for the whole job, but the action keeps the job's environment as it is and so sets it in the km command alone (km and what it starts), where the interpreter needs it: the runner needs no AGENT_TOOLSDIRECTORY, no system Python, no python3-venv and no sudo. On a macOS runner, setup-python's builds need its tool cache at /Users/runner/hostedtoolcache (see setup-python's advanced usage, "Using setup-python with a self-hosted runner"). Every job has a timeout-minutes (15 at most), so a stuck job does not hold a runner for GitHub's default 6 hours.
Security: approve-fork-ci, review-request-guide and automerge run on pull_request_target and never check out the pull request's code, but ci does run on a fork's pull request, and with the runner setting it runs on your runner: a fork author's pull request runs on your hardware, in the network the runner sits in. A fork can also change runs-on in its copy of ci.yml; that is a control file, so approve-fork-ci leaves such a run to a person. GitHub starts a fork's run only as "Run workflows from fork pull requests" and the approval setting for outside contributors allow, and approve-fork-ci starts it without a person when the pull request changes no control file (ci then runs km on the fork's docs, nothing from the checkout). So set runner: to ephemeral, isolated runners only: one job per fresh VM, with a network that gives the job no more than it needs. On a persistent or non-isolated runner, leave the setting unset while approve-fork-ci auto-approves. km doctor names the runner the setting names, with this note.
.claude-plugin/ plugin and marketplace manifests
hooks/ the plugin's hooks: km sync when a session starts in a brain, no edit in a mounted brain
action.yml GitHub Action: installs km at the action's version
action/install.sh the action's install step
.pre-commit-hooks.yaml pre-commit hooks km-validate and km-gen-index
src/km/ the package: cli, validate, gen_index, demote, serve, promote, approve, repin, cite, cites, init, upgrade, doctor, sync, list_docs
src/km/templates/ what `km init` writes
skills/km/SKILL.md the skill's core: rules, a dispatch table, what every flow shares
skills/km/reference/ the flows the core dispatches to, read on demand; skills/km/bin/km runs the package from the installed plugin
tests/ smoke tests
evals/ plugin evals for the skill (evals/README.md)
e2e/ end-to-end test on a sandbox team brain on GitHub (e2e/README.md)
The smoke tests need Python 3.11+, PyYAML and git: bash tests/gate_smoke.sh, index_smoke.sh, team_smoke.sh, doctor_smoke.sh, sync_smoke.sh, list_smoke.sh, ready_smoke.sh (km ready against a stand-in gh), automerge_smoke.sh (km automerge, each merge condition flipped alone, against a stand-in gh), pins_smoke.sh, cites_smoke.sh, mounted_pins_smoke.sh (the mounted-pins workflow and script a team brain gets, against a stand-in GitHub API), action_smoke.sh (the GitHub Action's install step, with stand-ins for setup-python's interpreter, one that starts only with its lib folder on LD_LIBRARY_PATH), skill_smoke.sh (the skill's core keeps its size limit, no Markdown line under skills/ is long enough for the Read tool to cut, its reference paths resolve, every /km verb has a dispatch row), hook_smoke.sh (the plugin's edit guard; the pre-push hook too where pre-commit is installed) and e2e_smoke.sh (the e2e driver's seed generator, and its check that e2e/ names no repository but km's). CI runs them plus the GitHub Action on every pull request (once in GitHub's tool cache, once in another), and encoding_smoke.sh, doctor_smoke.sh, sync_smoke.sh, hook_smoke.sh, signoff_smoke.sh and gate_smoke.sh on Windows (team_smoke runs the encoding test on macOS under non-UTF-8 locales). A release bumps __version__ in src/km/__init__.py, version in .claude-plugin/plugin.json and the version in this README together; merging that to main is the release, CI tags vX.Y.Z once main is green.
km started inside dotclaude and was moved here with its history.
MIT