Recognize multi-record messages so squash inheritance stops losing identity and provenance (#60)

[MongLong0214]

Summary

Closes #60. The issue's own author self-corrected twice before landing on the real finding; this PR fixes all three, in the order requested:

1. Multi-record grammar (SPEC §2.4). A message MAY now carry several record blocks. The message's own last paragraph keeps its existing, unconditional recognition (SPEC §2.1 B1–B8, unchanged). Every other paragraph is an additional block only when, tested in isolation, it is entirely trailer-shaped and declares a Record-Id. The identity gate is what keeps this from reopening B2's own worked example (Context:/Source: — trailer-shaped, no identity, correctly still prose). A message with at most one Record-Id anywhere has exactly one block, so a single-record message parses byte-identically to before — backward compatibility is a property of the grammar, not a shim. X-Inherited-From becomes unnecessary and is no longer written.
2. squash-preserve emits one block per inherited record (SquashPlan.blocks, replacing the old single merged record), each with its own Record-Id and its own accurate Provenance: inherited <sha> naming that record's true source, never a different record's. Old notes carrying X-Inherited-From still resolve — it's an ordinary preserved extension (SPEC §3.2).
3. commitlore doctor gained a squash-conservation check. It warns when a local branch that looks like an un-preserved squash source declared a Record-Id HEAD's history can't find. Detection, not prevention — nothing local can hook GitHub's server-side squash button. Ruled-out: a CI step — see ADR-0014 for the full reasoning (needs a GitHub API dependency this tool takes nowhere else, and can only run after the squash is already pushed).

No trailer key was added. Supersedes: still means deliberate replacement.

What changed

• src/core/trailers.ts — parseRecordBlocks, the multi-record grammar primitive.
• src/core/squash.ts — planSquash groups by identity and folds within an identity only (the old code folded across unrelated records too, which was part of the underlying bug); SquashPlan.blocks replaces merged.
• src/core/notes.ts — writeRecordBlocks/readRecordBlocks, the multi-block note read/write path; writeRecord/readRecord unchanged for single-block callers.
• src/core/index-db.ts — schema v2 (trailers.block column, derived/disposable per ADR-0003) and a narrow second git log pass (mirroring the existing readPaths pattern) that recovers extra blocks only for the sliver of commits that already carry ≥1 trailer.
• src/core/query.ts — groupByCommit/identityOf/foldMirroredNotes are block-aware, so commitlore context and every consumer route show each recovered record separately.
• src/commands/validate.ts — validates every block a message carries, not only the last paragraph; the existing merge-title special case (A PR title of the form 'word: description' becomes an invalid trailer in GitHub's merge commit #76) stays scoped to the last block only.
• src/commands/doctor.ts — new squash-conservation check.
• spec/SPEC.md §2.4, docs/adr/ADR-0014-multi-record-grammar.md, CHANGELOG.md.

Measured — before / after, all four verification cases

Baseline confirmed first: 1253 passed / 1 skipped / 35 files on dev.

1. Local git merge --squash + squash-preserve --target HEAD

$ commitlore squash-preserve base..feature --target <merge-sha>
commitlore: 2 record(s) from 2 commit(s) in base..feature — wrote the notes mirror

$ commitlore context --no-index
context — 1 limits, 0 ruled-out, 1 warnings, 3 other in 2 records

limits
  r-verify01  e827d868  [claim]  the vendor caps us at 3 concurrent workers
warnings
  r-verify02  e827d868  [claim]  do not raise the retry ceiling without re-reading the vendor quota
other
  r-verify01  e827d868  [claim]  Provenance: inherited a05a7dea051a28e11f0b8602254c217d21db4d99
  r-verify02  e827d868  [claim]  Provenance: inherited 6ee3634f383f1b241b48fbf8ed44447d113072d5

Before: one merged record; with two distinct Record-Ids in range, the old code declared neither (the merge record declares none), and Provenance: named only the newest source. After: both ids survive, each block's Provenance: names its own true source commit — a05a7dea… for r-verify01, 6ee3634… for r-verify02, not both pointing at the same sha.

2. GitHub-style squash message (subject, blank line, then concatenated commit messages)

$ git log -1 --format=%B | git interpret-trailers --parse   # git's own B1 view, unchanged
Warn: do not raise the retry ceiling without re-reading the vendor quota
Record-Id: r-ghtest2

$ commitlore context --no-index                              # this PR
context — 1 limits, 0 ruled-out, 1 warnings, 1 other in 2 records

limits
  r-ghtest1  9d059d50  [claim]  the vendor caps us at 3 concurrent workers
warnings
  r-ghtest2  9d059d50  [claim]  do not raise the retry ceiling without re-reading the vendor quota

Before (this is the literal reproduction from the issue's first correction): 2 records in, 1 out, validate exit 0, nothing said so. After: both r-ghtest1 and r-ghtest2 recovered, each with a resolvable id.

3. Single-record message parses byte-identically

git interpret-trailers --parse and commitlore parse agree exactly, including a record whose Record-Id and Provenance sit in canonical §3 vocabulary order (Record-Id before Provenance) — the ordering that made a naive "split right after Record-Id" design wrong during development; the shipped grammar only draws a boundary when a second Record-Id justifies one. All 123 fixture-driven cases in test/trailers.test.ts (spec/fixtures/valid, spec/fixtures/boundary B1–B8, spec/fixtures/invalid) pass unchanged.

4. commitlore context shows each recovered record with a resolvable id

Demonstrated in cases 1 and 2 above — r-verify01/r-verify02 and r-ghtest1/r-ghtest2 each print next to their own id.

Test plan

• npm run typecheck — clean
• npm test — 1289 passed, 1 skipped, 35 files (up from the 1253/1/35 baseline; net new/updated coverage in trailers.test.ts, squash.test.ts, action-preserve.test.ts, index-db.test.ts, doctor.test.ts, validate.test.ts)
• Manually verified all four cases in the issue's VERIFY list against a fresh dist/commitlore.mjs build (transcript above)
• node dist/commitlore.mjs validate --commit HEAD passes on this branch's commit
• dist/ rebuilt and committed alongside src/, matching this repo's existing convention (.gitignore's own comment; confirmed against a prior dev commit)

Known, documented limitations (not silent)

• An inherited record that never declared a Record-Id is recoverable from the plan squash-preserve computes, but if there is more than one such unidentified record, only the last one survives a later re-parse of already-written text (the grammar can only use identity to tell a non-final block apart from body prose). squash-preserve orders unidentified blocks last, so the common case — at most one — is unaffected, and warningsFor says so when it isn't.
• Follows:/Supersedes: across two blocks declared by the same commit is not resolved specially; each block is still checked against every earlier commit in history.

Both are named explicitly in ADR-0014 and in code comments, not discovered later.

[github-actions]

CommitLore — record lint

Trailers: clean — 1 commit in origin/dev..92aeb24aeee6642312e3da15fd49327ce6cb20f6
Active constraints: 30 limits · 79 ruled-out · 48 warnings — from 55 records over 38 changed paths

Active constraints for the paths this PR touches

Limits (30)

• r-multirec01 92aeb24 — parseRecordBlocks only recognizes a non-final block by its declared Record-Id, so an unidentified inherited record beyond the first stays recoverable in the plan that computed it but not in a later re-parse of stored text; squash-preserve orders unidentified blocks last so the common case (at most one) is unaffected.
• r-multirec01 92aeb24 — multi-block reference checking (Follows:/Supersedes:) does not resolve one block's reference against a sibling block declared by the same commit; each block is still checked against every earlier commit in history.
• r-exit065 e545dee — any new command's exit codes must be drawn from SPEC §10, not invented locally
• r-fix70a1 d707fc7 — one encoding layer and explicit lexical forms in the four published languages; semantic paraphrases, nested encodings, and split payloads remain outside coverage
• r-shwt66 5efa206 — git rev-parse --git-path may return a repository-relative path, so resolve it against cwd
• r-merge66 40e7987 — Generated dist files were resolved only by npm run build and npm run bundle
• r-fix760 fb8ba45 — Git remains the authority on trailer recognition; diagnostics must not loosen the parser
• r-refint74 572f573 — validate cannot perform conservation checks because it has no before state
• r-warn75 24c7cc8 — exit-code semantics remain owned by guard's exit 2 means blocked; everywhere else in the same CLI exit 2 means bad usage #65
• r-shallow66 60a8659 — a depth-1 clone can only inspect its reachable commit history
• r-doctor72 996bcde — generated dist artifacts must come from npm run build and npm run bundle, not a hand merge
• r-fix067 a915af0 — PreToolUse hook failures must always exit 0 and never change stdout's hookSpecificOutput contract
• r-fix063 0b8c496 — doctor performs remote probes; an unreachable remote reports could not verify instead of ok
• r-fix053 ecc4b90 — QueryResult.notes remains repository-level availability and is independent from whether one record was mirrored
• r-fix055 43b40f8 — harvest-verify makes no model call, so semantic entailment is outside its contract
• r-fix054 664d4e2 — notes-only metadata must survive folding; a mirror is one record, not two
• r-fix056 55cb8bc — blocked output may retain only validated structural values that cannot carry prose
• r-7a3e91 cf859e4 — better-sqlite3 stays external because it is native — the bundle degrades to --no-index without it, which only works because r-6f2a08 made that load lazy first
• r-6f2a08 4c2d432 — esbuild cannot follow createRequire(import.meta.url)('x'), so any dependency reached that way stays external no matter what the bundle config says
• r-4a8e15 49e12c7 — git's grammar requires a subject before a trailer block, so a serialized block is not by itself a parseable message
• r-1e7b40 c3ecbb6 — the merge is the only moment the branch's commits are still reachable, so this has to be right the first time or the records are gone
• r-4e9c72 a7a7e26 — the index is derived, so nothing about its state can make the tool give a wrong answer -- only a slower one
• r-1b7d94 736ef92 — git reads ambient configuration, so a suite that does not neutralise it is testing the developer's machine as much as the code
• r-7e5f02 e5f5e00 — npm installs through an engine mismatch, so the ecosystem's own signal cannot be relied on to stop anything
• r-9a5e17 6d68703 — five workers on one repository share npm test and tsc, so file ownership alone does not prevent one worker from "fixing" another's half-written code -- verification scope had to be split too
• r-4d8a13 b1034ca — the same field carries two shapes, so any near-miss between them resolves to whichever branch is looser unless the looser one excludes the shape deliberately
• r-1f4b26 65f01c7 — this repository ran under two retired names, so its early records cannot validate against the current vocabulary and a whole-history check would be permanently red
• r-5a8c04 c46a577 — git owns the definition of a trailer block, so any behavior we cannot get from interpret-trailers is behavior we must not invent
• r-c0f4e2 3d249cd — npm gitlore is held by an active same-domain CLI, so the owner's first-choice name was not available
• r-b2e7f1 00d348d — Parsing must delegate to git interpret-trailers -- reimplementing the block rules would drift from the rest of the git ecosystem

Ruled out (79)

• r-multirec01 92aeb24 — minting a fresh Record-Id for an inherited record that never declared one | no other code path in this project invents identity; Record-Id is always author-declared, and doing it here would be new scope beyond what the issue asked for
• r-multirec01 92aeb24 — a CI step comparing a PR's commits against its post-merge squash commit, as the primary mechanism for finding 1 | needs a GitHub API dependency this tool takes nowhere else, and can only run after the squash is already pushed; doctor catches the same mistake locally, before push, when the source branch is still in refs/heads
• r-83d43117 8a49ddc — an install-root check for COMMITLORE_BIN | its only reason to exist is aiming the hook at a build outside the install root -- a test harness, a monorepo's local bin. Restricting its location would remove the one thing it is for; doctor's existing COMMITLORE_BIN visibility is the right amount of scrutiny for a channel that is supposed to point anywhere.
• r-83d43117 8a49ddc — resolving commitlore.bin with an external realpath/readlink -f binary | neither is guaranteed on every machine a hook runs on, the same reasoning 1fd0d53 gave for not shelling out to shasum. cd ... && pwd -P is a POSIX-specified builtin and covers the same physical-resolution need without a new dependency.
• r-exit065 e545dee — leaving guard's inversion in place and only documenting it | guard and inject are the two commands wired into hooks and CI, so a script written against guard today is already trusting the number; a documented inversion is still an inversion, and it gets load-bearing the longer it sits. The surface is one boolean per command right now — cheaper to fix once than to explain forever.
• r-fix70a1 d707fc7 — exhaustive per-language phrase enumeration | unbounded phrase lists cannot provide semantic coverage, so this fix documents a bounded lexical policy and independent corpus
• r-shwt66 5efa206 — checking --git-dir/shallow | linked worktrees keep the shallow marker in the common Git directory
• r-fix760 fb8ba45 — testing commits with more than one parent in dogfood scope | their platform-generated merge messages carry no authored decision, so requiring a record would require one nobody wrote
• r-refint74 572f573 — allowing a note to extend a commit record under the same Record-Id | notes are remote-reachable, so divergent content would inherit a human-approved identity
• r-warn75 24c7cc8 — accepting run-on or indented trailers | Git treats them as prose and accepting them would make records ambiguous
• r-doctor72 996bcde — choosing either parent doctor list | each drops a runtime check required by the other incident
• r-fix067 a915af0 — treat an outside-repository file_path as a legitimate no-record result | only an in-repository query can truthfully establish that no records apply; silence would hide a broken matcher
• r-fix063h f0bb995 — leave hook runtime as a separate contradictory check | a fix-bearing installation check must not report ok or warn when the installed hook demonstrably fails
• r-fix063 0b8c496 — add the explicit refspec only after confirming the remote ref exists | setup would depend on today’s remote state and require another doctor run after the first notes push
• r-fix053 ecc4b90 — add a public mirrored boolean | the per-record sources array already models contributing channels, so a second representation would create drift
• r-fix055 43b40f8 — infer whether a quote supports Verified | deterministic text matching can prove presence, not that a check ran
• r-fix055 43b40f8 — downgrade harvested Verified to reconstructed | it preserves a citation-bearing assertion the verifier cannot substantiate
• r-fix054 664d4e2 — write X-Inherited-From into commit messages too | transport metadata would lengthen every preserved user-facing message merely to restore symmetry
• r-fix054 664d4e2 — stop squash-preserve from writing notes | it discards the mirror instead of fixing the query seam
• r-fix056 55cb8bc — reuse the injection omission list for blocked withholding | it includes prose-bearing Evidence and Expires, so it is not a safety boundary
• r-7b26f1 ec070ec — retrying the read inside the transaction | a write lock held across a subprocess is a worse failure than the one being fixed
• r-1e58d3 1fd0d53 — removing the recorded-path branch entirely | a clone is on no PATH and in no node_modules (ADR-0011), and that branch is the only thing that finds the CLI there
• r-1e58d3 1fd0d53 — hashing the recorded binary at install time | shasum is not guaranteed on every machine a hook runs on, and a check that silently no-ops is worse than the one being replaced
• r-9c74b3 68340e4 — withholding only in --json | a shell agent reads stdout, and the text form is what it reads
• r-4b17f8 7efba5c — retrying the read inside the transaction | a transaction holding a write lock while it shells out to git is a lock held across a subprocess
• r-7a48c3 b85d847 — a CONFLICTED lifecycle state for divergent declarations | see above — it would block work on records that have a correct answer
• r-8d51a6 27f73b0 — filtering blocked matches out of the result | the caller needs to know something matched; withholding is a rendering decision, made once
• r-8d51a6 27f73b0 — reusing exit 1 for "could not check" | 1 already means a broken invocation, and a hook that cannot tell a bad flag from an unreadable repository will treat both as noise
• r-2f7d94 a7673d0 — an allow-list of free-text keys | it is the shape of the original bug, and a new key would be unguarded until someone remembered
• r-2f7d94 a7673d0 — leaving the wording generic ("a trailer") | an operator needs to know which line to edit, and the key was available two frames up
• r-4e29b7 66829bb — folding this into the existing notes field | they are independent axes and can co-occur; one enum would have to enumerate the product
• r-4e29b7 66829bb — throwing on an unreadable repository | context runs from a hook on every edit, and an exception there is a broken editor rather than a refusal
• r-1c47e9 0e9930b — dropping the check | the two installation failures it exists for are real and were both invisible to configuration reads
• r-1c47e9 0e9930b — probing whichever file is newer | "which artifact is this installation" is a fact about the layout, not about timestamps
• r-3d92a8 f85101a — keeping the searches first and fixing the shim | the shim belongs to npm, not to us, and the version-skew problem survives the fix
• r-3d92a8 f85101a — a config-only hook check | it was written, it reported ok, and the hook failed on the next commit
• r-7c05e2 218ea28 — fetching notes automatically when the ref is missing | a query is a read, and silently reaching the network on a read is a surprise that belongs to git fetch
• r-7c05e2 218ea28 — leaving it to doctor | doctor is run by a person once, and the answer that misleads is the one an agent gets on every task
• r-7c05e2 218ea28 — a diagnostic string alone | the field it qualifies is records: [], and prose is not something a consumer can branch on
• r-9b31c7 e8d45fb — keeping the placeholder until author trust was configurable | the placeholder was the permissive direction, so waiting meant shipping the hole
• r-9b31c7 e8d45fb — withholding blocked payloads from the CLI too | a person reading a terminal can disbelieve a sentence; a tool result is retrieved fact
• r-9b31c7 e8d45fb — dropping blocked records from the MCP answer entirely | an agent that silently receives less than there is cannot notice, and cannot audit
• r-6c48b2 aaadedf — matching the whole file at edit time | the file contains everything the agent did not write, and GUARD-CANNOT-BLOCK measured prose surfaces producing false alarms specifically on compliant agents
• r-6c48b2 aaadedf — blocking on a match | the score bands overlap, measured
• r-6c48b2 aaadedf — running T-705 · guard route benchmark — measure the path SPEC §5 assigned to Ruled-out #37 without this pre-check | an arm that fires zero times measures nothing, and 120 runs is an expensive way to learn that
• r-5b9e37 010782c — baking the resolved path into the hook stub | hooks status is a byte comparison against commitMsgStub(), so every hook installed from a different checkout would report outdated forever
• r-5b9e37 010782c — an npx fallback | the existing comment is right — npx --no still queries the registry when the package is absent, putting a network call on every commit and breaking offline commits
• r-2f9c40 07f47ca — wiring guard into the plugin as a blocking hook | true and false positives occupy the same score band on real agent output, so the only precision-safe threshold catches 1 of 5 and every useful threshold blocks four compliant edits in twenty-five
• r-2f9c40 07f47ca — raising RECORD_ID_WEIGHT's threshold instead of gating the signal | the false alarms scored 1.0000, so no threshold below the maximum excludes them and the maximum excludes everything
• r-2f9c40 07f47ca — semantic matching to separate the populations | ADR-0002 keeps the core LLM-free and zero-cost, and B-04 · Optional embedding-search tier #31 registers embeddings as opt-in — nothing measured here justifies moving that into the core
• r-7a3e91 cf859e4 — inlining spec/SPEC.md and the schema into the bundle | SPEC.md would need a codegen step that itself needs a drift guard, and the package-root walk removes the reason to want it
• r-7a3e91 cf859e4 — replacing the tsc output with the bundle | test/cli.test.ts, test/hooks.test.ts and test/mcp.test.ts import dist internals by path
• r-6f2a08 4c2d432 — forcing the ajv-formats import with a cast to make the bundle build | it swaps a load-time failure for a type lie, at the end of a long session, on the one path every command goes through
• r-0d4b81 8005227 — a longer quickstart that demonstrates context, limits, ruled-out, warnings and stale | an agent calls those itself once the MCP server is registered, so listing them teaches the human a workflow that is not theirs
• r-6d92c4 b058de2 — documenting grep -a as the convention | it leaves every future reader one forgotten flag away from the same silent empty result, and the cause takes six characters to remove
• r-4a8e15 49e12c7 — make the parser accept a bare block | it would disagree with git, and delegating to git is the one thing SPEC section 2 requires
• r-1e7b40 c3ecbb6 — retry every refused push | a permission failure is not a race, and retrying it produces the same refusal three times
• r-1e7b40 c3ecbb6 — act on any merge | rebase and merge commits keep the originals, so inheriting would duplicate rather than preserve
• r-1e7b40 c3ecbb6 — inherit from a shallow clone | it would silently carry a subset and report success
• r-4e9c72 a7a7e26 — fail when the index is missing or stale | it would be the first thing users learn to ignore, and then a real failure is quiet too
• r-1b7d94 736ef92 — pass -c flags everywhere | they cover the test's own git calls and miss every call made by the code under test
• r-1b7d94 736ef92 — give notes.ts a fallback identity | it would hide a real misconfiguration in a user's repository behind a fake author
• r-7e5f02 e5f5e00 — hold Node 20 and downgrade both dependencies | paying maintenance cost to keep supporting an unpatched runtime
• r-7e5f02 e5f5e00 — floor at 24 | excludes Node 22 users today for no benefit, and 22 outlives v0.1.0
• r-7e5f02 e5f5e00 — drop engines entirely | the failure moves from install time to runtime, where it is someone else's confusing bug
• r-9a5e17 6d68703 — let each command edit src/cli.ts | guaranteed conflict, and the conflict surfaces only after every worker has finished
• r-9a5e17 6d68703 — npx fallback in the hook stub | a network call on every commit, and offline commits start failing
• r-4d8a13 b1034ca — reject all free text and require a date | conditions are a real use, and the stale engine already flags them for review
• r-4d8a13 b1034ca — accept 2026-2-15 as a date | the spec names one form, and accepting two invites a third
• r-1f4b26 65f01c7 — hardcode the adoption commit sha | a hand-maintained cutoff is the first thing to go stale, and staleness here reads as passing
• r-1f4b26 65f01c7 — keep the anchor requirement and add anchors to the records | it would have manufactured anchors to satisfy a rule that buys no additional checkability
• r-1f4b26 65f01c7 — skip the check on shallow clones | silence is indistinguishable from passing, so a shallow clone fails loudly instead, with fetch-depth 0 named in the message
• r-5a8c04 c46a577 — regex trailer parsing | B3 prose false-positives are the failure mode this protocol exists to prevent
• r-5a8c04 c46a577 — a custom GitError subclass | the convention here is new Error with structured context, and callers read GitResult
• r-c0f4e2 3d249cd — GitLore published as git-lore | the binary and search results still collide with the existing gitlore tool
• r-c0f4e2 3d249cd — keep Annals | the sound problem does not decay, and with code near zero this is the cheapest moment the project will ever have
• r-c0f4e2 3d249cd — rename code and spec first, documents later | the drift window makes every artifact written in it wrong
• r-b2e7f1 00d348d — line-matching Key: prefixes | prose containing a colon line parses as a record and feeds agents false context (verified B3)
• r-b2e7f1 00d348d — content-hash Record-Id | must survive rebase and squash, which a hash of the commit does not

Warnings (48)

• r-multirec01 92aeb24 (claim) — index-db.ts SCHEMA_VERSION is now 2 for the added block column — bump it again, not the shape in place, the next time the trailers table changes.
• r-83d43117 8a49ddc (claim) — the containment check resolves the recorded path's directory physically and separately rejects a symlink at the final component, but does not protect a relative commitlore.bin with no path separator (a bare filename), which resolves against the hook's cwd and could coincide with the install root in a repository that installs commitlore against itself. That residual case sits in the same accepted-risk category as the severity note above: an attacker who can write that config key already has an equivalent, direct route.
• r-exit065 e545dee (claim) — guard's swap is a breaking change for anything scripted against the old exit 2 for "matched" — see CHANGELOG Unreleased/Breaking
• r-fix70a1 d707fc7 (claim) — add malicious and benign fixtures together when extending scanner patterns; false positives can make the defence unusable
• r-merge66 40e7987 (claim) — test/hooks.test.ts must keep both worktree git-path resolution and reference-integrity assertions
• r-fix760 fb8ba45 (claim) — unknown-only final paragraphs are treated as prose only when the source is a multi-parent commit
• r-wt77fix f77ef5d (claim) — git rev-parse --git-path may return a repository-relative path; resolve it against the test repository
• r-refint74 572f573 (claim) — exact commit and note mirrors remain one logical record; only divergent note payloads collide
• r-warn75 24c7cc8 (claim) — query several paths one at a time when rename history matters
• r-shallow66 60a8659 (claim) — shallow history remains advisory; query and guard exit-code semantics are unchanged
• r-doctor72 996bcde (claim) — keep commit-msg health bound to hook-runtime and keep inject-runtime as a separate known-good payload probe
• r-fix067 a915af0 (claim) — the accepted tool set is the union of the plugin and settings matchers; aligning those matchers remains Shallow clone: answers from 1 commit of history without saying history is truncated #66
• r-fix063 0b8c496 (claim) — the wildcard fetches every ref under refs/notes, including notes owned by other tools
• r-fix055 43b40f8 (claim) — Verified remains valid protocol vocabulary for facts recorded from actual command or test execution; only harvest refuses it
• r-7b26f1 ec070ec (claim) — the concurrency test is deterministic rather than sleep-based, so it proves the transaction boundary and not the absence of every race
• r-1e58d3 1fd0d53 (claim) — COMMITLORE_BIN still accepts any executable, deliberately — a harness must be able to aim the hook at a specific build. It is now reported rather than restricted
• r-9c74b3 68340e4 (claim) — context now prints [blocked] beside a record whose payload is gone, which is more visually alarming than the old silent leak. That is the intended direction — a withheld record should be conspicuous — but it changes what a clean repository's output looks like the first time someone commits a Warn: that trips a pattern by accident
• r-1a63f5 2bb4993 (claim) — "CI is green" was said five times today against a red CI, including in the commit that introduced the rule saying to check CI before saying it. The rule is in docs/RELEASE-GATE.md §5 and it was not followed by its own author. This commit is not claiming CI is green; that claim comes after the run reports
• r-4b17f8 7efba5c (claim) — deleteNoteRows opens its own transaction inside the new outer one. better-sqlite3 nests these as savepoints; node:sqlite has neither, so ADR-0012's migration must flatten this rather than assume it works
• r-7a48c3 b85d847 (claim) — these two changes were developed concurrently in one worktree and share a built dist/. Splitting them would leave one commit whose dist/ did not match its src/, so they land together and are described together
• r-5c92e0 73b1285 (claim) — the delegate reported "943 passed" for a suite whose baseline is 1108. It ran while another task was writing to the same worktree and collected a partial set. The real count, verified here on a quiet tree, is 1109 across 31 files — but a delegated test count is now a claim to check, not a result to accept
• r-8d51a6 27f73b0 (claim) — guard stays advisory. Nothing here makes it block, and GUARD-CANNOT-BLOCK still holds — the point is that it no longer lies about what it saw
• r-2f7d94 a7673d0 (claim) — Evidence: and Expires: are now scanned. Both usually hold paths and dates, so a false positive there withholds a legitimate record. No case is known; a legitimate record carrying a path, a URL and a date was checked and passes
• r-4e29b7 66829bb (claim) — historyAvailability spends two git invocations per query. Both are metadata reads, but this is a hot path and nothing measures it yet
• r-1c47e9 0e9930b (claim) — this is the second defect in three days from assuming the development checkout is the deployment. The first was exec node in the run script
• r-3d92a8 f85101a (claim) — hook-runtime executes the hook on every doctor run. The probe message is valid so nothing is written, but it is no longer a read-only command
• r-3d92a8 f85101a (claim) — the check pins PATH to /usr/bin:/bin, which assumes git is there. On a system where it is not, this reports a hook failure that is really a probe failure
• r-7c05e2 218ea28 (claim) — notesAvailability runs git rev-parse and up to two git config reads on every query. Config-only, no network, but it is not free on a hot path
• r-9b31c7 e8d45fb (claim) — the default is now fail-closed on every route — with no --trusted-author, every Warn: grades claim. That is SPEC §7 and it is what inject already did, but a user who saw [directive] yesterday will see [claim] today
• r-6c48b2 aaadedf (claim) — recall here is against four re-proposals. It is a go/no-go signal for whether an arm has anything to measure, not an effect size
• r-5b9e37 010782c (claim) — commitlore.bin and commitlore.node are local config, so they do not survive a fresh clone of a repository whose hook was installed elsewhere — re-run hooks install there, which is what the failure message now says
• r-2f9c40 07f47ca (claim) — --require-content changes precision, not recall; it removes a false-alarm class and catches nothing new
• r-7a3e91 cf859e4 (claim) — hardcoding ../ counts back to the package root is what broke this — new code reads assets through installedPath(), never through import.meta.url
• r-6f2a08 4c2d432 (claim) — the READMEs and ADR-0011 currently overstate this — they say a clone runs, and it does not until B-09 · Single static binary — remove the Node runtime dependency #39 lands
• r-0d4b81 8005227 (claim) — claude mcp add commitlore -- commitlore mcp is Claude Code's syntax — other MCP clients register a stdio server their own way
• r-6d92c4 b058de2 (claim) — keep the NUL separator when touching these keys — a printable delimiter can appear inside a trailer value and would collide
• r-4a8e15 49e12c7 (claim) — canonical output is a block, not a message -- prepend a subject before parsing it back, or the round-trip silently returns nothing
• r-1e7b40 c3ecbb6 (claim) — this runs on pull_request closed with contents: write -- keep the permission scoped to that workflow and out of ci.yml
• r-4e9c72 a7a7e26 (claim) — doctor reads the index read-only and never rebuilds it -- a diagnostic that repairs on sight hides how often the repair was needed
• r-1b7d94 736ef92 (claim) — keep the GIT_CONFIG_* overrides in vitest.config.ts -- removing them makes the suite pass on developer machines and fail in CI, with a message that points at git rather than at the test
• r-7e5f02 e5f5e00 (claim) — raising the floor again needs an ADR superseding ADR-0010 -- a package.json-only change will pass tests and lie to users
• r-9a5e17 6d68703 (claim) — commands are advertised in --help only once they work -- test/cli.test.ts holds the landed and unlanded lists, and moving a name between them belongs in the commit that wires it
• r-4d8a13 b1034ca (claim) — the two Expires branches must stay disjoint -- widening the free-text branch without narrowing the date-shape exclusion puts the typo hole straight back
• r-1f4b26 65f01c7 (claim) — if this test goes red, fix the commit or fix the spec -- weakening an assertion to get green is how a dogfooding gate becomes decoration
• r-5a8c04 c46a577 (claim) — do not add --grep anywhere under src/ -- test/source-guards enforces its absence and will fail the build
• r-c0f4e2 3d249cd (claim) — ADR-0008 and ADR-0009 keep the literal string Annals on purpose -- mechanical substitution there destroys the decision trail
• r-c0f4e2 3d249cd (claim) — the residual grep for lore_query reports a false positive because commitlore_query contains it as a substring, so check the prefix
• r-b2e7f1 00d348d (claim) — spec/fixtures and spec/contract-cases are the contract -- prose in SPEC.md explains them, it does not define them

git log --follow accepts exactly one pathspec, so renames are not followed for 38 paths; query one path at a time to follow its rename chain

withheld the content of 2 record(s) graded blocked: a Ruled-out, Verified trailers matching an injection pattern is reported, never quoted (SPEC §7)

_{Trailer violations fail this check. Active constraints are informational — they are what the repository already decided, not a verdict on this PR.}