Commit graph

8 commits

Author SHA1 Message Date
Julian Knutsen
b3d17caa6d Merge release/1.3.0 into main (post-tag forward-port)
Forward-ports the 38 commits that shipped on release/1.3.0 (tagged v1.3.0 at
f45b249ce) into main, as RELEASING.md mandates after a tag. None of them had
ever been forward-ported. Recorded as a merge so main becomes a superset of
the release branch and the lineage is in the history.

Migration ordinal collision (the reason this needed a human-shaped merge):
both branches independently claimed clone-local ignored slot 0026 under
different filenames, so git merged both in with no conflict and left the
series with two migrations at ordinal 26 — a single-integer cursor cannot
address that, and migrationSource.list() panics on it.

Main's ignored/0026_add_wisps_current_revision is renumbered to 0027.
Release's 0026_dep_rekey_dedup_marker is in the shipped v1.3.0 tag, so field
stores have already recorded it at 26 and it can never move; main's twin has
never shipped in any release, so it is the one that is free to move. 0027 was
unused in the ignored series (both sides topped out at 26).

This trips check-migration-hygiene.sh Check C (frozen migrations), which has
no exemption mechanism. That is expected and accepted: breaking the collision
requires a rename, and the ignored series' cursor table is itself dolt-ignored,
so its content hashes are clone-local and never participate in the cross-clone
ContentHashSkew comparison that Check C exists to protect. Main's 0067 body is
deliberately NOT edited for the same reason in reverse — it is main-plane and
its hash IS compared across clones.

Conflicts resolved:

  CHANGELOG.md                       release's finalized [1.3.0] section kept
                                     byte-identical; main's two unreleased
                                     entries (#6023, #5859) moved up under
                                     [Unreleased] where they belong
  cmd/bd/init_safety.go              union — release's added paragraph is
  cmd/bd/init_safety_help.go         accurate against the merged code (three
                                     exit-12 sources, incl. init.go:3147)
  internal/storage/uow/dolt_sql_provider.go
                                     kept main's newProvider refactor AND
                                     release's readOnly field/assertion;
                                     newProvider gained readOnly: opts.readOnly
                                     so release's read-through-refused-migration
                                     behavior survives main's refactor
  .github/workflows/main.yml         single -timeout=30m per release's #6091
  scripts/ci_workflow_test.go        design (flag on the invocation, not in
                                     matrix.test-flags); the shadowed 25m in
                                     matrix.test-flags removed
  scripts/migration-test/lib/versions.sh
                                     union — main's darwin/arm64 corpus plus
                                     release's v1.2.2 linux/amd64 entry
  integrations/beads-mcp/uv.lock     ruff 0.16.5 (release, newer); block is
                                     internally consistent, uv lock --check ok
  default.nix                        vendorHash left at main's value and is
                                     KNOWN STALE — see below

Version stamp lands at 1.3.0 (main had been sitting at the previously-released
1.2.2, this project's between-releases pattern). check-versions.sh: 24/24.

Known follow-up: default.nix vendorHash. The merged go.mod/go.sum is a genuine
union (release's kin-openapi/oapi-codegen bumps + main's newer Dolt stack) and
matches neither side, so neither recorded hash is correct. It must be
regenerated with scripts/update-nix-vendorhash.sh. The repo's automatic fixer
(update-vendor-hash.yml) is dependabot-only and will not run on this PR.
2026-09-15 22:09:13 +00:00
Julian Knutsen
d530cddfa6
ci: add advisory cyclomatic complexity reporting (#6081)
* ci: add advisory cyclomatic complexity reporting (bd-7g21)

Add a pinned gocyclo report, checked-in baseline, stable-key PR diff, and opt-in guard for shipped Go code. Run the report on every PR as a non-required artifact while maintainers measure signal quality; preserve existing complexity as grandfathered debt.

Agent-Signature: unknown-model/unknown-reasoning

* test(protocol): refresh dependency removal corpus
2026-08-30 19:05:17 -07:00
Julian Knutsen
b858a29e4a
fix(contracts): JSON contract fixes before 1.3.0 freezes them — string revision tokens, --set-metadata scalar typing, create --json nano timestamps (#6053)
* fix(metadata): restore v1.2.2 scalar typing for --set-metadata values

8ebd53e88 moved the CLI's metadata-edit helpers into
internal/storage/metadata.go and, in the move, replaced v1.2.2's
toJSONValue inference with a MetadataEditValue that always json.Marshals
the value as a string. The intent was GH#4146 (a numeric-looking id or a
version like "1e3" came back as a JSON number, breaking map[string]string
Go consumers), but it silently changed the shipped CLI contract:
`bd update --set-metadata k=5` started storing "5" instead of 5. That
regression shipped only in the deprecated/superseded v1.2.1, never in
v1.2.2, and 1.3.0 would freeze it.

Restore v1.2.2's inference body-for-body inside MetadataEditValue, so the
parity claim stays checkable against `git show v1.2.2:cmd/bd/update.go`:
"null" is JSON null, "true"/"false" are booleans, a spelling that scans
as a float AND is valid JSON on its own is emitted as that literal
(5 -> 5, 1e3 -> 1e3, 0.50 -> 0.50, while 05, +5 and NaN stay strings),
and everything else is a string. Every --set-metadata caller funnels
through this one function: embedded (cmd/bd/update.go ->
storage.ApplyMetadataEdits), proxied (parseSetMetadataFlags) and the
update executor's []string path.

GH#4146's concern is served by the explicitly typed routes, which are
untouched: --metadata / --metadata-json on the CLI (MergeMetadataJSON)
and the typed set map on the HTTP/Go path (applyTypedMetadataEdits).

No data migration: a "5" written by an in-window build is
indistinguishable from a string a user set intentionally through the
typed paths, so normalizing stored metadata would corrupt intended data.
Re-running the same --set-metadata k=5 retypes any given key.

Tests: new table in internal/storage/metadata_edit_value_test.go pinning
the v1.2.2 matrix plus an ApplyMetadataEdits end-to-end; the tests that
pinned the string-always behavior are flipped (domain/db mergeops suite,
update_lifecycle patch mapping, cmd/bd toJSONValue table) and the
embedded + proxied CLI suites now assert a stored JSON number. The
contract corpus is regenerated: its update/list/ready goldens run
`--set-metadata phase=2`, so `"phase": "2"` becomes `"phase": 2` and
nothing else moves.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* fix(create): echo full-precision timestamps from bd create, not the DATETIME(0) re-read

b92442d1a routed `bd create` through issueops.Lifecycle, whose executors
build their result by re-reading the row they just wrote
(HydrateIssueOperationResult -> GetIssueInTx). created_at/updated_at are
DATETIME(0) columns, so that snapshot comes back at whole-second
precision and cmd/bd/create.go echoes it. v1.2.2 returned the caller's
own in-memory struct, which PrepareIssueForInsert stamps with
time.Now().UTC() including nanoseconds, so `bd create --json` used to
print e.g. 2026-08-28T12:34:56.789012345Z. Agents that create several
issues in a burst order them by exactly that fraction; rounded to the
second they all tie.

Restore the echo with OverlayCreateTimestamps: after hydration, put back
the created_at/updated_at (and closed_at, when the write set one) the
INSERT actually sent. Everything else on the snapshot stays DB-truth,
which is the facade's contract — only create, and only these fields.

Applied at every create body, not just the two the CLI reaches:
issueops.ExecuteCreate and ExecuteCreateBatch behind the dolt and
embedded-dolt stores, and the unit-of-work provider's own Create,
CreateBatch and batch-apply create item, which is what the proxied server
and POST /v0/beads/issues run on. Fixing only the shared executors would
have left the two bodies disagreeing about the same promise.

What is NOT changed, because it is not a regression: `bd show --json` and
`bd list --json` answered whole seconds in v1.2.2 too — they read the
column — and update/close/reopen re-read after writing there as well.
Widening the columns to DATETIME(6) would give reads sub-second times
too, but that is a schema migration on user Dolt DBs and touches paths
that deliberately compare at second precision; it is a 1.4 change.

The accepted skew, which predates this and stays: the engine ROUNDS to
the column rather than truncating, so a later read of the same row can
sit up to half a second either side of the create echo.

Tests: two new conformance cases, run on all three backends —
RunLifecycleCreateEchoesSubSecondTimestamps (a caller-supplied
nanosecond stamp must survive to the result exactly; the auto-stamped arm
stays a bounded smoke check, since requiring a non-zero fraction off the
clock is flaky by a billionth) and RunBatchCreatorEchoesSubSecondTimestamps
(per item, since both bodies build the result one snapshot at a time).
Plus a cmd/bd embedded test asserting `bd create --json` prints a
fractional part, and one httpapi assertion that the wire does not round
the role's snapshot on the way out. All four fail on the pre-fix tree.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* fix(httpapi,types)!: revision / expected_version tokens are opaque JSON strings

The optimistic-concurrency token is minted by freshRowLock over the FULL
int64 range (crypto-random, non-zero) and published on the wire as a JSON
number: `revision` on responses, `expected_version` on guarded requests.
A JSON number does not survive a consumer that decodes into an IEEE-754
double — JavaScript's JSON.parse, Go's `any`, Python's `float`, jq. Live
tokens run past 5e17, where a double's ulp is already 64, so such a
client reads back a value NEAR the token, echoes that as its guard, and
earns a 409 against a row nobody else touched. The spec already carried
"DECODE IT AS A 64-BIT INTEGER" paragraphs telling clients to work around
this; that is a workaround for a wire type that should not have been a
number.

Emit and accept the token as a decimal STRING instead. It is documented
as opaque and EQUALITY-ONLY — compare it, never order or interpret it —
and a string round-trips exactly in every JSON consumer. It also leaves a
future backend free to mint a token that is not an int64 at all.

Internals are untouched: freshRowLock, the row_lock BIGINT column, its
migration, types.Issue.RowVersion and the ExpectedVersion *int64 guards
on the issueops requests all stay int64. Only the wire projection moves,
through the one spelling of the encoding — types.RevisionToken and
types.ParseRevisionToken.

STRICT STRING ONLY, with no transitional number-or-string acceptance.
This API already refuses unknown members by name and keeps one spelling
of the guard, and a number is precisely the shape a double-based client
has already rounded before it left the client — accepting it would
preserve the defect. A numeric guard is a 400 naming the member.

Chosen over clamping freshRowLock to 53 bits: a clamp does not fix rows
already minted with full-range tokens by in-window builds, so a JS
consumer reading one still rounds past 2^53 — repairing that would need a
row_lock normalization sweep over issues and wisps, a migration days
before a tag.

Surface: types.IssueDetails.Revision (what `bd show --json` prints and
GET /v0/beads/issues/{id} returns), the five hand-assigned httpapi
response fields, applyVersionGuardMember (now the reader for the batch
update item too, ahead of its typed decode, so a mistyped token still
earns a 400 naming the member), Problem.expected_version, and 14 OpenAPI
members regenerated through `make api-gen`. actual_version goes with them
— it is documented as "the `revision` the row was found holding", so
leaving it an integer would make the expected/actual pair disagree about
its own type; it is declared but never populated, so nothing changes
behaviorally.

Nothing shipped in a tagged release ever carried this member: v1.2.2 has
no internal/httpapi at all and no `revision` anywhere on the wire, so the
whole surface is in-window and can still be changed compatibly. Legacy
migration-0054 rows read as the string "0" with the same CAS semantics.

Corpus goldens are UNCHANGED: the canonicalizer already replaced any
`revision` value with the string "<REVISION>" whatever its JSON type.

Tests: types-level pins that the marshaled member matches `"revision":
"-?\d+"` and that RevisionToken/ParseRevisionToken round-trip MinInt64,
MaxInt64 and 2^53+1, plus a JS-realistic decode of 2^53+1 with a float64
control proving the token really is one a number would corrupt; httpapi
refusal tests for a numeric guard on update, close, reopen, delete and
both batch item kinds; a 409 echo asserted as the string; and the proxied
serve integration tests now splice the response's own token back in
verbatim rather than re-rendering a parsed one.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>
2026-08-29 05:20:27 +00:00
Athos Bernardes
d871b5c54a
fix(show): explain that "not found" may mean deleted, not never-existed (#5802)
* fix(show): explain that "not found" may mean deleted, not never-existed (ga-m6inyb)

bd delete and wisp purge both remove a row (and its events) from the
live tables with no trace left behind, so `bd show` on a deleted or
purged id is byte-for-byte identical to one that never existed —
confirmed live (Gas Town HQ Dolt server) against two real archived-wisp
ids, and against dolt_history_wisps (always empty for wisps by design,
per the dolt_ignore comments throughout internal/storage/dolt).

An earlier draft of this fix tried to auto-detect the distinction via
bd's own commit history (store.History), but that scan has a
documented multi-second-to-timeout cost even on a healthy production
database (reproduced live: `bd history` timed out with "row read wait
bigger than connection timeout" on both a real archived wisp and a
made-up id on the same server) — wiring it into show's default
not-found path would regress the common typo case to fix a rarer one.
Wisps never have history at all regardless, so it wouldn't have
resolved the reported case either way.

Instead, the not-found message now says plainly that the id may have
existed and been removed, and points at `bd history <id>` as the
(separate, opt-in) way to check further — additive only: the JSON
"error" field text is unchanged, the new context lands in a "hint"
field; the direct-mode text path keeps "Issue %s not found" as its
first line and adds the hint as a second line.

Also found, filed separately, not fixed here: `make ci-pr-lint`
surfaces 2 pre-existing gosec findings in darwin/nonlinux-only files
that the Linux CI runner never lints (no darwin cross-lint pass,
unlike the existing Windows one) — confirmed present on a clean
origin/main checkout, unrelated to this change.

* fix(show): update contract-pinning tests for the new not-found hint (CI)

CI on PR #5802 caught 4 test corpora this change needed to update but I
missed locally (my earlier local run only matched tests named
TestShow*; these pin the SAME code path — reportIssueLookupFailure and
show.go's JSON not-found branch — under different names):

- cmd/bd/proxied_lookup_failure_test.go: TestProxiedLookupReportsMissingIssue
  (show / show --refs / show --children / reopen rows) and
  TestReportIssueLookupFailure both assert exact stderr text by design
  ("Their lines here are unchanged, and that is the point" — the
  file's own doc comment). Updated the 4 affected wantNotFound values
  to include the new hint, computed via showNotFoundHint() rather than
  duplicated as a literal, so the two can't drift independently.

- cmd/bd/protocol/testdata/corpus/{flat,envelope}/error.json and their
  manifest.json SHA-256 entries: the committed golden-file corpus for
  `bd show <missing> --json`. `make corpus-regen` needs Docker
  (unavailable here) to regenerate for real, so I independently
  reimplemented corpus.go's exact marshalCanonical encoding (same
  json.Encoder settings: SetEscapeHTML(false), 2-space indent) in a
  standalone program and confirmed both edited files are byte-for-byte
  identical to what that encoder produces, before hand-computing and
  writing the new SHA-256 manifest entries.

Two more matches from a repo-wide grep for the old exact string
(linear_test.go, update_claim_proxied_test.go) needed no change:
linear_test.go's is an unrelated subsystem's own literal message, and
update_claim_proxied_test.go asserts via strings.Contains, which the
purely-additive hint doesn't break.

Local verification (same commands as before, still Docker-less):
go build ./..., go vet ./cmd/bd/..., go vet -tags=integration, make
ci-pr-lint (2 pre-existing unrelated darwin-only gosec findings only),
and the full previously-failing test names plus a broader NotFound|
LookupFailure|Claim sweep — all green.

* docs(changelog): add [Unreleased] entry for the show not-found hint (ga-m6inyb)

Addresses reviewer bee-ghosttrack's second ask on PR #5802: "this adds a
line to one of bd's most common outputs and a new JSON field" needs a
CHANGELOG entry. Filed under Fixed, since the underlying bead is a bug
(archived and never-existed issues were indistinguishable via bd show).

Also documents, per the reviewer's first ask, that the direct-mode
single-ID not-found path's first line is not purely additive: it
changes from "Error fetching <id>: ..." to "Issue <id> not found" to
match the wording the other not-found paths already used.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Sonnet 5 <noreply@anthropic.com>
Co-authored-by: Steve Yegge <steve.yegge@gmail.com>
2026-08-20 08:11:39 -07:00
Julian Knutsen
8c7db45c8b
fix(show): expose guarded-write revision in JSON (#5353)
* fix(show): expose guarded-write revision in JSON (bd-bwa7n)

Project RowVersion only at the bd show CLI edge so guarded subprocess clients receive the current opaque token without changing generic Issue, JSONL, or HTTP serialization. This preserves main's object-model boundary while restoring the show contract established by PR #4682.

Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>

Agent-Signature: codex-unknown-model-unknown-reasoning on behalf of CI Bot

* fix(show): resolve revision CLI/HTTP parity + emit legacy-zero token (bd-bwa7n)

Maintainer adoption fixup for PR #5353 (adopt-pr): pre-review CI normalization
plus the review-loop resolution of the CLI/HTTP parity decision that pre-review
deliberately deferred.

PR #5353 exposes the guarded-write revision (the row_lock optimistic-concurrency
token) in `bd show --json` via the CLI-edge DTO. That token is a per-write random
int64, so several oracles that pin bd's JSON shape needed to learn about it.

Pre-review CI normalization (mechanical volatile-token gaps):

- Contract corpus golden (cmd/bd/protocol): CanonicalizeJSON did not scrub the
  new field, so the show blob diffed on the random value and the double-run
  determinism check failed. Add a volatileValueKeys scrub for `revision` (pin the
  field's presence, replace its value with <REVISION>, same treatment as
  timestamps) and regenerate the two show goldens + manifest SHAs.
- Differential regression (tests/regression): the v0.49.6 baseline never emitted
  `revision`, and its value is random per write, so it is pure cross-version
  noise. Add it to volatileFields so normalizeIssue strips it before the
  baseline/candidate diff.

Review-loop resolution (was DEFERRED at pre-review; now decided):

- CLI/HTTP read-parity (major): `bd show --json` emits `revision` but the
  apigen-frozen GET /v0/beads/issues/{id} keeps RowVersion json:"-", so the
  field-level parity oracle (TestProxiedServerServeReadParity/show) would flag it
  as unreviewed drift. Resolve as an accepted CLI-only surface: add a documented
  readsParityAllowlist["revision"] entry and rewrite the allowlist narrative.
  Exposing the token over the frozen v0 HTTP object is out of scope; the token is
  only meaningful to the CLI guarded-write path.
- Legacy-zero token (minor): drop `omitempty` from the show DTO so a legitimate
  RowVersion==0 CAS token is emitted instead of being conflated with an absent
  field; a guarded client must read the 0 it needs to send on un-mutated legacy
  migration-0054 rows.
- Test evidence (minor): add TestProjectShowJSONDetailsEmitsZeroRevision pinning
  the legacy-zero wire behavior.

Validated locally: git diff --check; go test ./internal/types (RowVersion),
./cmd/bd (focused show unit tests incl. the new zero-revision case),
./cmd/bd/protocol (corpus goldens unchanged), and the proxied Dolt parity oracle
TestProxiedServerServeReadParity (the show subtest now excuses `revision`).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

---------

Co-authored-by: CI Bot <ci@beads.test>
Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>
2026-08-05 19:51:49 -07:00
kev
0e6d1e19d9 fix(protocol): update corpus manifest sha256 hashes for metadata coercion
The prior commit fixed the six golden blob files (phase: 2 -> "2") but
left manifest.json's per-blob sha256 hashes stale, so the manifest-drift
check still failed even though the per-blob content check passed.

Co-authored-by: Cursor <cursoragent@cursor.com>
2026-07-07 23:38:24 -04:00
kev
86478c0aa1 fix(protocol): update contract corpus golden files for metadata string coercion
phase=2 now stores as JSON string "2" instead of number 2 across all
corpus goldens (flat + envelope variants for update/list/ready), matching
the --set-metadata always-strings behavior. Update the explanatory
comment in corpus.go and CATALOG.md to match.

Co-authored-by: Cursor <cursoragent@cursor.com>
2026-07-07 23:13:01 -04:00
Julian Knutsen
1914af5852
test(protocol): golden-JSON contract corpus + diff guard (Beads↔Gas City contract, Phase 2) (#4490)
* test(protocol): add canonicalized golden-JSON contract corpus + diff guard (contract Phase 2)

Producer half of the Beads<->Gas City cross-version contract-test system.
Generates a deterministic, canonicalized golden-JSON corpus of bd's --json
wire surface (create/show/list/ready/dep/count/version + the
{error,schema_version} envelope, in both flat and BD_JSON_ENVELOPE=1
variants) and fails on any unreviewed diff. Gas City vendors this corpus
to detect cross-version drift without a live bd.

- corpus.go: deterministic command plan, canonicalizer (timestamps -> <TS>,
  object arrays stable-sorted, sorted keys), provenance manifest.
- corpus_test.go: TestCorpusGolden (byte-compare vs committed corpus;
  -corpus.update regenerates; Dolt-boot is an infra skip, a diff is a hard
  fail). Pins IDs with --force for determinism; captures stdout only.
- canonicalize_test.go: canonicalizer unit tests + TestCorpusDoubleRunByteIdentical.
- make corpus-regen; cmd/bd/protocol/CATALOG.md.

Pre-commit hook bypassed: it fails in golangci-lint (built with Go 1.25,
repo targets 1.26.2) unrelated to this change; gofmt, go vet, and the full
corpus test suite were run manually and pass.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* ci: gate the contract corpus in beads CI (contract-corpus job)

Adds a Docker-enabled contract-corpus job to the PR gate that regenerates
the canonicalized golden corpus from this branch's bd and byte-compares it
to the committed testdata/corpus/, plus the determinism double-run. An
unreviewed bd --json wire change is now a hard CI failure on the producer
side, mirroring the gascity consumer gate. Wired into ci-gate/CI_GATE_REQUIRED.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* fix(protocol): drop build-provenance from the corpus so it is reproducible across build envs

The contract-corpus CI gate caught a real reproducibility bug: bd version
--json embeds a 'commit' field from Go's VCS stamping that varies by build
environment (a local worktree build omits it; a CI clean-clone build embeds
the SHA), so the committed golden corpus failed the diff in CI. Canonicalization
now drops the 'commit' key entirely (value AND presence vary), and the manifest
no longer records bd_commit. bd_version plus the per-blob checksums remain the
reproducible provenance.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* ci: publish the contract corpus as a release artifact (contract Phase 3)

Ships cmd/bd/protocol/testdata/corpus as beads_<version>_contract_corpus.tar.gz
with each release and appends its checksum to the release checksums.txt, so Gas
City can anchor its vendored-corpus drift-check to a signed beads release rather
than a self-recomputed manifest. Runs in the goreleaser job before the macOS
job's serial checksums.txt append (goreleaser-macos needs goreleaser), so the
corpus entry is preserved.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* test(protocol): extend the contract corpus to the full command surface

Adds update, close, reopen, delete, dep remove, and two more create beads to
the corpus plan, taking it to 17 commands x {flat, envelope}. New shapes pinned:
the update/close/reopen issue arrays (incl. close_reason + closed_at), the
dual-key dep edge {issue_id, depends_on_id, type, status} for add AND remove,
the delete confirmation {deleted, dependencies_removed, references_updated}, and
metadata coercion (--set-metadata phase=2 -> integer 2) plus label round-trip.
Mutations run after the show/dep_list reads so those long-standing blobs stay
byte-identical; list/ready/count now reflect post-mutation state. Golden +
double-run determinism verified.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* fix(protocol): make the corpus version-agnostic (placeholder version/branch/build)

The contract-corpus gate failed when beads main bumped to 1.1.0-rc.1: the corpus
version.json pinned the literal bd version, which changes every release (CI builds
the PR merged with current main). The corpus pins wire SHAPES, not release
identity, so canonicalization now replaces version/branch/build values with
placeholders and the manifest drops bd_version/bd_commit entirely. schema_version
(the coordination canary) + per-blob checksums remain. gc's real version
parsing/gating is covered by the cross-version matrix + bd_version_pin_test.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* fix(protocol): satisfy build-tag policy + misspell lint for contract corpus

Pre-review CI repair for the golden-JSON contract corpus PR (#4490):

- Makefile: add -tags "$(BUILD_TAGS)" to the corpus-regen target so it
  passes scripts/check-build-tags.sh (ICU build-tag policy, see
  docs/ICU-POLICY.md), matching every other go test/build target.
- corpus.go: fix "re-marshalled" -> "re-marshaled" (misspell, US locale).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

* fix(protocol): harden the contract corpus per maintainer review

Maintainer review fixups for the golden-JSON contract corpus (PR #4490),
folded into one maintainer commit across review iterations.

- CanonicalizeJSON now rejects trailing stdout after the first JSON value.
  A command that printed valid JSON followed by a warning line (or a second
  JSON value) would otherwise be silently truncated to the leading value and
  pass the corpus gate, while a real consumer decoding the whole stream would
  choke. Add regression tests for trailing text, multiple values, and the
  still-allowed trailing-whitespace case.
- TestCorpusGolden now asserts the committed corpus file set is exactly the
  generated blobs plus manifest.json, and `make corpus-regen` recreates each
  mode directory before writing. A capture removed or renamed in CorpusPlan can
  no longer leave a stale blob committed and shipped in the release archive.
- The required contract-corpus CI job sets BEADS_PROTOCOL_REQUIRE_DOLT=1 and
  the corpus tests hard-fail (not skip) when the Dolt store is unavailable, so
  the gate cannot report success without exercising the golden and double-run
  checks.
- Document the intentionally global (bare-key) scope of provenance
  canonicalization and the required future action if a non-version command adds
  a commit/version/branch/build field.
- Make the release corpus-checksum append idempotent so a re-run of the
  goreleaser job does not leave a duplicate row in checksums.txt.
- generateCorpus now pins each capture's subprocess exit status instead of
  discarding cmd.Run(): every capture must exit 0 except the dedicated error
  capture, which must exit non-zero with bd's not-found code. Otherwise the
  corpus could pass while a "successful" command exited non-zero, or while the
  error capture stopped failing, leaving the exit-codes-and-errors half of the
  error blob's contract (CATALOG.md) unpinned. Add a checkCaptureExit helper
  and TestCheckCaptureExit, and run the test in the required CI job.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

---------

Co-authored-by: CI Bot <ci@beads.test>
Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
2026-07-04 18:54:28 -07:00