agentleFS
malloydatamalloydata/publisher/.claude/skills/publisher-release/SKILL.md

publisher-release

Skill133 starsChanged 2 days agoMITView on GitHub

Cut a Malloy Publisher release, and write the RELEASE_NOTES.md entries a release ships. Use when asked to release, cut a release, ship a version, or publish Publisher to npm/Docker — and when a change needs a release note, or you are deciding whether it does and what version to stamp on it.

  • Reads credentials
  • Commits and pushes

The file

Show its rules and text

We split this skill into the rules it gives an agent

13 rules. About 0 are common, 8 are distinctive, and 5 are very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈8

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 5

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Very specific:

    Read .github/workflows/CONTEXT.md (path from the repo root) before acting.

    line 19
  2. Distinctive:

    Write it for the person upgrading: what changed, what breaks, what to do.

    line 57
  3. Distinctive:

    Amend that same section in place: if a follow-up PR lands before the release and changes the same behaviour.

    line 67
  4. Distinctive:

    Never write a version number into a note yourself.

    line 82
  5. Very specific:

    Read a release note's own claims rather than its heading when deciding.

    line 122
  6. Distinctive:

    If you want to see what the release will decide before dispatching, ask npm the same questions the release does:

    line 249
  7. Very specific:

    If the wait gives up, the scaffolder was not dispatched.

    line 300
  8. Distinctive:

    If a section is present that should not ship yet, the work behind it is already on main and the note is telling the truth.

    line 333
  9. Distinctive:

    Read them in order, and stop at the first surprise:

    line 407
  10. Distinctive:

    Any other file: stop and show the user. The release branch should carry nothing else.

    line 413
  11. Distinctive:

    A PR exists: use it rather than opening a second.

    line 417
  12. Very specific:

    Ask the user to merge the PR, or merge it if they asked you to.

    line 461
  13. Very specific:

    If the release page is missing narrative that [$V] sections on the branch carry, gh-release logged a could not read RELEASE_NOTES.md or …

    line 471

≈ “Common” is an estimate: at least 1 in 5 of the 364,980 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md
<!-- Copyright (c) Credible Data Inc. SPDX-License-Identifier: MIT -->

Releasing Publisher

A release is one workflow_dispatch of Release (NPM + Docker + PyPI) (.github/workflows/release.yml), followed by one pull request: the release/v<version> branch the release published from, merged back into main. That branch already carries the version bump and the stamped release notes, so you never create a branch or stamp anything by hand. You open the PR from the branch the workflow pushed.

Read .github/workflows/CONTEXT.md (path from the repo root) before acting. It carries the publishing rules that are not guessable from the YAML, and it is the authority when this file and it disagree.

Release notes: when to write one, and what number goes on it

RELEASE_NOTES.md is not written at release time. The PR that changes the behaviour writes the note, in the same PR, as a ## [Unreleased] section — which is the only way it gets written by someone who knows what changed. The release then carries it to users on its own: prepare stamps every [Unreleased] heading with the release's version on the release branch, and gh-release puts those sections on the release page. Writing the section is the whole job; merging the release branch back is the one thing the release cannot do for itself.

Does this change need one?

gh-release already attaches an auto-generated "What's Changed" list of merged PRs. That list is sufficient for a routine patch, so a note is not a per-PR chore. Write one when the PR list would leave a reader unable to act — when a user or operator has to do something, or would otherwise draw a wrong conclusion from an unchanged-looking system:

  • A breaking change, or anything needing a migration step. Mark the heading (BREAKING).
  • A new or removed API field, endpoint, or response shape — anything that breaks a strict generated client, or that consumers should move onto.
  • A deprecation: what still works, for how long, and what to move to.
  • Changed meaning of an existing signal — a metric label, a counter, an error code. A value that keeps its name and changes its basis is the case most worth writing, because nothing else will surface it.
  • A silent failure that is now visible, or a bug whose symptom users have been living with. Say who was affected and how to tell.
  • A new capability with a cost or a limit worth knowing before adopting it.

Skip it for refactors, tests, docs, CI, and internal changes with no observable effect. When unsure, ask whether a reader upgrading blind could be surprised. If not, the PR list covers it.

Write it for the person upgrading: what changed, what breaks, what to do. The existing sections are the house style — prose, not bullets-only, and specific about the failure mode.

What number goes on it

Three states, in order:

  1. ## [Unreleased] — <what changed> while the change sits on main unreleased. This is what an authoring PR writes. Always.
  2. Amend that same section in place if a follow-up PR lands before the release and changes the same behaviour. Do not add a second section — the two ship together as one story, and the reader has never seen the first version. #1024 (pre-aggregation off by default) and #1030 (on by default) are one section for exactly this reason.
  3. ## [<version>] — <what changed> once a release has shipped it. CI writes this — prepare stamps it on release/v<version>, and it reaches main when that branch's PR merges (step 6). You do not stamp by hand, and you do not guess the number in advance.

Once a section is stamped, it is history and does not get rewritten. A follow-up that changes that behaviour opens a new [Unreleased] section referencing the shipped version by number, the way the build-failures section names 0.0.245 and 0.0.246 when describing what 0.0.247 changed.

Never write a version number into a note yourself. Release numbers are assigned at dispatch time and a release can fail. A failed release's stamp is harmless only because its branch is never merged; the next dispatch cuts a new branch from main, which still reads [Unreleased].

The versioning policy

0.MINOR.PATCH for every published package, while pre-1.0. sdk/app/server have followed it since 0.2.0 (the Python client follows them, in lockstep), and skills has always been on 0.1.x. create-malloy-package is the exception: it is still on its own 0.0.x line, computed at release time. Nothing enforces the shape of the number for any of them — skills and create-malloy-package resolve their next version from npm latest at release time, and moving either onto a new minor line is a judgement call made with an explicit -f version=, not something CI demands.

  • MINOR = a breaking change. PATCH = everything else. A breaking change is one that turns a package which loaded or built yesterday into one that does not: a refused annotation, a refused #@ persist combination, a load-time failure on syntax that previously passed. It also covers a removed endpoint or response field, like 0.0.242's /pages → /data-apps rename.
  • This is what makes a range usable. ^0.0.250 resolves to >=0.0.250 <0.0.251 — exactly one version — and ~0.0.250 to >=0.0.250 <0.1.0, a range whose upper half does not exist. So on 0.0.x no consumer can say "patches yes, breaking no". ^0.2.0 resolves to >=0.2.0 <0.3.0, which they can. (On any 0.x line ^ and ~ are identical — both stop at the next minor.)
  • No 1.x. Publisher is preview, so a major is a deliberate decision made with an explicit -f version=; there is no major option on the dispatch. If it ever happens, note @malloy-publisher/sdk@1.0.1 is published (an old off-line publish latest moved off long ago) while 1.0.0 is free, and app and server have no 1.x at all — so a 1.x line has to start at 1.0.0 and skip 1.0.1, or start at 1.0.2.
  • The sdk/app/server train moved on 2026-08-28, from 0.0.250 straight to 0.2.0: not 0.1.0, because skills already occupies 0.1.x and two trains sharing a minor invites reading one for the other. From there, a default dispatch is a patch and bump=minor is the next minor, with no explicit version needed (0.11.0 was a bump=minor off 0.10.7).

Read a release note's own claims rather than its heading when deciding. A section can be titled (BREAKING) while its bullets say "this cannot affect an existing package", and the reverse happens too. Propose the level and get the maintainer's call rather than inferring it from the diff alone — a narrow break may still be judged patch-worthy, and that judgement is theirs.

How to bump

prepare derives the version from npm's latest, so a routine release needs no version input at all:

# a patch — the default
gh workflow run release.yml --repo malloydata/publisher --ref main

# a breaking release
gh workflow run release.yml --repo malloydata/publisher --ref main -f bump=minor

The floor is max(npm latest, main declared) by version sort, and it fails closed: if the registry will not answer, prepare refuses rather than falling back to the file. An explicit -f version= still wins outright over bump, and is what you want for a major, for a prerelease, or to name the number exactly.

Two things worth knowing about the derived path:

  • The chosen level is applied once. If that number's release branch or tag already exists, the walk past it is by patch — so bump=minor colliding with an existing 0.3.0 gives 0.3.1, not 0.4.0.
  • bump=minor is computed off npm's current latest. On the 0.x line that is the number the policy wants. It was not while the line sat on 0.0.x: a minor off 0.0.250 would have landed on 0.1.0, the line skills occupies, which is why the move to 0.2.0 was made with an explicit version.

An earlier version of this section said "prepare's default version is not trustworthy — always pass -f version=". That was true and is no longer: #1037 changed the floor to max(npm latest, main declared) with fail-closed behaviour, so the hole it warned about — a default run walking up from main's stale number, finding a gap below latest, and moving the dist-tag backwards with nothing failing — is closed. Passing an explicit version is now a choice, not a precaution.

The version trains

PackagesVersionDecided byMissing bump caught by
sdk, app, serverlocksteprelease.yml itself, on a release/v<v> branchn/a — the release sets it
skillsits own line, package.json carries a fixed 0.0.0-dev placeholderrelease time, from npm's own state (scripts/independent-version.mjs); you, for a minorn/a — nothing is committed ahead of time to forget
create-malloy-packageits own line, same placeholderrelease time, the same wayn/a, same reason
malloy-publisher-sdk (Python)lockstep with sdk/app/serverrelease.yml itself, in packages/python-client/pyproject.toml on the release branchn/a — the release sets it

Skills and create-malloy-package no longer have a version to forget. Nothing is bumped ahead of a release: both packages' package.json declare 0.0.0-dev in the repo, and what actually publishes is decided at release time by scripts/independent-version.mjs, called from scripts/publish-packages.sh, and written into the manifest at publish time. So the pre-release hand-audit that used to live in step 2 below (comparing main's declared version against npm) no longer applies to either package — there is nothing on main to compare.

The two are decided differently:

  • skills publishes when its published content changed since npm latest's gitHead — a diff of skills/, packages/skills/, bun.lock and the root package.json, excluding skills/README.md and packages/skills/src/*.spec.ts. Changed publishes one patch above the highest published plain version; unchanged skips.
  • create-malloy-package publishes on every non-prerelease release, unconditionally, because it bakes the server's npm latest into every workspace it scaffolds — a release changes what it ships even when its own directory did not. The only skip is a re-run of the same release, detected by its published publisherServer field already matching.

The publish version is one patch above the HIGHEST published plain version (npm view <pkg> versions --json), not latest plus one — a latest dist-tag rolled back by hand after a bad release must not make this recompute a version that's already published. latest's gitHead stays the content-diff baseline above; only the version arithmetic reads the full versions list.

A hand dispatch of either child workflow with no version input publishes one patch above the highest published version, the same guard the old PR check used to enforce, now run once at dispatch time. A minor or major bump is a hand dispatch with -f version=. After a hand-dispatched skills minor, hand-dispatch the scaffolder too — it depends on skills' version — or wait for the next release, which republishes the scaffolder anyway.

It publishes from release.yml itself, not from publish-packages: prepare stamps the release version into pyproject.toml with the three package.json files, build-python-sdk calls python-sdk.yml on the release branch (build and verify; the smoke test against a server is build.yml's, on every PR, like the Docker image's), and publish-python-sdk uploads the verified wheel and sdist through PyPI trusted publishing once publish-npm and publish-docker have succeeded, so PyPI never holds a version whose server did not ship. It skips only a version already on PyPI, which in lockstep means a re-run, and both jobs skip a prerelease or +build version. The first upload was 0.10.5, on 2026-10-31, and every release since has published there. The trusted publisher names project malloy-publisher-sdk, workflow release.yml, environment pypi; Publishing to PyPI in .github/workflows/CONTEXT.md explains why each of those is pinned, and what breaks if one moves.

main's packages/sdk/package.json used to lag npm permanently. It no longer does: merging the release PR (step 6) brings those three files (and packages/python-client/pyproject.toml) to the version that shipped, and CI's Release sync check fails while a shipped release's PR is unmerged. prepare still takes the max of npm and the file for its floor rather than trusting either. Ask npm when you want to know what is published.

Order, and why each step is where it is

1. Establish where things actually stand

git fetch --tags origin
npm view @malloy-publisher/server version              # the real current version
git log --oneline "v$(npm view @malloy-publisher/server version)..origin/main"

That commit list is what this release ships. If it is empty, there is nothing to release.

2. Skills and create-malloy-package need no pre-flight bump check

Nothing is committed ahead of time for either package, so there is nothing to confirm here: scripts/independent-version.mjs reads npm's own state at release time and decides publish/skip/version from it, not from what main declares. Skip straight to Sanity-check the notes below.

If you want to see what the release will decide before dispatching, ask npm the same questions the release does:

npm view @malloy-publisher/skills dist-tags.latest
npm view "@malloy-publisher/skills@$(npm view @malloy-publisher/skills dist-tags.latest)" gitHead
git diff --quiet "<that gitHead>" origin/main -- skills/ packages/skills/ bun.lock package.json \
  ':!skills/README.md' ':!packages/skills/src/*.spec.ts' && echo unchanged || echo changed

npm view @malloy-publisher/create-malloy-package dist-tags.latest
npm view "@malloy-publisher/create-malloy-package@$(npm view @malloy-publisher/create-malloy-package dist-tags.latest)" publisherServer

changed (or any diff not unchanged) means skills will publish this release; unchanged means it skips. create-malloy-package publishes regardless, unless its publisherServer already equals the version this release is about to ship — that only happens on a re-run.

The Python client needs no check: it releases in lockstep with sdk/app/server, so this release publishes it at this release's version.

The scaffolder's server pin is derived now — do not set it by hand

create-malloy-package pins the server its generated workspaces run (SERVER_VERSION in packages/create-malloy-package/src/scaffold.ts). That pin is substituted at publish time from npm's current @malloy-publisher/server latest, in the runner's working tree only, so the value committed to the repo is a dev default and there is nothing to bump before a release. Its publish job then reads the line back, confirms it matches the registry, and confirms that server still documents --host.

This is what 0.0.250 was about, and it is worth knowing why the old instruction existed: the pin was hand-maintained and the publish job refused to ship unless it equalled npm's latest, so a release that forgot it went red 25 minutes in, after skills had already published. Setting it in the pre-release PR is now wrong rather than merely unnecessary — the substitution overwrites it, and a committed value that happens to differ is not a problem to fix.

The derivation is only correct because publish-packages waits for publish-npm. It did not until 0.0.250, and on needs: prepare alone this job races the server publish, so the substituted value would be a release behind and every generated workspace would pin the previous server. If that needs: is ever narrowed back to prepare alone, this breaks silently rather than loudly.

The needs: is not enough on its own, because npm can take minutes to show a version after it publishes. In 0.7.0 latest read 0.7.0 seven minutes after publish-npm finished. So publish-packages.sh also waits, up to 15 minutes, for the server's latest to read the new version before dispatching the scaffolder. It then passes that version to the scaffolder as its server_version input, because another runner can still read the old latest for a few minutes; the scaffolder waits until its own latest matches and refuses to pin anything else. If the wait gives up, the scaffolder was not dispatched. Once latest reads the new version, re-run the publish-packages job (Re-run failed jobs), not the whole release.

3. Check the last release merged back, and read what ships

prepare stamps RELEASE_NOTES.md itself and gh-release reads it back, so there is nothing to paste. Whether the last release merged back is CI's job: release-sync.yml compares npm's latest with packages/sdk/package.json on every PR, every push to main, and after every release run. Read its result rather than repeating the comparison:

gh api repos/malloydata/publisher/commits/main/check-runs \
  --jq '.check_runs[] | select(.name == "Release sync") | "\(.conclusion) \(.html_url)"'
# the narrative this release will stamp and ship
git fetch origin
NOTES="$(mktemp)" && git show origin/main:RELEASE_NOTES.md > "$NOTES"
RELEASE_NOTES_FILE="$NOTES" node scripts/release-notes.mjs extract | grep '^## '

If the check failed, do not dispatch. The previous release's PR has not merged, so main still reads [Unreleased] for sections that release already shipped, and this release would stamp and publish them again. The check's error names the version; finish step 6 for it, which is also the only thing that turns the check green. release.yml does not run this check itself, so nothing stops a dispatch but you.

What you are checking in the extract is that the sections listed are the ones this release actually ships. A section describes work merged to main, so anything sitting there goes out with this release whether or not it was written for it. Nothing listed is fine and common — the generated PR list carries a routine patch.

If a section is present that should not ship yet, the work behind it is already on main and the note is telling the truth; the fix is a release, not an edit.

4. Dispatch

prepare derives the version from npm's latest and fails closed if the registry will not answer, so a routine patch needs no input. See How to bump above for the policy behind the choice.

# a patch
gh workflow run release.yml --repo malloydata/publisher --ref main

# a breaking release
gh workflow run release.yml --repo malloydata/publisher --ref main -f bump=minor

# an exact number: a major, a prerelease, or a line change like 0.0.250 -> 0.2.0 was
gh workflow run release.yml --repo malloydata/publisher --ref main -f version=<next>

Do not merge to main while it runs. publish-packages aborts if main moves under a watched path mid-release. A RELEASE_NOTES.md-only merge is not watched, but the window is short — just wait. Do not push to release/v<version> while it runs either: npm-sdk.yml and docker-image.yml check it out by name, so a push mid-run can publish two different commits under one version.

5. Verify what actually shipped

A green tick is not evidence. Read the run's job summary, which names each independently-versioned package as published or skipped and why.

npm view @malloy-publisher/server version
npm view @malloy-publisher/skills version
gh release view "v<version>" --repo malloydata/publisher

6. Open the release PR, and get it merged

This is the one step the release cannot finish itself, and as the agent running this skill you open the PR. The branch already exists and already holds everything: prepare committed the three packages/{sdk,app,server}/package.json versions, the Python client's packages/python-client/pyproject.toml version, and the stamped RELEASE_NOTES.md headings to release/v<version> as one commit. Do not create another branch and do not stamp anything by hand.

Open it once the run has finished, for any release whose sdk reached npm (npm view @malloy-publisher/sdk version reads it). That includes one whose gh-release then failed: it shipped, and release-sync.yml stays red until this PR merges. A release that never reached npm has nothing to merge back: leave its branch alone (the next dispatch skips past it) and dispatch again. A prerelease or a +build version never gets a PR.

First confirm the branch is there and holds only the release commit, against origin/main:

V=<version>
git fetch origin
# 1. prepare pushed it
git ls-remote --exit-code --heads origin "release/v$V"
# 2. one commit ahead of main, titled chore(release): $V
git log --oneline "origin/main..origin/release/v$V"
# 3. only the three manifests, python-client/pyproject.toml and RELEASE_NOTES.md
git diff --stat "origin/main...origin/release/v$V"
# 4. the [$V] sections it stamped, which should match the release page
NOTES="$(mktemp)" && git show "origin/release/v$V:RELEASE_NOTES.md" > "$NOTES"
RELEASE_NOTES_FILE="$NOTES" node scripts/release-notes.mjs extract "$V" | grep '^## '
# 5. no PR for it yet
gh pr list --repo malloydata/publisher --head "release/v$V" --state all

Read them in order, and stop at the first surprise:

  1. No branch: prepare failed before pushing, so nothing published. Read the run; there is nothing to merge back.
  2. More than one commit: someone pushed to the release branch. Read those commits before opening anything.
  3. Any other file: stop and show the user. The release branch should carry nothing else.
  4. No sections: normal for a routine patch. Otherwise compare with gh release view "v$V" --repo malloydata/publisher.
  5. A PR exists: use it rather than opening a second. If it was closed unmerged, reopen it.

Then open it against main:

gh pr create --repo malloydata/publisher --base main --head "release/v$V" \
  --title "chore(release): $V" \
  --body "Merges the v$V release branch back into main: sets sdk, app, server and the Python client to $V and stamps the RELEASE_NOTES.md sections v$V shipped.

Release: https://github.com/malloydata/publisher/releases/tag/v$V"

The title matters: the repo squash-merges, so it is what main's history keeps. The workflow does not open this PR itself because a PR opened with GITHUB_TOKEN triggers no workflows: main's required checks would never run and only an admin could merge it. Opened on the user's credentials, the checks run and any maintainer can merge.

main requires the branch to be up to date, and RELEASE_NOTES.md usually conflicts. Any PR merged since the release was cut makes the branch stale. A new [Unreleased] section lands directly above the first stamped heading, which git treats as one conflicting hunk. Merge main in locally, with a sign-off because the DCO check is required:

git fetch origin
git switch -c "release/v$V" "origin/release/v$V"
git merge --signoff origin/main
# Only if the merge stopped on a RELEASE_NOTES.md conflict: keep BOTH sides,
# main's new [Unreleased] sections exactly as they are and this branch's [$V]
# headings, then conclude it. The package.json version lines never conflict;
# only release PRs change them.
#   git add RELEASE_NOTES.md && git commit -s --no-edit
node scripts/release-notes.mjs extract "$V" | grep '^## '   # exactly v$V's sections
node scripts/release-notes.mjs extract | grep '^## '        # only what merged since
git push origin "release/v$V"

The two extract lines are the check that the resolution is right: the first must list the same sections as the release page, the second only sections merged after the release was cut. Pushing to the release branch is safe once the run has finished, since the tag pins the published commit.

Ask the user to merge the PR, or merge it if they asked you to. Merging deletes release/v$V (the repo deletes head branches on merge); the tag keeps the commit. Then confirm:

git fetch origin main
git show origin/main:packages/sdk/package.json | grep '"version"'   # $V
gh release view "v$V" --repo malloydata/publisher --json body -q .body | head -40

If the release page is missing narrative that [$V] sections on the branch carry, gh-release logged a could not read RELEASE_NOTES.md or could not fit the release body warning. Add the output of extract "$V" to the page by hand with gh release edit.

A page that lists the section titles under "This release's notes are longer than a GitHub release page allows" is not a failure. GitHub caps a release body at 125,000 characters, so when the narrative and the PR list would not fit, gh-release (release-notes.mjs fit) puts an index of the titles on the page with a link to RELEASE_NOTES.md at the tag, and truncates the PR list to its compare link if it has to; the run logs a notice saying which. The titles should still match step 4's extract "$V" | grep '^## '.

Left unmerged, release-sync.yml fails on main and on every PR, naming this version; merging this PR is the only fix. Confirm it went green on main after the merge (the first command in step 3).

If it fails

  • Only build-python-sdk or publish-python-sdk is red → npm and Docker are unaffected; neither job is in gh-release's needs. Re-run failed jobs: the publish job skips a version PyPI already holds, and reuses the verified artifact. Do not re-run the release. If publish-npm or publish-docker is red instead, publish-python-sdk shows as skipped, not failed: it waits for both, and Re-run failed jobs runs it once they pass.
  • Only publish-packages is red → the sdk/app/server release completed and the tag exists; that job sits outside gh-release's needs. Use Re-run failed jobs, which re-enters that job alone and skips whatever already landed. Do not re-run the release — it walks the version forward and burns three npm versions.

    Dispatching the children by hand also works, but it is not the same thing and the skip does not come with it. Only publish-packages asks the registry and skips; each child carries a Verify this version is not already published step that exit 1s on a version npm already holds. So dispatching a child that already published fails the run rather than no-opping. Ask npm first and dispatch only the package still missing, keeping skills before the scaffolder:

    npm view @malloy-publisher/skills version
    npm view @malloy-publisher/create-malloy-package version
  • "main moved during this release" → expected and retryable, same recovery. It can fire on the second package after the first already published, so read the job summary rather than assuming nothing shipped.
  • Anything after npm-sdk.yml published → not resumable at the same version. npm versions are immutable; move forward.

Prereleases

Any hyphen in the version skips gh-release and both independently-versioned packages, because their own versions carry no hyphen and would take over the latest tag. Ship those from an ordinary release.

A prerelease is also never stamped and never merged back. main's [Unreleased] sections stay as they are and ship with the next ordinary release, and extract <prerelease> finds nothing, because no heading carries a prerelease number.

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.