Commit graph

61 commits

Author SHA1 Message Date
Julian Knutsen
ae1a493e01
test(bazel): fully green //..., tag taxonomy + docker lane, sharding, test sandbox ceiling (#6871)
* fix(doctor): detect test binaries with testing.Testing(), not the file name

getBdBinary refuses to return a test binary as "bd" so fix tests cannot
fork-bomb by re-running themselves. The guard matched only the `go test`
naming (<pkg>.test). Bazel names test binaries <target>_test, so under
`bazel test` every fix that shells out to bd re-ran the whole fix_test suite,
recursively (~60 levels), until the 300s timeout.

testing.Testing() is true for any binary linked as a test by `go test` or
rules_go (both set testing.testBinary=1), whatever its name. The name check
stays as a fallback. bd already links package testing, so the product binary
gains no dependency. Behavior under `go test` is unchanged.

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

* test(bazel): tag taxonomy, docker lane, and green //scripts targets (slice B5)

`bazel test //... --config=ci` is now fully green, locally and with
--config=remote-exec.

- scripts_test declares what it reads and runs: this package's own tree
  (:scripts_files), .github/** (//:workflow_files, widened from the
  workflows), and .buildflags/.test-skip for scripts/test.sh. The complexity
  diff test builds a one-commit git fixture instead of git-archiving the
  real checkout's HEAD. Under Bazel it skips the whole-repo testing.Short()
  scan (it would pass vacuously over the runfiles) and the two release
  formula tests (.beads is in .bazelignore). Tagged host-tools +
  no-remote-exec: it runs the host's git/python3/coreutils and some subtests
  skip without git.
- prlintmake_test resolves fmt-check.sh through bazeltest.CallerDir and
  declares it; it needs only bash (gofmt is shimmed), so it stays untagged
  and runs remotely.
- //cmd/bd/doctor/fix:fix_docker_test reruns the fix_test binary (no second
  compile, tools/bazel/go_test_variant.sh) with BEADS_FIX_REQUIRE_DOLT=1, like
  pr.yml's container-backed doctor/fix job. Tagged requires-docker +
  no-remote-exec; `--config=docker` selects it (race, no -short, no
  BEADS_TEST_SKIP=dolt). fix_test itself stays untagged: under prcore it
  skips the Dolt-backed tests exactly as pr-core's `go test` does.
- scripts/bazel_policy_test.go: every BUILD `tags` value must be in the
  taxonomy, be named in the comment above its rule, and host-bound tags must
  come with no-remote-exec; test:prcore must exclude requires-docker,
  embedded and manual.

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

* test(bd): reset git's cwd cache in TestContextRoutesNameOneWorkspaceTheSameWay

The test chdirs into a fresh git repo but reset only beads' caches. git
caches the cwd's repository context process-wide, so when an earlier test in
the same process had resolved it from a non-repo directory (for example
TestCollectMetadataEntriesNoBeadsDir), GetMainRepoRoot kept answering "not a
git repository". Test order hid it under `go test ./cmd/bd`; Bazel sharding
reorders tests and exposed it. Reproduces with plain go test:

  go test -run '^(TestCollectMetadataEntriesNoBeadsDir|TestContextRoutesNameOneWorkspaceTheSameWay)$' ./cmd/bd

The cache is reset on entry only. Resetting it again in cleanup changes what
later tests inherit, and TestCreateRemoteRepoSkipsLocalDatabaseGuard (which
never resets it) then fails under the unsharded go test order.

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

* test(bazel): shard bd_test and embeddeddolt_test; keep test re-execs shard-free (slice B6)

- //cmd/bd:bd_test shard_count = 16, //internal/storage/embeddeddolt:
  embeddeddolt_test shard_count = 8. Remote -race under --config=ci: bd_test
  max shard 61-82s (unsharded 252-264s), embeddeddolt max shard 84-122s
  (unsharded 207-377s). The embeddeddolt max is a single test
  (TestWithPeerAuth, ~93s), so more shards would not lower it. Every shard
  runs tests (bd 161-172 top-level tests each, embeddeddolt 15-20).
  protocol (4s), legacysqlite (4s) and dbproxy/server (22s) stay unsharded.
- Tests that re-exec their own binary now pass bazeltest.ShardFreeEnv
  (a no-op under go test), so a helper child does not inherit
  TEST_SHARD_INDEX/TEST_TOTAL_SHARDS/TEST_SHARD_STATUS_FILE and filter away
  the one test it was asked to run: dolt suite_leak_linux, dbproxy
  force_stop_linux, workspacegate (3 helpers), metrics spawn_reap, bd
  worktree_remove, conformance role_bundle, linear synclock (windows).
  scripts/test_script_test.go (child env built from scratch) and
  repro-dolt-prod-timeouts (copies the binary, never runs it) need nothing.

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

* test(bazel): keep sharded bd_test off ~/.beads and keep its stdio leak guard

Two things sharding //cmd/bd:bd_test exposed:

- config.Initialize walks up from the test's cwd for .beads/config.yaml and,
  under BEADS_TEST_IGNORE_REPO_CONFIG, stops at the module root (go.mod).
  The runfiles tree had no go.mod, so the walk left it; with the output base
  under $HOME it loaded the developer's ~/.beads/config.yaml (here
  dolt.shared-server: true) and two embedded-mode autocommit tests failed
  locally, though not on remote workers. bd_test now declares //:go.mod, so
  the walk stops at the runfiles root as it stops at the checkout under go
  test. Unsharded runs hid this: an earlier test re-initialized config first.
- TestZZStdioNotLeaked skipped in every shard, because the baseline test is
  always in shard 1 and the guard in another. Without a baseline it now
  checks the descriptors instead (a leaked capture leaves a pipe where fd 1
  or 2 was). Under go test the baseline is always captured, so nothing
  changes there.

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

* chore(bazel): sync BUILD files with test files added on main

Gazelle picks up cmd/bd and internal/notion tests that landed on main after
the last sync (make bazel-sync).

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

* fix(discovery): add BEADS_CEILING_DIRECTORIES; bound bazel tests' walks

bd finds its workspace by walking up from the working directory for .beads
and .beads/config.yaml. Under `bazel test` the working directory is in the
runfiles tree under the output base, usually below the developer's HOME, so
the walks left the sandbox: tests read the developer's ~/.beads/config.yaml
(results depended on it) and wrote into ~/.beads (interactions.jsonl from the
audit log, .local_version from version tracking).

BEADS_CEILING_DIRECTORIES takes git's GIT_CEILING_DIRECTORIES form (a PATH-
style list of absolute directories): a search starting inside a ceiling never
examines the ceiling or anything above it; the start itself is always
examined. Unset, nothing changes. Honored by every upward .beads/config
search: beads.AncestorDirWalk (all FindBeadsDir walks), config.Initialize
(the go.mod and config.yaml walks, and the worktree-fallback git probe, whose
routing scrub drops GIT_CEILING_DIRECTORIES), findProjectBeadsDir, the legacy
upgrade guard, the --db beads-dir walk, store reopen and findBeadsRepoRoot.
The migration-freeze marker walk is left alone on purpose: it is a write
safety gate, and BD_MIGRATION_FREEZE_FILE is already its explicit override.

tools/bazel/test_env.sh sets BEADS_CEILING_DIRECTORIES and
GIT_CEILING_DIRECTORIES to the runfiles root, TEST_TMPDIR and its own temp
root. It does not fail on an ancestor .beads: a live ~/.beads above the
output base is normal on a developer machine. bd_test no longer needs
//:go.mod as a walk stop.

Canary check: with an invalid-YAML .beads above a scratch --output_base,
compact, issueops, validation and bd_test pass under --config=ci and nothing
is written there; the previous wrapper fails on it and writes
interactions.jsonl into it.

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

* test(bd): check for leaked stdio after m.Run in every process

TestZZStdioNotLeaked only sees the tests that ran before it in the same
process. Under Bazel's 16-way sharding that is ~1/16 of bd_test: the baseline
test is in shard 1, the guard in another shard, and leaks in the other shards
were never checked.

TestMain now compares os.Stdout/os.Stderr after m.Run with the streams from
before it (runTestsAndSweep, so every shard and every go test run) and fails
the process on a leak. The one allowed change is the framework's own
os.Stderr = os.Stdout under -json. TestZZStdioNotLeaked stays for its go test
report and skips when it has no baseline; the descriptor fallback added for
sharding is gone.

Verified: a test that leaks os.Stdout fails `go test -run` for it alone, with
and without -json; a clean -json run passes.

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

* test(bazel): keep host-tools results out of the remote cache; tighten tag policy

- //scripts:scripts_test (host-tools, no-remote-exec) ran locally but its
  result was still uploaded to the remote cache and served to other clients,
  though the action key does not cover the host's git/python3/bash. It is now
  also tagged no-remote-cache (neither read nor uploaded). Checked: after a
  --config=remote-exec run and `bazel clean`, a rerun without the disk cache
  executes the test again instead of taking a remote cache hit.
- Under Bazel a missing git or bash now fails those tests instead of
  skipping (the host-tools tag promises them); under go test they still skip.
- Tag policy: host-tools requires no-remote-exec and no-remote-cache;
  `tags = [...] + X` is rejected as non-literal; every --test_tag_filters set
  by test:prcore or a config that expands it (test:ci, transitively) must
  exclude requires-docker/embedded/manual, not only the first prcore line.

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

* fix(bazel): run go_test variants from their package directory

rules_go gives a go_test GO_TEST_RUN_FROM_BAZEL=1 (and its `env`) through
RunEnvironmentInfo; an sh_test that reruns the binary gets neither, so the
binary skipped its chdir into the package directory and ran from the
runfiles root. go_test_variant.sh now exports GO_TEST_RUN_FROM_BAZEL=1, and
its header says the variant target must repeat the go_test's `env`.

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

* test(bazel): docker-lane variants for domain/db, uow and protocol

--config=docker only ran doctor/fix. pr.yml's container jobs also run
internal/storage/domain/... + uow/... (race, no -short, Dolt image pulled)
and cmd/bd/protocol (BEADS_PROTOCOL_REQUIRE_DOLT=1). Under --config=ci those
container suites skip (BEADS_TEST_SKIP=dolt), so without variants their
coverage would vanish if Bazel replaced those jobs.

- testutil: BEADS_TEST_REQUIRE_DOLT_CONTAINER=1 makes RequireDoltContainer
  and StartIsolatedDoltContainer(Handle) fail instead of skip when the Dolt
  container is unavailable (the generic form of BEADS_FIX_REQUIRE_DOLT).
- db_docker_test, uow_docker_test (4 shards) and protocol_docker_test
  (8 shards, BEADS_PROTOCOL_REQUIRE_DOLT=1) rerun the go_test binaries via
  go_test_variant.sh, repeating their `env`; tagged requires-docker +
  no-remote-exec. The other domain/tracker packages have no container tests
  and already run under --config=ci.

`bazel test //... --config=docker --test_arg=-test.v`: 4/4 PASS; db 908
PASS / 0 SKIP, uow 985 PASS / 32 SKIP (conformance capabilities the backend
does not implement, as under go test), protocol 151 PASS / 2 SKIP (tracked
known gaps). With --test_env=BEADS_TEST_SKIP=dolt, db_docker_test fails.

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

* test: shard-free env for the embeddeddolt concurrency helper; 2m bd init timeout

- concurrency_test re-execs its test binary with -test.run=^TestHelperProcess$
  inside the now-sharded embeddeddolt_test; pass bazeltest.ShardFreeEnv so a
  child cannot inherit TEST_SHARD_* and filter its one test away (it is
  gated by BEADS_TEST_EMBEDDED_DOLT=1, so dark today).
- initBeadsWorkspace / runBDStdout (TestClose_UpdatesLastTouched and the
  gemini prime hook tests) allowed 30s per bd subprocess. A -race bd on a
  loaded host exceeded that for a single `bd init` (killed at 30.18s in 1 of
  3 sharded remote runs; the whole test otherwise passes in ~21s), so allow
  2 minutes.

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

* test(bd): give TestCreateRemoteRepoSkipsLocalDatabaseGuard its own git state

The test chdirs into a fresh non-repo temp dir but used whatever git/beads
cwd caches earlier tests left. When an earlier test had reset git's cache and
a later one refilled it from the package directory, workspace discovery in
the test returned the checkout's .beads (from a git worktree: the MAIN
checkout's live .beads via the worktree fallback) and `bd create` tried to
open it, so it failed with "could not verify workspace identity" instead of
the expected downstream error. It passed only on stale state (a cache
pointing at a deleted temp repo).

It now resets the git and beads caches after its chdir and again in cleanup,
so it neither depends on nor leaks cwd state. With that fixed,
TestContextRoutesNameOneWorkspaceTheSameWay also resets git's cache in
cleanup. Reproduced with the context-test cleanup reset in place, running
every cmd/bd test declared up to this one (the failing go test order); now
passes there, alone, with the two context tests, and under -shuffle seeds
1-5 (other pre-existing order dependencies show up under shuffle; this test
is not among them).

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

* build(bazel): re-sync BUILD files with main

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

* test(bazel): pin BD_MIGRATION_FREEZE_FILE in test_env

The freeze-marker ancestor walk is intentionally not ceiling-bounded; an
explicit BD_MIGRATION_FREEZE_FILE replaces the walk, so a MIGRATION-FREEZE
above the output base can no longer change test results.

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

* test(scripts): give the complexity diff fixture a Go package

complexity.sh expands "${analyzer_paths[@]}" under set -u; with an empty
fixture tree that is an unbound-variable error on bash 3.2 (macOS runners).

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

---------

Co-authored-by: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-09-27 20:19:38 -07:00
Julian Knutsen
57ef364501
build(bazel): side-by-side Bazel scaffold + policy tests (#6798)
* build(bazel): add side-by-side Bazel scaffold (module + gazelle)

Add a Bzlmod Bazel build alongside the Go toolchain. `go build` and
`go test` are unchanged; nothing in CI invokes Bazel yet.

- MODULE.bazel: rules_go 0.63.0, gazelle 0.53.0, Go SDK 1.26.7 (matches
  the go.mod toolchain directive), go_deps from go.mod.
- ICU policy (engdocs/ICU-POLICY.md): a go-mysql-server gazelle_override
  selects the pure-Go regex backend and excludes regex_cgo.go, and
  .bazelrc builds with --@rules_go//go/config:tags=gms_pure_go, so no
  target depends on go-icu-regex or links libicu.
- third_party/patches: three module_override patches for dolt deps that
  ship WORKSPACE-era BUILD files, adapted from the gascity project.
- .bazelrc: prcore/ci test configs (inert for now; they match pr-core's
  test selection, not yet its environment isolation) and a generic
  remote-exec config with a bounded remote timeout. Executor endpoints and
  TLS credentials come only from a gitignored .bazelrc.local/user.bazelrc
  or a CI rc outside the workspace.
- .bazelversion pins Bazel 9.2.0; .bazelignore skips separate modules,
  non-Go trees, nested agent worktrees (.claude, .worktrees) and local
  data/output dirs (.beads, .dolt, dist, .runtime, tmp), so a primary
  checkout neither builds nor gazelle-rewrites nested worktree copies.
- Gazelle-generated BUILD.bazel files for every Go package.
- Makefile: `make bazel-sync` (gazelle + bazel mod tidy).
- .gitignore: bazel-* output symlinks and machine-local rc files.

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

* test(bazel): policy tests for the Bazel configuration

Add scripts/bazel_policy_test.go, plain Go tests that run under both
`go test ./scripts` and `bazel test //scripts:scripts_test`:

- MODULE.bazel go_sdk.download version equals the go.mod toolchain.
- ICU policy: .bazelrc sets gms_pure_go for build, the go-mysql-server
  gazelle_override excludes regex_cgo.go, and the root BUILD.bazel
  carries `# gazelle:build_tags gms_pure_go`.
- .bazelversion pins an exact Bazel release.
- .bazelrc.local and user.bazelrc are gitignored (parsed from .gitignore
  and cross-checked with git check-ignore when in a checkout).
- No remote-execution endpoints or credentials in committed bazelrc-like
  files, Markdown docs or .github/**: remote/BES/TLS flags
  (--remote_executor, --remote_cache, --bes_backend, --remote_header,
  --tls_client_certificate, ...) with a literal value, with or without a
  URL scheme, and non-loopback gRPC URLs in rc/.github files. Placeholders,
  $VARIABLES, and loopback are allowed; Markdown gRPC URLs (OTel exporter
  docs) are not flagged. Skipped outside a git checkout, e.g. in the Bazel
  sandbox.

Each check is a pure function also exercised against fixtures that break
the invariant. The files the tests read are declared as data via
//:bazel_policy_files so they resolve from runfiles under Bazel.

scripts/check-build-tags.sh now treats Bazel invocations as governed by
.bazelrc: the shell command segment that invokes Bazel (split on &&, ||,
;, |, $( and backticks) is exempt from the per-line `go` tag check, while
a bare `go` in another segment of the same line is still flagged. When
any scanned file invokes Bazel (or .bazelrc exists) .bazelrc must set
--@rules_go//go/config:tags=gms_pure_go for build.
scripts/check_build_tags_test.go covers both in a temp repository.

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

* fix(scripts): split bazel lines in pure bash so check-build-tags works with BSD sed

BSD sed (macOS) does not expand \n in s/// replacements, so the segment
split never happened and the Bazel-exemption tests failed on macos-latest.

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

* test(scripts): skip check-build-tags tests when bash lacks mapfile

macOS runners use /bin/bash 3.2, which has no mapfile; check-build-tags.sh
has always required bash >= 4, so the new tests are skipped there.

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

---------

Co-authored-by: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-09-27 03:41:02 -07:00
Julian Knutsen
24a9da6cc7
test(proxy): topology-parameterized history and remote front-door matrix (#6269)
* feat(ga-p9iuv.22): add shared tracker proxy storage seam

* fix(ga-p9iuv.22): preserve tracker storage capabilities safely

* test(ga-p9iuv.22): cover tracker adapter label semantics

* test(ga-p9iuv.22): harden tracker adapter contracts

* fix(ga-p9iuv.22): reject invalid proxied tracker stores

* feat(ga-p9iuv.1): route Linear and Jira front doors through proxy store

* test(ga-p9iuv.1): exercise tracker mutations through UOW store

* fix(ga-p9iuv.1): preserve proxied Linear endpoint config

* test(ga-p9iuv.1): cover proxied Linear endpoint and direct config

* feat(ga-p9iuv.19): add typed proxied capability matrix

* feat(proxy): enforce typed capability matrix before provider

* test(proxy): cover command capability rows and claim caps

* test(proxy): check capability rows across topologies

* fix(proxy): validate capabilities before workspace side effects

* fix(proxy): refuse ready claim max rows caps

* feat(proxy): add shared maintenance capability policy

* fix(proxy): key maintenance refusals by command path

* test(proxy): cover nested maintenance refusals

* fix(proxy): enumerate nested maintenance command paths

* fix(proxy): refine compact and nested maintenance policy

* test(proxy): prove maintenance refusals preserve files

* fix(proxy): cover admin and remote maintenance refusals

* fix(proxy): refuse doctor before store initialization

* test(proxy): define history capability command matrix

* fix(proxy): wire history capability refusals to front door

* fix(proxy): refuse top-level sync history path

* fix(proxy): preserve maintenance refusal codes

* feat(proxy): classify history as supported UOW API

* feat(proxy): classify transform capability paths

* test(proxy): harden transform capability matrix

* fix(proxy): drive transform validation from exact rows

* fix(proxy): drive transform matrix from normalized flags

* fix(proxy): bound external backend dials per attempt

* test(proxy): cover bounded blocked backend dial

* fix(proxy): make transform capability policy row-driven

* fix(proxy): make transform capability policy row-driven

* fix(proxy): classify formula swarm and merge-slot refusals

* test(proxy): enforce workflow refusal contract

* fix(proxy): classify Dolt remote history boundaries

* test(proxy): enforce history refusal contract

* test(proxy): cover canceled backend dial cleanup

* test(proxy): cover real TCP blackhole cancellation

* test(proxy): cover external transport lifecycle matrix

* test(proxy): assert stable dial failure diagnostics

* test(proxy): add outage reconnect acceptance matrix

* test(proxy): make unix outage bridge restartable

* test(proxy): bound outage subprocess cleanup

* test(proxy): cover upstream restart with retained endpoint bridge

* test(proxy): stabilize managed-local outage contract

* fix(proxy): retire managed proxy when backend exits

* test(proxy): accept managed child retirement restart

* test(proxy): cover workflow refusals at bd front door

* test(proxy): cover history VC front doors

* test(proxy): pass valid workflow refusal arguments

* test(proxy): assert text and json refusal contracts

* test(proxy): assert exact workflow refusal codes

* test(proxy): guard refusal issue-row stability

* fix(proxy): expose non-mutating capability refusals

* test(proxy): match stable refusal text

* test(proxy): compare refusal artifact snapshots

* test(proxy): assert exact refusal messages

* test(proxy): retain direct workflow behavior

* test(proxy): match nested refusal messages

* test(proxy): cover direct-only front-door refusals

* test(proxy): provide valid direct-only command args

* fix(migrate): repair missing proxied sidecar on reentry

* fix: checkpoint Dolt mode migrations for safe retry

* fix: harden migration journal topology and retries

* fix: fsync migration journal removal

* fix: fail on migration journal directory sync errors

* fix: reject external ownership in every migration phase

* fix: enforce canonical shared migration topology

* fix: enforce live migration topology

* test: add migration front-door and topology regressions

* fix: require physical Dolt roots for migration

* test: strengthen migration front-door contracts

* fix: reject missing or invalid Dolt migration roots

* fix: keep shared migration dry-runs side-effect free

* fix: require Dolt repository identity for migrations

* fix: validate Dolt repository identity metadata

* fix: require typed Dolt repo state identity

* test: expand migration front-door CRUD assertions

* test: make migration JSON dry-run front-door safe

* test: sanitize Dolt environment for migration front door

* test: use cgo binary for migration front door

* test: omit empty Dolt overrides in migration front door

* test: isolate migration front door from test mode

* test: isolate home for migration front door

* test: stop supervised Dolt before reverse migration

* fix: reject empty Dolt head refs

* test: harden migration topology invariants

* test: harden external and shared topology refusals

* test: snapshot migration refusal artifacts

* test: cover external migration refusal phases

* fix: refuse stale proxied sidecars during migration

* test: strengthen migration artifact and external front door checks

* feat: type external migration refusals

* test: assert external refusal starts no proxy

* fix: validate migration journal sidecar topology

* fix: make sidecar recovery phase aware

* fix: honor persisted shared topology during migration

* test: exercise external journal migration front door matrix

* test(tracker): add shared conformance harness

* test: harden external migration matrix fixtures

* test: preserve durable dolt gate lock in matrix

* test: preseed gate lock for refusal matrix

* test: cover malformed migration state front door

* fix: type malformed migration config refusals

* fix: type migration preflight state errors

* test: separate migration JSON stdout from warnings

* test: reach typed malformed journal refusal

* test: assert migration retry phase and idempotence

* test: cover shared migration checkpoint retries

* fix: make reverse migration idempotent without sidecar

* test: cover proxied to shared retries

* fix: derive shared topology from persisted YAML

* fix: validate shared migration no-op state

* fix: allow completed proxied shared no-op

* fix: validate forward proxied no-op sidecar

* test: reject bad already-proxied sidecars

* fix: reject stale proxy controls on no-op

* fix: fail closed on malformed migration workspace yaml

* test: pin migration yaml topology precedence

* Cover forward migration no-op ownership refusals (ga-p9iuv.26.5.2)

Agent-Signature: unknown-model/unknown-reasoning

* Strengthen migration retry sentinel coverage (ga-p9iuv.26.1)

Agent-Signature: unknown-model/unknown-reasoning

* Expand migration fault retry artifact coverage (ga-p9iuv.26.1)

Agent-Signature: unknown-model/unknown-reasoning

* Add reverse migration frontdoor fault matrix (ga-p9iuv.26.1.1)

Agent-Signature: unknown-model/unknown-reasoning

* test: cover shared migration frontdoor fault matrices

* test: strengthen direct migration matrix assertions

* test: preserve migration dependency edges

* test: assert exact migration dependency edges

* test: parse migration dependency edges from batch list

* test: fix shared migration matrix compile

* test: verify shared dependencies before shutdown

* test(proxy): cover history remote front-door topology matrix

* docs: define direct-local ownership handoff contract

* fix(ci): repair pre-review CI failures on proxy parity branch

Five PR-introduced failures across the docs, PR Core, and Proxied Dolt Cmd
lanes. Each fix is scoped to the evidenced defect.

- test/docsync: TestEveryDocsPageIsPublished flagged
  docs/architecture/ownership-handoff-contract.md as unpublished. It is an
  internal Beads/Gas City handoff contract with no Mintlify frontmatter and
  no inbound links, so move it to engdocs/design/ beside its peers rather
  than publishing it.

- cmd/bd: TestProxyWorkflowRefusalContractAndNoMutation asserted on
  commandDidWrite, a process-wide atomic latch set by 71 non-test sites and
  never reset, so it reported an earlier test's write. Baseline and restore
  it around the assertion, matching the save/reset/restore idiom already
  used in proxied_lookup_failure_test.go and readonly_policy_test.go.

- cmd/bd: the new pre-provider gate short-circuited compact.go's refusal
  with new wording, breaking TestProxiedServerCompactDolt/non_dolt_mode_-
  rejected in an unchanged test. Restore the long-standing message; the
  proxy.compact.unsupported code is unchanged.

- internal/storage/dbproxy/proxy: the unix subtests bound sockets under
  t.TempDir(), whose embedded test name overflows macOS's ~104-byte
  sun_path limit ("bind: invalid argument"). Add unixSocketPath() to place
  them in a short temp dir.

- cmd/bd: migration topology compared recorded and canonical Dolt roots
  lexically, so macOS's /var -> /private/var symlink made equivalent paths
  compare unequal. Add sameMigrationRoot(), mirroring the existing
  resolveExistingPrefix idiom in cmd/bd/doctor/git.go.

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

* fix(review): address blocker and major findings from adopt-pr review

Maintainer review fixup for the proxy parity branch, iterations 1-2.
Blockers and majors from the review synthesis and quality scorecard.

Blockers:

- cmd/bd/migrate_dolt_mode.go: resuming from migratePrepared rebuilt the
  migration plan from the current argv instead of replaying the recorded
  one. A resume that omitted or changed --idle-timeout wrote a sidecar the
  target_configured check then rejected, and because that check runs only
  after the phase advances past migratePrepared, the block never ran again
  — the workspace stayed wedged in proxied-server mode with no in-tool
  recovery. Replay j.Sidecar and warn when the supplied value is ignored.

- internal/tracker/store.go: NewStore double-wrapped already-adapted values.
  directStore embeds the storage.Storage interface, so *directStore also
  satisfies storage.Storage and was re-wrapped as
  &directStore{Storage: &directStore{...}}; the inner value can never
  satisfy storage.IssueLifecycleStore, which silently degraded
  ApplyIssueUpdate to a bare UpdateIssue — no labels, no lifecycle
  transaction. Match the tracker's own adapters by concrete type first.
  Testing value.(Store) first, as the review suggested, does not work:
  storage.Storage is a strict superset of Store, so a raw direct store
  satisfies Store too and would be returned un-adapted, relocating the same
  bug. The branch order is documented at the call site.

Majors:

- internal/tracker/store.go: directStore.ApplyIssueUpdate now calls
  syncIssueLabels, which normalizes both label sets (trim, drop empty) and
  restores the semantics the pull path had before this seam moved behind
  ApplyIssueUpdate. The un-normalized local copy churned remove+add on
  whitespace-only differences and let an empty label reach AddLabel; it is
  deleted rather than left as a second, divergent implementation.

- Both regressions were invisible to the suite. Adds
  TestNewEngineKeepsDirectStoreAdaptationIntact, TestNewStoreIsIdempotent,
  TestDirectStoreApplyIssueUpdateNormalizesLabels, and
  TestMigrateToProxiedServer_ResumeReplaysRecordedIdleTimeout (changed /
  omitted / never subtests, each also asserting the reverse-migration escape
  hatch still recovers). All four were verified to fail against the
  pre-fix production code with the predicted symptoms.

Non-gating follow-ups from the scorecard, fixed while nearby:

- cmd/bd/proxy_capability.go: treat ProxyOutcomeNA as "this command has no
  such flag" rather than a refusal, so an assert on an N/A row cannot return
  a non-nil error carrying an empty message.

- cmd/bd/errors.go: emit the rule's real Mutates value in the JSON refusal
  envelope instead of a hardcoded false.

- cmd/bd/main.go: the doctor pre-provider check returned unconditionally,
  so a nil result (every doctor subcommand) skipped the legacy-store guard
  and autocommit-mode resolution that other skipsStoreInit commands run.
  Return only on a real refusal.

- internal/tracker/engine.go: type NewEngine's store parameter as Store so
  the seam names its contract, and drop the now-dead applyPullIssueUpdate.

- CHANGELOG.md: record the proxied `bd ready --claim` row-cap refusal, which
  was a behavior change shipped without a release note.

Iteration 2 -- gating major (uowStore/directStore external_ref divergence):

- internal/tracker/uow_store.go: GetIssueByExternalRef resolved through a
  single merged search over both storage planes, which has no plane
  preference: it is a UNION ALL ordered by content and terminating in
  `id ASC`, so one external_ref present on both planes resolved to whichever
  row's id sorted first. The direct backend is explicitly issues-first --
  issueops.GetIssueByExternalRefInTx queries `issues` and falls through to
  `wisps` only on sql.ErrNoRows, and says why ("so that pushed ephemeral
  beads are found during pull dedup"). The consumer is the pull dedup, which
  updates whatever row comes back, so the divergence was a silent write to
  the wrong local bead under --proxied-server only. Query the issues plane
  first via SkipWisps, then fall back.

  The fallback is the merged search rather than the review's literal
  Ephemeral=true: that filter contributes an `ephemeral = 1` predicate the
  direct backend's `SELECT id FROM wisps WHERE external_ref = ?` does not
  have, and wisp-plane rows legitimately carry ephemeral=0 (NoHistory beads;
  see types.IssueFilter.EphemeralTier). Taking it literally would have traded
  one divergence for a narrower one. Verified: implementing the prescription
  fails the ephemeral_flag_clear subtest below.

- internal/tracker/uow_store_engine_test.go: the engine fake now models plane
  routing (SkipWisps / Ephemeral / merged) instead of one flat map, so the
  contract is expressible at all. Adds
  TestUOWStoreGetIssueByExternalRefPrefersIssuePlane, whose wisp id sorts
  first so "first merged hit" fails it, and
  TestUOWStoreGetIssueByExternalRefFallsBackToWispPlane over both ephemeral
  values. Verified to fail against the pre-fix uow_store.go.

- internal/tracker/conformance: the shared suite gains a Wisps plane and
  external_ref_resolution_prefers_issue_plane, so this is a contract both
  backends are held to rather than one adapter's unit test.

Iteration 2 -- non-gating follow-ups from the scorecard:

- cmd/bd/migrate_dolt_mode.go: scope the migratePrepared sidecar-equivalence
  check in runMigrateFromProxiedServer to reverse journals. A forward journal
  at that phase records the sidecar it is about to write, so a crash in the
  pre-write window leaves none on disk -- the correct state -- and the
  unscoped check refused the documented escape hatch by naming a missing
  file, stranding the workspace. Tested against TargetMode's forward value so
  the guard stays live for both reverse targets, "server" and
  "shared-server". Adds
  TestMigrateFromProxiedServer_ForwardJournalAtPreparedIsNotSidecarRefused,
  verified to fail against the unscoped guard.

- cmd/bd/linear.go: buildLinearClientAPIOnly returned the OAuth client inline
  and never reached the WithEndpoint block, so a configured
  linear.api_endpoint was honored for an API key and ignored for OAuth. Hoist
  the endpoint application after the branch, as Tracker.Init does, and add
  the OAuth mirror of the existing endpoint test.

- cmd/bd/ready_max_rows_proxied_test.go: pin the proxied --max-rows refusal
  on `bd ready --claim`. It lives in RunE above the dispatch and nothing
  below it can enforce a cap, but the existing coverage all sits below it.
  Covers both cap sources (--max-rows and BEADS_MAX_ROWS) and the negative
  case that the refusal is conditioned on a live cap, not on --claim.

- engdocs/design/ownership-handoff-contract.md: trim the trailing blank line
  at EOF flagged by `git diff --check`.

Iteration 3 -- non-gating residual on the iteration-2 fix:

- internal/tracker/uow_store.go: the issues-first fix above split one logical
  lookup across two read transactions. uow.RunTxRead opens a fresh unit of
  work per call, so calling s.SearchIssues twice left the wisp fallback's
  premise -- "the issues plane is already known empty" -- without a shared
  snapshot: a concurrent same-ref insert into the issues plane landing between
  the two reads could let the merged fallback return the wisp, re-creating the
  wrong-row write that ordering exists to prevent. The consumer is the pull
  dedup loop, so it runs per imported issue. Both plane reads now share a
  single RunTxRead, which is also the shape the direct backend uses (both
  planes inside one withReadTx). Plane ordering is unchanged.

- internal/tracker/uow_store_engine_test.go: the engine fake counts the units
  of work it hands out, and
  TestUOWStoreGetIssueByExternalRefUsesOneReadTransaction pins that count at 1
  across the two paths that actually perform both reads -- the wisp fallback
  and the miss. An issues-plane hit short-circuits after one read and would
  pass either way, so it is not a case. Verified to fail against the
  two-transaction version with "opened 2, want 1".

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

---------

Co-authored-by: Claude Opus 5 <noreply@anthropic.com>
2026-09-05 08:25:49 -07:00
ecuthiell
594c464cc2
fix(windows): detect exited processes in liveness helpers (#4980) (#4981)
OpenProcess success does not prove a process is running: Windows keeps a terminated process object openable while any handle remains. Probe with SYNCHRONIZE and a zero-timeout wait instead.

This corrects the production Dolt-server probe and the matching existing Linear helper. The Linear helper has no production caller today; its change is latent correctness and regression coverage, not a current Linear runtime fix.

The wait-based design and regression strategy build on Marco Del Pin's contributor work in #4808.

Co-authored-by: Marco Del Pin <marco.delpin@gmail.com>

Agent-Signature: codex-tui-gpt-5.6-sol-ultra on behalf of Ewen Cuthiell
2026-07-23 18:24:49 -07:00
ecuthiell
db0787bb15
fix(linear): correlate Windows sync lock diagnostics (#4990)
Windows LockFileEx prevents contenders from reading inline owner metadata from the fully locked primary guard. Keep that guard as the sole lock authority and preserve the existing Unix path unchanged.

On Windows, publish a strict fixed-size owner record only after taking a random generation-specific byte lease on a stable sidecar handle. Contenders require an exact live process incarnation, shared lease probes, and a stable reread and reprobe before reporting details. Missing, stale, torn, mixed-version, or otherwise uncertain metadata remains generic and never authorizes reclaim.

Invalidate and release diagnostics before the primary guard, while making every sidecar failure best-effort. Cover shared-probe concurrency, stale-live and process-reuse defenses, crash phases, failure injection, open readers, and repeated handoffs.

Agent-Signature: codex-tui-gpt-5.6-sol-ultra on behalf of Ewen Cuthiell
2026-07-23 18:09:33 -07:00
Kevin Glynn
50b0617405
fix(linear): arm rate-limit breaker after successful calls (#4778)
* fix(linear): arm rate-limit breaker after successful calls

Co-authored-by: Medhaug <Medhaug@users.noreply.github.com>

* fix(linear): expire rate limit breaker after reset

Agent-Signature: codex-gpt-5.6-sol-medium on behalf of matt wilkie

* fix(linear): parse reset header as epoch milliseconds

Agent-Signature: codex-gpt-5.6-sol-medium on behalf of matt wilkie

* fix(linear): require valid reset to arm breaker

Agent-Signature: codex-gpt-5.6-sol-medium on behalf of matt wilkie

* fix(linear): bound rate limit reset horizon

Agent-Signature: codex-gpt-5.6-sol-medium on behalf of matt wilkie

* test(linear): send valid reset header so breaker arms in reconcile mock

The breaker arming contract now requires a valid future
X-RateLimit-Requests-Reset alongside low remaining quota (48b0c6725).
The parent-reconcile mock only sent the remaining header, so the
breaker never armed and TestReconcileParents_AbortsOnRateLimit got no
abort error.

Co-authored-by: Cursor <cursoragent@cursor.com>

---------

Co-authored-by: Cursor Agent <cursoragent@cursor.com>
Co-authored-by: Medhaug <Medhaug@users.noreply.github.com>
Co-authored-by: matt wilkie <maphew@gmail.com>
2026-07-14 13:13:52 -07:00
Kevin Glynn
3f91a67cb9
fix(linear): avoid double-format skip mismatch in batch push (#4779)
* fix(linear): avoid double-format skip mismatch in batch push

Co-authored-by: Kev Glynn <kev-pryon@users.noreply.github.com>

* fix(test): add TeamLabels mock handler for BatchPush preformat test

The BatchPush path now builds a label cache for each team (from the
label-push feature on main), so the mock server must handle the
TeamLabels GraphQL query. Without it the test fails on empty JSON parse.

Co-authored-by: Cursor <cursoragent@cursor.com>

---------

Co-authored-by: Cursor Agent <cursoragent@cursor.com>
Co-authored-by: Kev Glynn <kev-pryon@users.noreply.github.com>
Co-authored-by: matt wilkie <maphew@gmail.com>
2026-07-14 12:52:40 -07:00
Kevin Glynn
7fbbf3caff
fix(linear): use OAuth auth header for idempotent create (#4777)
Co-authored-by: Cursor Agent <cursoragent@cursor.com>
Co-authored-by: Kev Glynn <kev-pryon@users.noreply.github.com>
2026-07-14 10:19:35 -07:00
Kevin Glynn
922f9089e3
fix(linear): push bead labels to Linear on sync --push (GH#3753) (#3776)
Push bead labels (issue_type-derived + custom labels) to Linear on `bd linear sync --push`, closing #3753.

Why: completes the #3772 pair - #3772 gave push-direction state mapping its outbound overrides, this PR makes labels flow beads -> Linear (they previously only flowed Linear -> beads, so pushed issues arrived label-less). Adds paginated `GetTeamLabels`, a per-team `LabelCache`, inversion of `label_type_map` for the push direction, label-aware `PushFieldsEqual` skip logic, and warnings for labels missing on the Linear team. Author rebased onto main same-day when asked; rebase verified clean against the pre-rebase diff (changed lines byte-identical, both #3772 and #3776 test sets preserved in mapping_test.go).

Local verification: gofmt clean, `CGO_ENABLED=0 go build -tags gms_pure_go ./...` ok, `go test ./internal/linear/...` ok, `go vet` clean. Failing PR checks (errcheck in formula_schema.go, testing.Short policy, unclaim/update claim tests) are base-branch breakage present on main at rebase time, since fixed by #4623 - unrelated to this change.

Co-Authored-By: kev <kglynn@pryoninc.com>
2026-07-07 06:27:16 -07:00
Afik
98f3cb43a5
fix(linear): wire parent-child relationships to Linear's parent field (#3930)
* fix(linear): wire parent-child relationships to Linear's parent field

bd-ena: bd linear sync wasn't pushing parent-child relationships to
Linear, leaving epic trees flat (every issue parent=null on the Linear
side). Concretely on the houmanoids_www rig: a 73-issue tree push
created HOU-151..HOU-209 all with parent=null, even though the local
beads structure was correctly parent-child-linked.

Root cause: Tracker.CreateIssue and UpdateIssue never set parentId; the
GraphQL client's buildIssueCreateInput didn't accept it; the field
mapper's IssueToTracker dropped parent entirely.

Fix: post-sync reconciliation pass.

After engine.Sync completes (push, non-dry-run, success, full scope):
1. Walk local store for beads with Linear external_refs and a
   parent-child dependency to a parent that also has an external_ref.
2. For each (child, parent) pair, fetch both from Linear (cached by
   identifier so repeated parents cost one fetch).
3. If child's remote parent doesn't match the desired parent UUID,
   issue IssueUpdate{parentId} on the child's host team-client.

Idempotent: re-running on a healthy tree produces only Skipped++ events,
no API mutations. This means a single run of `bd linear sync` will both:
  (a) wire up new trees that were just pushed in the same sync, AND
  (b) repair pre-existing orphan trees from before this fix landed
      (HOU-164..209 on houmanoids will get parents on next sync).

Multi-team correctness: fetchIssueAcrossTeams returns the host client
alongside the issue, and the update reuses that client. Avoids a
silent fall-through to the primary team's client (clientForExternalID's
non-rate-limit error path falls back to primary, which would silently
update the wrong team's issue in a multi-team rig).

Rate-limit safety: the pass aborts immediately when Linear's circuit
breaker trips. Already-applied updates are reported in the partial
"Reconciled N parent links" line before the warning surfaces.

Scope safety: skipped on scoped syncs (--parent / --type / --exclude-
type / --issue-id) since the reconciler walks the full local tree, not
just the in-scope subset. A subsequent unscoped sync picks up the work.

Tests (internal/linear/parent_reconcile_test.go, 9 cases):
- HappyPath, IdempotentSkip, RewiresWrongParent
- FetchCaching (parent-shared-by-N children fetched once)
- MissingChildOrParent (NotFound, no errors)
- EmptyLinks, BlankIdentifiersSkipped (defensive)
- MultiTeam (cross-team probing + correct host-client routing)
- AbortsOnRateLimit (circuit breaker stops the pass cleanly)

Codex-Reviewed-By: codex-rescue (2 rounds; second round caught the
multi-team silent-fallback hazard and the scoped-sync interaction)
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* feat(linear): dry-run preview for parent reconciler

bd-5zh: the bd-ena parent-child reconciler had no dry-run mode — every
call mutated Linear via UpdateIssue, so callers were forced to gate on
`!dryRun` at the call site. That defeats the point of
`bd linear sync --dry-run` as a pre-flight: the orphan-repair scope
(HOU-164..209 on the houmanoids_www rig) was invisible until you
committed to a wet sync.

API change: `ReconcileParents(ctx, links)` → `ReconcileParents(ctx,
links, dryRun bool)`. ParentReconcileStats gains:
  - WouldUpdate int     — count of mutations that WOULD fire (dry-run);
                          zero in wet-run
  - Mutations []ParentLink — (child, parent) pairs that were applied
                          (wet-run, only after IssueUpdate success) or
                          that would apply (dry-run). Lets callers print
                          per-link detail without re-deriving.

When dryRun is true the per-link logic still runs through fetch,
fetch-caching, and idempotency-check — only the API mutation is skipped.
The preview is therefore trustworthy: same NotFound/Skipped behavior,
same Mutations set as wet-run for the same input (locked by
TestReconcileParents_DryRunMatchesWetRunMutationSet).

cmd/bd/linear.go:
- Drops the `!dryRun` gate; reconcile pass now runs in dry-run too.
- `reconcileLinearParents` takes new dryRun + jsonOutput params.
- In dry-run: prints `[dry-run] Would reconcile N parent links` summary
  + one `[dry-run] Would set parent of CHILD → PARENT` per Mutations
  entry. Suppressed when --json is set so the JSON envelope stays clean.
- `effectivePush := push || (!push && !pull)` mirrors engine.Sync's
  bidirectional default so `bd linear sync --dry-run` (no direction
  flag) still previews the reconcile.

Wet-run contract tightened (codex round 1 catch): Mutations is now
appended only AFTER the UpdateIssue API call succeeds, so the list
reflects state actually propagated to Linear — not attempted writes
that failed. Locked by TestReconcileParents_WetRunFailureDoesNotRecordMutation.

Scoped-sync skip preserved (codex confirmed): a scoped sync that
silently expanded its surface in dry-run mode would surprise the user.

Tests: 9 existing tests updated to pass `false` for dryRun (no behavior
change). 5 new tests:
- DryRunNoMutations — mixed already-correct + needs-parent; verifies
  WouldUpdate, Skipped, Mutations contents + ordering, zero mock.updates.
- DryRunIdempotentSkipUnchanged — all correct → zero WouldUpdate.
- DryRunMissingTargetsNotFound — unresolvable identifiers surface in
  NotFound during dry-run too.
- DryRunMatchesWetRunMutationSet — symmetry property: dry-run and
  wet-run produce identical Mutations sets for identical input.
- WetRunFailureDoesNotRecordMutation — issueUpdate returning
  success=false produces Errors entry, NOT a Mutations entry.

Known gap: reconcile preview lines aren't surfaced in --json output
(would require Linear-specific field on shared SyncResult; deferred).
Errors still flow through SyncResult.Warnings either way.

Codex-Reviewed-By: codex-rescue (2 rounds; caught Mutations-recorded-
before-success contract bug, --json output mixing, and the
bidirectional-default gate hole)
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* fix(linear): persistent linear.exclude_types no longer disables parent reconcile

bd-9w3: on the houmanoids_www rig the post-sync parent reconciler was
silently skipped on every full sync — HOU-164..209 stayed orphaned
despite the surrounding sync running clean. Traced via debug prints:
syncIsScoped(&opts) returned true because opts.ExcludeTypes was non-
empty (the rig has persistent `linear.exclude_types = "molecule,event"`,
merged into opts by the CLI). The gate then skipped reconcile.

Fix: drop ExcludeTypes from syncIsScoped. The reconcile pass only
mutates the parent FIELD on the child issue — it never touches the
parent issue itself — so excluding "molecule" or "event" types from
push doesn't conflict with wiring up parent-child for the remaining
types. ExcludeTypes is primarily a persistent-config knob, not a
temporary user scoping intent for THIS invocation.

Kept as scoping signals (all explicit-CLI-only):
  - ParentID  (--parent)
  - IssueIDs  (--issues / --issue-id)
  - TypeFilter (--type)

Tests: cmd/bd/sync_is_scoped_test.go covers 8 sub-cases including the
regression "exclude types only (persistent config)" → false, plus the
combined cases (exclude_types + parent_id → still scoped; exclude_types
+ type_filter → still scoped).

Verified on the houmanoids_www rig (via the integration sibling
binary, since the upstream binary's schema is incompatible with the
rig DB):
  bd linear sync --pull --push --dry-run
  → "[dry-run] Would reconcile 62 Linear parent links"
  → HOU-164 → HOU-159, HOU-165 → HOU-205, ... Phase epics → root epic.

Mayor's bd-9w3 nudge raised an "epic-aware silent skip" hypothesis from
the bd-2og epics-as-projects design — confirmed NOT present on this
code path. The reconciler treats all bead types (including epics)
identically; the 62 planned mutations include Phase-epic → root-epic
links (HOU-202 → HOU-159, HOU-205 → HOU-159).

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

---------

Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
2026-07-06 22:16:07 -07:00
Kevin Glynn
0a056e69d5
fix(linear): state_map validation for deferred, pinned, hooked, custom (GH#3754) (#3772) 2026-07-06 22:11:02 -07:00
Alex
017880cb61
feat(linear): add linear.outbound_state_map for push disambiguation (#4119)
`bd linear sync --push` errors with "type fallback is ambiguous" when a
beads status maps to a Linear state type that has multiple workflow
states. Linear's default workspace, for example, has both "In Progress"
and "In Review" as `started`-type states, so any push that needs to set
a beads `in_progress` issue to a Linear state fails with no escape
hatch.

Add a new optional config:

  linear.outbound_state_map.<beads_status> = "<Linear state name>"

When set, ResolveStateIDForBeadsStatus looks up the named Linear state
by case-insensitive name match and short-circuits the existing
name-then-type logic. Falls back to today's behavior when unset, so
this is opt-in and backwards-compatible. The existing ambiguity error
now points users at the new config key.

Tests cover the disambiguation, an unknown-state-name error path, the
precedence over explicit name matches, the case/whitespace
insensitivity, the LoadMappingConfig parse path, and the augmented
ambiguity error message.

Co-authored-by: a3ackerman <user.email=28374790+A3Ackerman@users.noreply.github.com>
Co-authored-by: Claude Opus 4.7 <noreply@anthropic.com>
2026-07-06 22:08:06 -07:00
Kevin Glynn
f172b97ada
fix(linear): correct issueBatchCreate GraphQL variable type (#3703)
The BatchCreateIssues mutation declared $input as [IssueCreateInput!]!
and passed the issue array directly. Linear's API expects
IssueBatchCreateInput! — a wrapper object with an "issues" field.

This mismatch caused all batch creates to silently fail with no issues
created. The fix corrects both the type declaration and the variable
structure. Tests updated to validate the correct payload shape.
2026-05-06 12:14:15 -07:00
Kevin Glynn
e643e94f17
fix(linear): add done/deferred/pinned/hooked aliases to ParseBeadsStatus (#3718)
ParseBeadsStatus silently mapped unrecognized status strings to
StatusOpen via the default case. This caused "done" beads to be
treated as "open" during push, and "deferred" beads to collide
with "open" in state_map resolution.

Add all valid beads statuses as recognized cases so the function
only falls back to StatusOpen for genuinely unknown strings.
2026-05-05 14:42:59 -07:00
Jozef Izso
42064c46fe
Sync Linear milestones as local epics (#3528) 2026-05-05 07:45:30 -07:00
Kevin Glynn
ac15e099e3
feat(linear): adopt issueBatchCreate/issueBatchUpdate for 50x efficiency (#3654)
* feat(linear): adopt issueBatchCreate/issueBatchUpdate for 50x efficiency

Implements tracker.BatchPushTracker interface on linear.Tracker.
Adds BatchCreateIssues and BatchUpdateIssues methods that chunk
inputs into groups of 50 (Linear's per-call limit). Graceful
fallback to per-issue mutations on batch failure.

* fix(linear): address BatchPush correctness blockers from maphew review

Three correctness issues flagged in PR #3654 review:

1. Skip semantics: BatchPush now fetches each existing issue before
   updating and compares with PushFieldsEqual (title, description,
   priority, status). Unchanged issues are added to result.Skipped
   instead of being re-pushed unconditionally. forceIDs bypasses the
   check, matching the single-issue path in engine.go:doPush.

2. Batch-create result mapping: results are now matched by title rather
   than array index. Linear's issueBatchCreate API does not guarantee
   response order matches input order; index-based mapping silently
   associated wrong ExternalRefs with issues. Unmatched inputs are
   recorded in result.Errors with the title for debugging.

3. Multi-team state cache: build a StateCache per configured team at the
   start of BatchPush. Updates to issues belonging to non-primary teams
   resolve workflow state IDs against that team's cache, not the primary
   team's. The primary cache is used only for creates (which always target
   the primary team).

Add four regression tests covering: unchanged-issue skip, forceIDs bypass,
title-based result mapping with reversed API response, and per-team state ID
selection in a two-team setup.

* fix(linear): prevent duplicate issues from batch-create correctness gaps

Two correctness fixes addressing maphew's re-review blockers on PR #3654:

1. Title-based result correlation is unsafe for duplicate titles.
   BatchPush now detects duplicate titles before batching. Issues with
   duplicate titles are routed through single-create with idempotency
   markers (CreateIssueIdempotent) instead of the batch mutation where
   title-based correlation would silently lose one duplicate.

2. Full-chunk fallback after ambiguous batch failure risks duplicates.
   BatchCreateIssues no longer falls back to creating the entire chunk
   when the batch mutation returns success=false or an API error. Instead
   it searches for each issue's idempotency marker to discover which were
   partially created, returns only confirmed issues, and errors on the
   rest. If the recovery search itself fails, the error propagates rather
   than risking duplicates.

Supporting infrastructure ported from feat/linear-idempotency-markers:
- idempotency.go: GenerateIdempotencyMarker, AppendIdempotencyMarker
- FindIssueByDescriptionContains, CreateIssueIdempotent on Client

* fix(linear): gofmt client.go and tracker_test.go

Fix Check formatting CI failure — two files had formatting drift
from the merge conflict resolution.
2026-05-03 16:28:13 -07:00
matt wilkie
890950f388
Merge pull request #3661 from kevglynn/pr3-oauth-client-credentials
feat(linear): OAuth client-credentials support for service identity
2026-05-02 19:31:14 -07:00
maphew
425ae20683 Merge main into OAuth client credentials branch 2026-05-02 19:14:05 -07:00
maphew
f4a1a211df Merge main into staleness signal branch 2026-05-02 19:09:01 -07:00
matt wilkie
9c41669cf4
Merge pull request #3657 from kevglynn/feat/linear-sync-concurrency-lock
feat(linear): add per-workspace concurrency lock on sync
2026-05-02 19:05:23 -07:00
matt wilkie
a9e437a0a8
Merge pull request #3655 from kevglynn/feat/linear-retry-after-adaptive-backoff
feat(linear): parse Retry-After headers and add rate-limit circuit breaker
2026-05-02 19:05:11 -07:00
maphew
f118303741 Merge main into OAuth client credentials branch 2026-05-02 18:40:54 -07:00
maphew
d33687481e fix(linear): clean staleness lint 2026-05-02 18:38:36 -07:00
maphew
cb1a0700b0 fix(linear): clean sync lock lint 2026-05-02 18:38:36 -07:00
matt wilkie
8cc3fea9a3
Merge pull request #3656 from kevglynn/feat/linear-idempotency-markers
feat(linear): add idempotency markers to prevent duplicate issue creation
2026-05-02 17:41:14 -07:00
kev
6584ff8f8f feat(linear): add ambient staleness signal for auto-fresh data
Add staleness detection so agents and devs automatically get fresh
Linear data without retry infrastructure.

- New staleness library (internal/linear/staleness.go): WriteLastPull,
  ReadLastPull, IsPullStale, IsWithinDebounce, GetStalenessInfo
- --pull-if-stale flag on bd linear sync with configurable --threshold
  (default 20m) and 5-minute debounce to prevent agent loops
- bd prime auto-pulls when stale and LINEAR_API_KEY is set
- Per-session stderr warning on any bd command when data is stale
- 14 new tests covering all staleness functions

Design validated by three adversarial reviewers (architecture,
performance, agent-native). Morning storm (50 devs) = 1% of rate
limits. Scales to 500 devs safely.

Refs: PLAN.md d16, btl-seo
2026-05-02 20:08:33 -04:00
kev
46584d8222 fix(linear): address maintainer feedback on OAuth client-credentials PR
OAuth-only sync path (no LINEAR_API_KEY required):
- Tracker.Init() now checks for OAuth credentials first
  (LINEAR_OAUTH_CLIENT_ID + LINEAR_OAUTH_CLIENT_SECRET), constructs
  NewOAuthClient per team when present, and only falls back to API key
  when OAuth is absent. Missing both is a clear error naming both options.

Lint fixes:
- oauth.go: add //nolint:gosec on DefaultOAuthTokenURL (G101 false
  positive — URL path component, not a credential)
- oauth.go: change defer resp.Body.Close() to
  defer func() { _ = resp.Body.Close() }() to satisfy errcheck
- .golangci.yml: add unparam exclusion for getLinearConfig (ctx param
  kept for context propagation)

Docs/code precedence alignment:
- getLinearConfig: env vars now take precedence over config.yaml for
  yaml-only keys (was reversed). Matches documented precedence:
  OAuth > LINEAR_API_KEY > config file.

Tests:
- TestTrackerInitOAuthOnly: validates OAuth client construction without
  API key
- TestTrackerInitNoAuthFails: validates error message when no auth
  configured
2026-05-02 19:04:20 -04:00
kev
3e804cd39f fix(linear): address maintainer feedback on PR #3655
- Format types.go (struct field alignment was off by one space)
- parseRetryAfter: use http.ParseTime for HTTP-date form (RFC 1123 /
  RFC 850 / ANSI C) instead of time.Parse(time.RFC1123) — the latter
  requires an exact timezone abbreviation while http.ParseTime accepts
  the canonical GMT form mandated by RFC 9110 §10.2.3
- Add MaxRetryAfterDelay (300s) cap on server-provided Retry-After
  delays; log a warning to stderr and clamp when the hint exceeds the cap
- Wire linear.rate_limit_floor / LINEAR_RATE_LIMIT_FLOOR through both
  Tracker.Init() and getLinearClient() so the config key is functional
  via `bd config set linear.rate_limit_floor <n>` and the env var
- ErrRateLimitExhausted now implements RateLimitExhausted() bool;
  engine.go uses an interface check (no import cycle) to abort the
  push loop immediately on quota exhaustion instead of cascading the
  error across every remaining issue
- Tests: extend TestParseRetryAfter with HTTP-date future/past cases;
  add TestExecute_RetryAfterCapApplied to confirm the cap path is taken
2026-05-02 19:00:25 -04:00
kev
b8e7562f0f fix(linear): address maintainer blockers on idempotency PR
Fix 1 (double description formatting): Tracker.CreateIssue was calling
BuildLinearDescription(issue) to format the description, but the sync
engine's FormatDescription hook already calls BuildLinearDescription
before invoking CreateIssue. For issues with AcceptanceCriteria/Design/
Notes, this caused those sections to be appended twice in the Linear
description. Fix: use issue.Description directly in CreateIssue, trusting
the caller to have pre-formatted it.

Fix 2 (retry race in CreateIssueIdempotent): The previous implementation
called CreateIssue (which goes through Execute's retry loop) after the
initial marker search. If issueCreate reached Linear but the HTTP response
was lost, Execute could retry the mutation and create a duplicate issue
with the same idempotency marker. Fix: add createIssueSingleAttempt that
runs the mutation exactly once. After any failure, re-search for the
marker before returning the error so callers can safely retry
CreateIssueIdempotent without creating duplicates.

Also documents the concurrent multi-source limitation (Linear provides no
server-side uniqueness enforcement; the dedup window is bounded by search
index propagation).

Adds regression tests:
- TestCreateIssueNoDoubleFormatDescription: verifies AC/Design sections
  appear exactly once in the description sent to Linear
- TestCreateIssueIdempotentRecoverAfterAmbiguousFailure: verifies that an
  ambiguous create failure (5xx response) followed by a recovery search
  returns the already-created issue with deduped=true
2026-05-02 18:59:33 -04:00
kev
175bc23d1f fix(linear): keep lock file stable across Release cycles
Removing the lock file after unlocking creates a lifecycle race: a blocked
waiter acquires the old inode (between flock release and os.Remove), then a
third process creates a new file at the same path and locks it — both
processes believe they hold the lock.

Fix: never call os.Remove in Release(). Truncate diagnostic metadata while
still holding the flock, then release. The stable path is reused by
subsequent AcquireSyncLock calls via O_CREATE|O_RDWR.

Also:
- Handle writeLockInfo's Truncate error (was silently discarded with _ =)
- Add #nosec G304 to readLockInfo (path is program-constructed, not user input)
- Update test: assert lock file persists and is empty after Release, not removed
2026-05-02 18:55:08 -04:00
Kevin Glynn
06d385edf9
feat(linear): add type mappings for decision, spike, story, milestone (#3651)
Fix-merged for release prep: preserved the contributor Linear type mappings and added exact-only matching to avoid story false positives such as history. Auto-merge after CI.
2026-05-02 14:24:27 -07:00
kev
097ed1cf16 feat(linear): add OAuth client-credentials support
Add OAuthTokenManager for machine-to-machine authentication using
Linear's client_credentials grant. This enables CI workers to use a
service identity (actor=application) instead of personal API keys.

Key changes:
- New OAuthTokenManager with lazy acquisition, caching, thread-safe
  refresh (5-min buffer before expiry), and Invalidate() for 401 retry
- AuthMode enum (APIKey vs OAuth) on Client with appropriate header
  format: API keys use "Authorization: <key>", OAuth uses "Bearer"
- NewOAuthClient() constructor and WithOAuth() option
- 401 auto-retry: invalidate token and re-acquire on first 401
- Auth precedence: LINEAR_OAUTH_CLIENT_ID/SECRET env vars >
  LINEAR_API_KEY env var > bd config
- Mark oauth_client_secret as secret key (uses IsSecretKey from PR-1)
- 12 new tests covering acquisition, caching, refresh, invalidation,
  error handling, thread safety, and header format

Validated against Linear sandbox: client_credentials grant works with
scope=read,write, actor=application gives bot identity, 30-day TTL.

Refs: gastownhall/beads integration charter, PLAN.md §6 PR-3
2026-05-02 09:35:08 -04:00
kev
989d0f9496 feat(linear): add per-workspace concurrency lock on sync
Acquires .beads/.linear-sync.lock at start of bd linear sync to
serialize concurrent invocations. Stale lock detection via PID
check. Clean release on SIGTERM via defer. Prevents duplicate
creates and conflict thrash from overlapping sync runs.
2026-05-02 01:02:55 -04:00
kev
0ec4a99ea0 feat(linear): add idempotency markers to prevent duplicate issue creation
Embeds <!-- bd-idempotency: hash --> in Linear descriptions on create.
Pre-create dedup query uses description contains filter (validated
against Linear API). Hash uses immutable fields only (beadID +
creatorEmail + createdAtNano). Prevents duplicates under sync
interruption or multi-source create races.
2026-05-02 01:00:09 -04:00
kev
a845bc4eba feat(linear): parse Retry-After headers and add rate-limit circuit breaker
Server-hint-aware backoff: prefer Retry-After delay over computed
exponential backoff when present. Circuit breaker pauses sync when
remaining quota drops below linear.rate_limit_floor (default 100).
Addresses thundering-herd retry amplification pattern (cf. #3623).
2026-05-02 00:42:06 -04:00
matt wilkie
3e56f0b214
Document Linear external_ref pre-linking (#3517)
* Document Linear external ref prelinking (bd-ly3)
* Fix Linear sync dependency graph handling
* Fix init remote clone routing
* Fix stale gate help text
* Fix init remote cherry-pick integration
* Fix init remote flag handling
* Fix Linear prelink hydration blockers
* Fix Linear relation dependency gating
* Fix ready list parent filtering
* Deduplicate dry-run dependency previews by stored identity
2026-04-27 06:05:30 -07:00
matt wilkie
f7269b6820 Add Linear state_map dotted key regressions (bd-cba) 2026-04-25 18:05:44 -07:00
matt wilkie
c446a2ef09
fix(linear): harden push against data clobbering (#3328)
Closes #3289, #3309, #3252, #3253 — hardens Linear push: requires explicit linear.state_map.* config, rejects ambiguous state resolution, narrows push dedup to pushable fields, blocks unscoped project-filtered push from creating unlinked beads, and adds regression test for the orphan-ownership rule (parent-filtered push must not update external issues Beads hasn't claimed via external_ref).
2026-04-18 08:36:13 -07:00
natorious
0271720965
fix: linear tracker reads yaml-only config keys from config.yaml (#3315)
The Tracker.getConfig() method only checked the Dolt database and
environment variables. Since `bd config set linear.api_key` writes
to config.yaml (yaml-only key), `bd linear sync --pull` could never
find the API key. Mirror the check from cmd/bd/linear.go:getLinearConfig()
by calling config.IsYamlOnlyKey() and config.GetString() first.

Co-authored-by: mayor <root@vmi3233510.contaboserver.net>
Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
2026-04-17 15:10:33 -07:00
Harry
2cd88e9426 fix: address PR review feedback
- Jira: reset body reader at top of retry loop (not just in retriable
  branch) so POST/PUT retries after network errors don't send empty bodies
- GitLab: add useServerDelay pattern matching other clients; skip jitter
  for server-mandated Retry-After delays
- Sanitize: replace custom decodeRune with stdlib utf8.DecodeRuneInString
- Ready --explain: log warnings instead of silently swallowing errors from
  GetDependencyCounts, GetDependencyRecordsForIssues, DetectCycles,
  GetIssuesByIDs
- Linear: fix pagination off-by-one; check page limit before processing
  instead of after, preventing MaxPages+1 fetches
2026-03-30 09:15:55 -07:00
Harry
860ef5969b lint: suppress gosec G404 for retry jitter (math/rand is fine for backoff)
Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
2026-03-30 09:15:53 -07:00
Harry
733b8fab89 Sanitize external tracker content for terminal display and add response size limits
- Add ui.SanitizeForTerminal() to strip ANSI escape sequences, OSC sequences,
  and C0/C1 control characters from external content before terminal display.
  Preserves printable UTF-8, newlines, and tabs.
- Apply sanitization in tracker engine dry-run output (3 call sites)
- Add MaxResponseSize (50MB) and io.LimitReader to Linear client to prevent
  OOM from malformed API responses (was the only tracker without this guard)
- Add comprehensive test suite for sanitization (17 test cases including
  ANSI injection, screen clearing, OSC title change, control characters)

Fixes: bd-u9u

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
2026-03-30 09:12:26 -07:00
Harry
c5e033f93e Add pagination guards to Linear and context checks to Jira client
- Linear FetchIssues/FetchIssuesSince: add MaxPages=1000 guard to prevent
  infinite loops from malformed API responses with hasNextPage=true
- Linear: add ctx.Done() checks at start of each pagination iteration
- Jira SearchIssues: add ctx.Done() check at start of each pagination iteration
- Add MaxPages constant to internal/linear/types.go

Fixes: bd-6fy

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
2026-03-30 09:11:20 -07:00
Harry
00b78da749 Add retry logic to Jira client and jitter to all tracker HTTP clients
- Add retry with exponential backoff to Jira doRequest (was single-attempt)
- Add MaxRetries, RetryDelay, MaxResponseSize constants to jira/types.go
- Add response body size limit via io.LimitReader to Jira client
- Handle permanent errors (400/401/403/404) without retry
- Parse Retry-After header for rate-limited responses
- Add jitter (0-50% of delay) to backoff in all 5 tracker clients:
  GitHub, GitLab, Linear, ADO, and Jira
- Guard rand.Int64N against zero delay to prevent panics
- Add retry tests: 429, 503, no-retry-on-400, max-retries-exceeded

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
2026-03-30 09:11:19 -07:00
Harry
3ae2ef3a5a feat: multi-project/team support for Linear, Jira, and ADO
Add support for syncing issues across multiple projects/teams in all
three tracker integrations, with shared infrastructure to avoid
duplicating logic.

Shared infrastructure (internal/tracker/multiproject.go):
- ParseCommaSeparated: splits comma-separated config values
- DeduplicateStrings: removes duplicates preserving order
- ResolveProjectIDs: config precedence (CLI > plural > singular)

Linear (closes #2791):
- Tracker: map[string]*Client with per-team routing
- FetchIssues iterates all teams, deduplicates by issue ID
- UpdateIssue routes to owning team via FetchIssueByIdentifier
- Config: linear.team_ids / LINEAR_TEAM_IDS + --team flag

Jira:
- projectKey string → projectKeys []string
- FetchIssues uses JQL IN clause (single query, no iteration)
- Config: jira.projects / JIRA_PROJECTS + --project flag

ADO:
- project string → projects []string
- WIQL uses TeamProject IN clause (single query)
- Config: ado.projects / AZURE_DEVOPS_PROJECTS + --project flag

All singular config keys remain supported for backward compatibility.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
2026-03-28 13:40:39 -07:00
ben
622c852294 fix(linear): include stateId in push updates to sync status changes
UpdateIssue was only pushing title, description, and priority to Linear,
omitting the stateId. This meant `bd close` followed by `bd linear sync
--push` left the Linear issue in its original state instead of marking
it as Done.

Resolve the workflow state ID (via the existing findStateID helper) and
add it to the update payload, mirroring what CreateIssue already does.

Fixes #2046
2026-02-26 17:20:52 +09:00
darcy
fb8ca5fc90 fix: resolve gofmt and golangci-lint CI failures
- gofmt: 7 files had formatting issues (dolt.go, close_guard_test.go,
  init_hooks_test.go, discovery_test.go, types.go, metadata_schema_test.go,
  testdoltserver.go)
- gosec G304: suppress false positives for os.ReadFile on trusted paths
  (daemon PID files, test cleanup)
- gosec G104: handle Close() return values with _ = pattern
- errcheck: wrap os.RemoveAll in defer closure

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-02-25 13:31:06 -08:00
lydia
0b95c75d68 fix(linear): correct Project sync issues from PR #2022
- Progress field: int → float64 (Linear returns 0.0-1.0)
- CreateProject: teamId → teamIds (projects span multiple teams)
- ProjectToEpic: map completedAt → ClosedAt, set CloseReason for canceled
- ProjectToEpic: canonicalize ExternalRef URL, remove raw Linear UUID as ID
- MapEpicToProjectState: map StatusInProgress → "started" for correct round-trip

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-02-24 12:24:19 -08:00
HuyNguyenDinh
e17d73ae9d feat(linear): add Project sync support
- Add Project type and related GraphQL response types
- Add FetchProjects, CreateProject, UpdateProject methods
- Add ProjectToEpic mapping function
- Resolve conflicts with upstream/main
2026-02-23 10:47:29 +07:00
Steven Syrek
634bf5d4a0 refactor(storage): define Storage interface, decouple from concrete DoltStore (bd-l3o)
Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-02-17 10:11:08 +01:00