assert-one-assert-per-test 20261111143626__tar.gz

assert_one_assert_per_test-20261111143626/.claude/memories/MEMORY.md

@@ -0,0 +1,41 @@
+# Memories
+
+- [Memories live in .claude/memories](memories-live-in-dot-claude-memories.md) — autoMemoryDirectory in the untracked settings.local.json points here; there is no CLAUDE.md.
+- [A memory holds only what the tree cannot say](a-memory-holds-only-what-the-tree-cannot-say.md) — the reason, never the history; nothing release.yml, README.md, the code or git log answers; this index is the one exception.
+- [The user's words are restated, never copied](the-users-words-are-restated-never-copied.md) — in memories, issues, commits, tasks, feedback drafts and summaries; names stay as given.
+- [Commits go straight to main](commits-go-straight-to-main.md) — no branch, no pull request; CI is the only review.
+- [A requested change ends at the push](a-requested-change-ends-at-the-push.md) — any change the user asks for, an issue's fix or not, is committed and pushed without asking or waiting to be told.
+- [A path is staged by name](a-path-is-staged-by-name.md) — never `git add -A` or `git add .`; the lock file is ignored only in this clone.
+- [git add stages nothing when one path is missing](git-add-stages-nothing-when-one-path-is-missing.md) — a removal goes to `git rm`, never on the `git add` line.
+- [The index is read back before committing](the-index-is-read-back-before-committing.md) — one `git status --porcelain` between staging and committing.
+- [Issues that share code are one piece of work](issues-that-share-code-are-one-piece-of-work.md) — group the issues whose fixes go through the same code, take the first group whole, push each part once it stands alone.
+- [An issue is closed by its commit](an-issue-is-closed-by-its-commit.md) — one `Closes #N` line per issue; `Closes #1 and #2` leaves #2 open.
+- [Issue-closing keywords fire on push](issue-closing-keywords-fire-on-push.md) — nine keywords close from anywhere in a pushed message, brackets included; keep them for the finishing commit.
+- [The form of an issue reference](closing-keyword-form.md) — `Closes #N` to close, `Refs #N` or `See #N` to mention, one line per issue.
+- [A push can leave its issues open](a-push-can-leave-its-issues-open.md) — once the runs are clean, read back each issue the message closes and close any still open.
+- [A revert leaves its issue closed](a-revert-leaves-its-issue-closed.md) — reopen it by hand with `gh issue reopen` and read its state back.
+- [Push once and let the run finish](push-once-and-let-the-run-finish.md) — a second push cancels the first run and costs that commit its release.
+- [Unpushed commits go out first](unpushed-commits-go-out-first.md) — oldest first, one commit per push, before any new work starts.
+- [A rejected push is fixed forward](a-rejected-push-is-fixed-forward.md) — one follow-up commit answering every failed check, never an amend and force-push.
+- [A red run is fixed by the session that pushed](a-red-run-is-fixed-by-the-session-that-pushed.md) — caused or inherited, in a push of its own before the next piece of work.
+- [CI is the source of truth](ci-is-the-source-of-truth.md) — never run tests, linters or builds locally; a green release run publishes.
+- [CI shows all output](ci-shows-all-output.md) — every step prints everything its tools say, passing or failing: no quiet or count flags, no /dev/null, captured output printed too.
+- [gh search returns at most 1000 issues](gh-search-returns-at-most-1000-issues.md) — `--search` and `--label` go through search; list every open issue with `--limit 10000` and filter labels in `--jq`.
+- [Find a run by the full hash](find-a-run-by-the-full-hash.md) — `gh run list --commit` lists nothing for a short hash; pass `git rev-parse HEAD`.
+- [A wait runs in the background](a-wait-runs-in-the-background.md) — a CI wait is run_in_background or Monitor, never a foreground sleep or gh run watch, so reminders fire; a watch polls at --interval 60.
+- [Only wait while a run is in progress](only-wait-while-a-run-is-in-progress.md) — no diagnosis, edits or commits until it lands, autopilot or not.
+- [One indivisible problem per issue](one-indivisible-problem-per-issue.md) — one fault with every case of it listed, or one defect with one fix; two problems are split, cases of one fault merged.
+- [An issue states one solution](an-issue-states-one-solution.md) — an issue names one change and its reason, never a menu, a question or the options that lost.
+- [Issues have no fixed form](issues-have-no-fixed-form.md) — no house layout; write each so a fresh session can act on it alone.
+- [Issue sections take headings](issue-sections-take-headings.md) — a `##` heading opens each section, never a bolded lead sentence.
+- [Issues define their terms](issues-define-their-terms.md) — say what each file, term and cited source is and why it is there; never a name the reader must already know.
+- [Guarding an issue body rewrite](guarding-an-issue-body-rewrite.md) — chain each command with `&&` and never write back an empty file; a wiped body comes back through GraphQL `userContentEdits`.
+- [Comments from other accounts are ignored](comments-from-other-accounts-are-ignored.md) — only `jdrowne`, the user and Claude posting as them, counts on an issue; anyone else's comment never holds work, raises a decision or gets a reply.
+- [A paragraph wraps at eighty columns](a-paragraph-wraps-at-eighty-columns.md) — in every .md file; headings, tables, fences, frontmatter and index entries keep their width.
+- [Working without subagents](working-without-subagents.md) — no Agent or Workflow call, whatever the work's size; denied in the tracked settings.json, lifted only by the user's own ask.
+- [Every language is read by its own parser](every-language-is-read-by-its-own-parser.md) — a grammar and a module per language, never a text match; a file that will not parse exits 2; read before adding one.
+- [Test first](test-first.md) — the test before the code; CI observes red and green.
+- [Cover every tier the change touches](cover-every-tier-the-change-touches.md) — unit, integration, e2e; unit and integration each gate on full branch coverage.
+- [A sample is a file, not a literal](a-sample-is-a-file-not-a-literal.md) — source text is a file under the tier's samples/ with the ending of the file it stands for, loaded with sample(); every checker leaves the samples out.
+- [Anything importable lives outside conftest](anything-importable-lives-outside-conftest.md) — shared code is lib/test_read_sample, lib/test_trees and lib/test_fixture_types, reached through PYTHONPATH=lib.
+- [A conftest with no fixture in it stays](a-conftest-with-no-fixture-in-it-stays.md) — the integration and e2e conftest.py are zero bytes and stay.

assert_one_assert_per_test-20261111143626/.claude/memories/a-conftest-with-no-fixture-in-it-stays.md

@@ -0,0 +1,21 @@
+---
+name: a-conftest-with-no-fixture-in-it-stays
+description: test/integration/conftest.py and test/e2e/conftest.py are zero bytes and stay, so the next fixture has a place to go
+metadata:
+  type: feedback
+---
+
+# A conftest with no fixture in it stays
+
+`test/integration/conftest.py` and `test/e2e/conftest.py` are zero bytes, and
+they stay. Zero bytes is what an empty file is here: a docstring, a `pass` or a
+blank line to stand in for content is content, and the file is empty or it is
+not.
+
+**Why:** the file is what tells whoever writes the next fixture that this level
+exists to hold one; left to itself a session writes setup into the test file
+already open in front of it.
+
+**How to apply:** delete neither file, and put nothing in either but a fixture.
+Nothing in CI fails when one of them is deleted, so the file is kept for the
+reader rather than for a gate.

assert_one_assert_per_test-20261111143626/.claude/memories/a-memory-holds-only-what-the-tree-cannot-say.md

@@ -0,0 +1,33 @@
+---
+name: a-memory-holds-only-what-the-tree-cannot-say
+description: A rule is a memory only if working from the tree alone would get it wrong; it adds the reason, never the history, and repeats nothing release.yml, README.md, the code or git log already answers
+metadata:
+  type: feedback
+---
+
+# A memory holds only what the tree cannot say
+
+A rule is a memory only if working from the tree alone would get it wrong:
+whatever `release.yml`, `README.md`, the code or `git log` already answers is
+not repeated in a memory. What a memory adds to the tree is the reason for its
+rule, never the rule's history.
+
+**Why:** a second copy goes stale with nothing to catch it, and `git log`
+already keeps the history. A date, a commit hash or an issue number given as
+provenance, or the incident that set a rule, tells the next session when the
+rule arrived rather than why it holds.
+
+**How to apply:** before writing a memory, look for the fact in the tree; where
+the tree states it, the memory is only the part it does not, which is why. The
+**Why:** gives the reason for the rule in the present tense, never when, by whom
+or after what incident it was set, and a rule that changes is rewritten in place
+rather than annotated with what it used to say. An issue number written as an
+example of the rule, rather than as its origin, stays, and so do the
+`originSessionId` and `modified` lines the memory tool writes into the
+frontmatter, which are its bookkeeping rather than part of the memory.
+
+`MEMORY.md` is the one exception: it is navigation for a reader of the memories
+rather than a claim about anything else in the tree, and it is rewritten in the
+same edit as the memories it lists, so it cannot drift from them the way a
+copied fact drifts from its source. A session that has just read this rule will
+reach for the index first. Leave it, and update it.

assert_one_assert_per_test-20261111143626/.claude/memories/a-paragraph-wraps-at-eighty-columns.md

@@ -0,0 +1,25 @@
+---
+name: a-paragraph-wraps-at-eighty-columns
+description: A paragraph in a .md file, memories and skills included, is hard-wrapped at eighty columns; headings, table rows, fences, frontmatter, index entries and commit bodies are not
+metadata:
+  type: feedback
+---
+
+# A paragraph wraps at eighty columns
+
+A paragraph in a `.md` file — `README.md`, a memory here, a skill — is
+hard-wrapped at eighty columns, and a paragraph is the only thing that is: a
+heading, a table row, a fenced block, a frontmatter line and an entry in
+`MEMORY.md` keep whatever width they have, and a commit message body is still
+written as one line, because none of those is a markdown paragraph.
+
+**Why:** nothing checks it. `markdownlint.yml` passes `--disable MD013`, and
+turning that rule on would cap every line rather than every paragraph — eighty
+is its own default, but exempting tables and fenced blocks takes a config file,
+and `assert-no-linter-config-files` names markdownlint. So the cap is kept by
+whoever writes the paragraph.
+
+**How to apply:** hard wrapping has the cost it always has: a one-word edit
+reflows the words after it and the diff marks lines the edit did not mean to
+change. Rewrap the whole paragraph when that happens rather than leaving one
+line long, because half a wrapped paragraph reads worse than either.

assert_one_assert_per_test-20261111143626/.claude/memories/a-path-is-staged-by-name.md

@@ -0,0 +1,24 @@
+---
+name: a-path-is-staged-by-name
+description: Stage each file by its own path; never git add -A or git add . in this repository
+metadata:
+  node_type: memory
+  type: feedback
+  originSessionId: 522cfb64-59f2-4927-8369-5ddee3a12124
+  modified: 2026-11-08T01:58:35.362Z
+---
+
+# A path is staged by name
+
+Never use `git add -A` or `git add .`. Stage each file by its path.
+
+**Why:** `.claude/` is tracked, since it holds the memories, `settings.json` and
+the autopilot skill, but `.gitignore` excludes only `settings.local.json` from
+it. The `scheduled_tasks.lock` the cron reminders write beside them is kept out
+only by this clone's `.git/info/exclude`, which a fresh clone does not have, so
+a sweep there stages the lock with the memories. Other untracked scratch turns
+up from time to time as well, so naming each path is the rule regardless.
+
+**How to apply:** name every path, keep removals off the `git add` line per
+[[git-add-stages-nothing-when-one-path-is-missing]], and read the index back per
+[[the-index-is-read-back-before-committing]].

assert_one_assert_per_test-20261111143626/.claude/memories/a-push-can-leave-its-issues-open.md

@@ -0,0 +1,26 @@
+---
+name: a-push-can-leave-its-issues-open
+description: "GitHub can accept a commit on main and act on none of its Closes #N lines, so once the runs are clean each issue the message closes is read back and closed by hand if still open"
+metadata:
+  node_type: memory
+  type: feedback
+  originSessionId: 522cfb64-59f2-4927-8369-5ddee3a12124
+  modified: 2026-11-08T01:58:31.763Z
+---
+
+# A push can leave its issues open
+
+Once a push's runs are clean, check that every issue its message closes is
+closed.
+
+**Why:** GitHub can accept a commit on `main` and act on none of its `Closes #N`
+lines. A long message naming many issues is where it is most likely; whether
+the count or the size sets it off is not known. An issue left open after its
+fix landed reads as unsolved, so a later loop takes it up again and works on
+code that already satisfies it.
+
+**How to apply:** for each `Closes #N` line, read `gh issue view <N> --json
+state`. Close any still open with `gh issue close <N> --reason completed` and a
+comment naming the commit that solved it. The lines themselves are written per
+[[an-issue-is-closed-by-its-commit]], and fire per
+[[issue-closing-keywords-fire-on-push]].

assert_one_assert_per_test-20261111143626/.claude/memories/a-red-run-is-fixed-by-the-session-that-pushed.md

@@ -0,0 +1,28 @@
+---
+name: a-red-run-is-fixed-by-the-session-that-pushed
+description: "When the run a push starts goes red, the session that pushed fixes it, whether the push broke something or inherited the break"
+metadata:
+  node_type: memory
+  type: feedback
+  originSessionId: 522cfb64-59f2-4927-8369-5ddee3a12124
+  modified: 2026-11-08T01:58:50.436Z
+---
+
+# A red run is fixed by the session that pushed
+
+When a run that a push starts goes red, the session that pushed fixes it,
+whether the push caused the failure or inherited it from an earlier commit.
+What sets the rule off is the push's own run going red, not a red run the
+session merely comes across.
+
+**Why:** a change is unverified until every job that checks it has passed, and
+a failed job reads the same whether the change broke something or inherited a
+break. `release` needs every other job in `release.yml`, so it is skipped
+rather than failed, and an inherited failure hides the change's own result and
+holds back its release for as long as it stands.
+
+**How to apply:** once the run completes, `gh run view --log-failed` tells a
+break the change caused from one it inherited. Fix both kinds, in one commit
+per [[a-rejected-push-is-fixed-forward]], pushed on its own before the next
+piece of work: pushed together, a second red run could not say whether the
+fix or the new work broke it.

assert_one_assert_per_test-20261111143626/.claude/memories/a-rejected-push-is-fixed-forward.md

@@ -0,0 +1,20 @@
+---
+name: a-rejected-push-is-fixed-forward
+description: A red run is answered by one follow-up commit that fixes every failed check, never by an amend and force-push
+metadata:
+  type: feedback
+---
+
+# A rejected push is fixed forward
+
+Answer a red run with a follow-up commit; do not amend and force-push.
+
+**Why:** the commit is already on `main`, the only branch there is, per
+[[commits-go-straight-to-main]]. Every check is a job of its own running in
+parallel with the rest, so a red run names every check that failed rather than
+the earliest one.
+
+**How to apply:** read the whole list, with `gh run view --log-failed`, and
+answer all of it in one commit, pushed once per
+[[push-once-and-let-the-run-finish]]. A break the push inherited is answered
+the same way, per [[a-red-run-is-fixed-by-the-session-that-pushed]].

assert_one_assert_per_test-20261111143626/.claude/memories/a-requested-change-ends-at-the-push.md

@@ -0,0 +1,25 @@
+---
+name: a-requested-change-ends-at-the-push
+description: A change the user asks for is finished only once it is committed and pushed; commit and push it without asking whether to and without waiting to be told to push
+metadata:
+  node_type: memory
+  type: feedback
+  originSessionId: 522cfb64-59f2-4927-8369-5ddee3a12124
+  modified: 2026-11-08T03:35:21.285Z
+---
+
+# A requested change ends at the push
+
+A change the user asks for, whether an issue's fix, a memory or any other edit
+to the tree, is finished only once it is committed and pushed. When it is
+ready, stage it, commit it and push it without asking whether to and without
+waiting to be told to push.
+
+**Why:** CI is the only place a change is tested, so a change left in the
+working tree is untested and unfinished, and asking or waiting for a go-ahead
+only holds back work the user has already asked for.
+
+**How to apply:** stage and commit per
+[[the-index-is-read-back-before-committing]], push per
+[[push-once-and-let-the-run-finish]], and once the runs are clean read back each
+issue the message closes per [[a-push-can-leave-its-issues-open]].

assert_one_assert_per_test-20261111143626/.claude/memories/a-revert-leaves-its-issue-closed.md

@@ -0,0 +1,25 @@
+---
+name: a-revert-leaves-its-issue-closed
+description: "Reverting the commit that closed an issue leaves the issue closed, so the revert is followed by gh issue reopen and a read of its state"
+metadata:
+  node_type: memory
+  type: feedback
+  originSessionId: 522cfb64-59f2-4927-8369-5ddee3a12124
+  modified: 2026-11-08T01:58:28.512Z
+---
+
+# A revert leaves its issue closed
+
+When a revert takes back the commit that closed an issue, reopen the issue by
+hand.
+
+**Why:** GitHub closes an issue when its keyword reaches `main`, and nothing
+undoes that. `git revert` adds a commit and leaves the original in history, and
+no message the revert carries, `Refs #N` included, reopens `#N`. The issue then
+reads as finished while the tree holds none of its work, and the list of open
+issues the autopilot works from never offers it again.
+
+**How to apply:** push the revert, then `gh issue reopen <N>` with a comment
+naming the commit that closed it, the commit that took it back and what the run
+said. Read the state back with `gh issue view <N> --json state`, since the
+revert's own output says nothing either way.

assert_one_assert_per_test-20261111143626/.claude/memories/a-sample-is-a-file-not-a-literal.md

@@ -0,0 +1,33 @@
+---
+name: a-sample-is-a-file-not-a-literal
+description: "Source text handed to a reader is a file under its tier's samples/ directory, ending as the file it stands for ends and loaded with sample() by its full name; every checker that reads that ending leaves test/*/samples/ out on its command line"
+metadata:
+  node_type: memory
+  type: feedback
+  originSessionId: 522cfb64-59f2-4927-8369-5ddee3a12124
+  modified: 2026-11-08T03:25:25.536Z
+---
+
+# A sample is a file, not a literal
+
+Source text handed to a reader is a file under the `samples/` directory of the
+tier that reads it, named for the test that reads it, and loaded with
+`sample()` by its full name. The samples that make up a project tree live in
+each CLI tier's `samples/project/`, because they belong to no single test.
+
+A sample ends as the file it stands for ends: in the language its folder names,
+or else as the path its test writes it to or hands to the reader with it. A
+sample standing for a file with no ending, such as a `Makefile`, has none.
+
+Every CI job whose checker reads one of those endings leaves `test/*/samples/`
+out with a flag on its command line: `--exclude`, `--ignore`, `--ignore-paths`,
+or the `ignore` key in yamllint's `--config-data`.
+
+**Why:** a file's ending says what the file holds, and `.txt` around Python
+says something false. The skips keep the samples, which break the rule on
+purpose and in places do not parse, away from checkers that are not meant to read them. They
+sit on the command line because `assert-no-linter-config-files` fails the build
+over a checker's config file.
+
+**How to apply:** never write source text as a string literal in a test. When a
+job is added whose checker reads a sample's ending, give it the same skip.

assert_one_assert_per_test-20261111143626/.claude/memories/a-wait-runs-in-the-background.md

@@ -0,0 +1,35 @@
+---
+name: a-wait-runs-in-the-background
+description: A wait for CI is a Bash run_in_background or a Monitor, never a foreground sleep or gh run watch, so the session stays idle and the autopilot reminders can fire; gh run watch inside it polls at --interval 60
+metadata:
+  type: feedback
+---
+
+# A wait runs in the background
+
+Waiting for a workflow run, or for anything else that takes minutes, is done
+with `Bash` and `run_in_background: true`, which notifies once when the command
+exits, or with `Monitor`, which notifies once per event; never with a foreground
+`sleep`, `gh run watch` or polling loop in the session's own shell.
+
+**Why:** a cron reminder fires only while the session is idle. A foreground wait
+holds the session busy for the whole run, so the autopilot's standing rules stop
+arriving exactly while a push is in flight, and the user cannot type either.
+10ulabs.com, api.10ulabs.com and wan-synthesizer hold the same rule for the same
+reason.
+
+**How to apply:** start the wait in the background, end the turn, and act on the
+notification. `gh run watch <id> --exit-status --interval 60` is fine inside the
+background command; it is the foreground that is the problem.
+
+The interval is there because `gh run watch` polls every 3 seconds by default,
+and over a long run that trips GitHub's secondary rate limit. Once it has
+tripped, the watch and every `gh` call after it answer HTTP 403 while `gh api
+rate_limit` still shows every bucket full, and the limit clears only after
+several minutes without a call. So when a `gh` call answers 403 that way, the
+next one waits behind a background `sleep` rather than retrying at once, since
+each retry keeps the limit tripped.
+
+Idle still means idle: nothing but the wait goes on while the run is in
+progress, per [[only-wait-while-a-run-is-in-progress]]. Find the run per
+[[find-a-run-by-the-full-hash]].

assert_one_assert_per_test-20261111143626/.claude/memories/an-issue-is-closed-by-its-commit.md

@@ -0,0 +1,20 @@
+---
+name: an-issue-is-closed-by-its-commit
+description: An issue is closed by a Closes #N line in the commit that fixes it, one line per issue
+metadata:
+  type: feedback
+---
+
+# An issue is closed by its commit
+
+An issue is closed by the commit that fixes it, through a `Closes #N` line, one
+line per issue.
+
+**Why:** GitHub binds the keyword to a single reference, so `Closes #1 and #2`
+closes #1 and leaves #2 open. There is no pull request to close it instead, per
+[[commits-go-straight-to-main]].
+
+**How to apply:** give each issue its own `Closes #N` line in the message, ahead
+of the attribution lines, and only in the commit that finishes it, per
+[[issue-closing-keywords-fire-on-push]]. A commit that only mentions an issue
+writes `Refs #N` or `See #N` instead, per [[closing-keyword-form]].

assert_one_assert_per_test-20261111143626/.claude/memories/an-issue-states-one-solution.md

@@ -0,0 +1,25 @@
+---
+name: an-issue-states-one-solution
+description: "An issue names one change and its reason; never \"either X or Y\", a menu with a recommendation, a question left for the reader, or the options that lost"
+metadata:
+  node_type: memory
+  type: feedback
+  originSessionId: 480159be-d838-4153-abff-13fe6b4fba0b
+  modified: 2026-11-08T03:51:21.797Z
+---
+
+# An issue states one solution
+
+An issue names one change — this function, this file, this dependency — and
+what the choice rests on. Never file "either X or Y", a menu with a
+recommendation, or a question left for the reader, and leave out the options
+that lost and the reasoning that ranked them.
+
+**Why:** the issue is the instruction to whoever picks it up, and they were not
+in the conversation that produced it. The options that lost are the trail to
+the answer, not part of it, and a reader has to get through them to find it.
+
+**How to apply:** settle the choice before filing, whatever form the issue
+takes per [[issues-have-no-fixed-form]]. When a later finding settles a
+question an open issue was weighing, rewrite the body to give the answer and
+cut every sentence the finding makes moot.

assert_one_assert_per_test-20261111143626/.claude/memories/anything-importable-lives-outside-conftest.md

@@ -0,0 +1,31 @@
+---
+name: anything-importable-lives-outside-conftest
+description: conftest.py holds only fixtures and hooks; code two tiers share by import is lib/test_read_sample, lib/test_trees and lib/test_fixture_types, reached through PYTHONPATH=lib
+metadata:
+  type: feedback
+---
+
+# Anything importable lives outside conftest
+
+`conftest.py` holds fixtures and hooks, which pytest finds by itself; a test
+module never imports from it. What two tiers share by import is a package under
+`lib/`, because `lib/` is where code used more than once in this repository
+goes: `test_read_sample` reads one sample, `test_trees` holds the crate trees
+the CLI is run over, their paths, the findings the findings tree produces and
+the `FULL_RUN` arguments that name them, and `test_fixture_types` holds the
+`RunCli` and `WriteTree` aliases the fixtures are annotated with.
+
+They are separate because a file reader, a fixture tree and a type alias change
+for different reasons. The packages are not named after the tool: what belongs
+there is whatever more than one caller needs and no fixture should hold. The
+tests themselves do not move there: nothing imports a test, so `test/unit/`,
+`test/integration/` and `test/e2e/` stay where they are.
+
+**Why:** importing a conftest instead works only while a package layout keeps
+its module name unique, and binds the suite to that layout for a reason nothing
+states. A block repeated across tiers also fails `jscpd-test`, which runs at a
+threshold of zero.
+
+**How to apply:** every job reaches the modules through `PYTHONPATH=lib` (or
+`MYPYPATH=lib`), since `test/` carries no `__init__.py` and pytest puts only a
+test's own directory on the path.

assert_one_assert_per_test-20261111143626/.claude/memories/ci-is-the-source-of-truth.md

@@ -0,0 +1,23 @@
+---
+name: ci-is-the-source-of-truth
+description: Never run tests, linters or builds locally to verify; commit, push to main and read the run, knowing a green release run publishes to PyPI
+metadata:
+  type: feedback
+---
+
+# CI is the source of truth
+
+Do not run tests, linters or builds locally to verify a change: write the code
+and the tests, commit, push to `main`, and read the run with `gh run list` and
+`gh run view --log-failed`, waiting for it in the background per
+[[a-wait-runs-in-the-background]]. Reading the code locally is still right and
+cheap: `grep` and file reads are how the useful findings surface.
+
+**Why:** the jobs between them want Python, Node, a tree-sitter grammar per language and
+eight tools this machine does not otherwise carry, and CI checks every gate at
+once.
+
+**How to apply:** a green push publishes to PyPI and force-moves `latest` by
+itself, so there is no version to hold back, and a commit that should not be
+published is a commit that should not be pushed. The change is done when each
+run the push started is green, per [[find-a-run-by-the-full-hash]].

assert_one_assert_per_test-20261111143626/.claude/memories/ci-shows-all-output.md

@@ -0,0 +1,33 @@
+---
+name: ci-shows-all-output
+description: "Every CI step shows all the output its tools produce, passing or failing: no quiet or count flags, no /dev/null, no captured output left unprinted"
+metadata:
+  node_type: memory
+  type: feedback
+  originSessionId: 522cfb64-59f2-4927-8369-5ddee3a12124
+  modified: 2026-11-08T02:14:50.772Z
+---
+
+# CI shows all output
+
+Every step of this repository's workflows shows everything its tools print, for
+passing runs as well as failing ones. That means:
+
+- no `-q`, `--quiet`, `--silent` or `--count` flags, and `--verbose` wherever a
+  tool has one;
+- no `>/dev/null`;
+- output captured into a variable or a file is printed as well;
+- `PYTHONUNBUFFERED=1` for a Python script that prints as it goes, so each line
+  reaches the log when it is printed rather than all at once at the end.
+
+`action.yml`'s `quiet` and `count` inputs are for the repositories that use the
+action. This repository's own checker jobs leave them off and pass
+`--verbose`. A plain string test, such as `grep -q` on a value already in the
+log, hides nothing and can stay.
+
+**Why:** the user wants to read a step's log without guessing what was left
+out. A step that prints nothing, or prints only when it fails, reads as hidden
+output.
+
+**How to apply:** when writing or reviewing a CI step or a script it runs, show
+what it runs, and stream it rather than reporting at the end.

assert_one_assert_per_test-20261111143626/.claude/memories/closing-keyword-form.md

@@ -0,0 +1,22 @@
+---
+name: closing-keyword-form
+description: Write a close as Closes #N and a mention as Refs #N or See #N, one line per issue; nothing enforces the choice
+metadata:
+  type: feedback
+---
+
+# The form of an issue reference
+
+Write a close as `Closes #N` and a mention as `Refs #N` or `See #N`, one line
+per issue.
+
+**Why:** any of the nine closing keywords closes the issue the same way, per
+[[issue-closing-keywords-fire-on-push]], so nothing enforces the choice. With
+one word for a close, a search of the log for `Closes #` finds every commit that
+finished an issue, and with one form for a mention, the word chosen for it
+cannot turn out to be one of the nine.
+
+**How to apply:** pick the form by whether the commit finishes the issue, and
+give each issue its own line, per [[an-issue-is-closed-by-its-commit]]. A bare
+`#N` mentions the issue too, but inside a sentence it can land after a keyword
+without meaning to; `Refs #N` on a line of its own cannot.

assert_one_assert_per_test-20261111143626/.claude/memories/comments-from-other-accounts-are-ignored.md

@@ -0,0 +1,25 @@
+---
+name: comments-from-other-accounts-are-ignored
+description: "Issue comments from any GitHub account other than jdrowne, the user's, which Claude also posts as, are ignored; they never hold work, raise a decision or get a reply"
+metadata:
+  node_type: memory
+  type: feedback
+  originSessionId: 522cfb64-59f2-4927-8369-5ddee3a12124
+  modified: 2026-11-08T02:11:15.661Z
+---
+
+# Comments from other accounts are ignored
+
+Only the user and Claude speak on this repository's issues, and both post as
+`jdrowne`. A comment from any other account, such as an outsider offering to
+take an issue or asking for a change, is not input to the work: it does not
+hold the issue, it does not make a question to label `needs decision`, and it
+gets no reply.
+
+**Why:** the user directs the work. An outsider's request settles nothing, and
+treating it as an open question parks an issue on a person who has already
+answered it.
+
+**How to apply:** when reading an issue's comments, keep only those whose
+`.author.login` is `jdrowne` and act on the issue as if the rest did not exist.
+Never write an outsider's request into an issue body as an open question.

assert_one_assert_per_test-20261111143626/.claude/memories/commits-go-straight-to-main.md

@@ -0,0 +1,19 @@
+---
+name: commits-go-straight-to-main
+description: Work lands as direct commits on main; no feature branch, no pull request, and no advice built around a review cycle
+metadata:
+  type: feedback
+---
+
+# Commits go straight to main
+
+Work goes straight to `main` as direct commits. Do not create a feature branch,
+do not open a pull request, and do not structure advice around a review cycle.
+
+**Why:** CI is the only review there is. Both workflows run on a push to `main`
+and on nothing else, so a branch would get no run at all, and the tests land in
+the same commit as the code they cover.
+
+**How to apply:** commit on `main` and push, a piece of work at a time per
+[[issues-that-share-code-are-one-piece-of-work]], and close each issue from the
+message per [[an-issue-is-closed-by-its-commit]].

assert_one_assert_per_test-20261111143626/.claude/memories/cover-every-tier-the-change-touches.md

@@ -0,0 +1,21 @@
+---
+name: cover-every-tier-the-change-touches
+description: unit/ for readers and CLI helpers, integration/ for the CLI over a real tree, e2e/ for the installed console script; unit and integration each gate on full branch coverage
+metadata:
+  type: feedback
+---
+
+# Cover every tier the change touches
+
+`unit/` for the readers and the CLI helpers, `integration/` for the CLI driven
+over a real tree, `e2e/` for the installed console script run the way a workflow
+step runs it, all three under `test/`. A change is covered in every tier it
+touches.
+
+**Why:** unit and integration each gate on full branch coverage on their own
+rather than on the two together. `e2e-tests` carries no coverage gate and
+cannot, since it runs the command in another process.
+
+**How to apply:** a line reachable only through the console script is reached by
+`run_cli`, the in-process fixture in the root `conftest.py`, and asserted again
+through the subprocess.

assert_one_assert_per_test-20261111143626/.claude/memories/every-language-is-read-by-its-own-parser.md

@@ -0,0 +1,36 @@
+---
+name: every-language-is-read-by-its-own-parser
+description: A language is read by its own tree-sitter grammar in its own module, never a text match; read before adding a language or reaching for tree-sitter-language-pack
+metadata:
+  type: project
+---
+
+# Every language is read by its own parser
+
+Each language has a module under `src/assert_one_assert_per_test/`, `rust.py`
+first, that reads a file with that language's grammar and returns its findings,
+and one row per suffix in `SCANNERS` in `scanner.py`. What a test is, what an
+assertion is and what a conjunction is are decided on the tree, by node type and
+by a node's own text, never by matching characters in the source.
+
+**Why:** a text match counts an `assert!` inside a string, a comment or a doc
+test, and cannot tell a binary `&&` from a double reference `&&x` or a closure
+`||`, which differ only in what token comes before them. The failure is silent
+in the direction that matters: a missed second assertion leaves a job green.
+Rust macro arguments are a `token_tree` the grammar does not parse into an
+expression, so `claim_operators` reads the tree's direct tokens and decides
+binary-ness from the token before each operator. That is still a reading of the
+tree, not of the characters: nesting, strings and the message after the first
+top-level comma are already separated by the grammar.
+
+**How to apply:** a new language gets its own grammar dependency, its own
+module exposing `scan(path, source: bytes) -> list[Finding]`, its suffixes in
+`SCANNERS`, its own sample folder in each tier, and its own section in
+`README.md` saying what counts as a test, an assertion and a conjunction there.
+`tree-sitter-language-pack` is not the shortcut it looks like: it ships hundreds
+of grammars to serve a few, and pins them together so none can move alone.
+
+A file the grammar cannot parse completely is `Unparsable`, exit 2, rather than
+whatever the grammar recovered. That differs from `assert-no-comments`, which
+reports what it can: a misread test here would be counted wrongly, and a wrong
+count is a false finding or a missed one.

assert_one_assert_per_test-20261111143626/.claude/memories/find-a-run-by-the-full-hash.md

@@ -0,0 +1,18 @@
+---
+name: find-a-run-by-the-full-hash
+description: gh run list --commit needs the full forty-character hash from git rev-parse HEAD; a short hash lists nothing
+metadata:
+  type: feedback
+---
+
+# Find a run by the full hash
+
+Find the run by the full forty-character hash from `git rev-parse HEAD`.
+
+**Why:** `gh run list --commit` returns an empty list for the short hash `git
+log --oneline` prints, which is indistinguishable from a run that has not
+started.
+
+**How to apply:** a push starts one workflow or both, depending on what it
+touched, and the change is done when each run that started is green rather than
+when the first one is.