From e8ae7a291a39e592d452df09dcb99eeb7dfecd70 Mon Sep 17 00:00:00 2001 From: Julian Knutsen Date: Sat, 13 Jun 2026 04:14:28 -0700 Subject: [PATCH] feat(count): add --include-infra for exact bd list cardinality parity (#4389) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * feat(count): add --include-infra for exact bd list cardinality parity bd count hardcoded filter.SkipWisps=true (9a29a158f, Q2 SQL-COUNT rewrite), so it only counted the durable issues table. bd list --include-infra merges the wisps table — including no_history beads, which are durable work — so no count invocation could match a list cardinality. On the production gascity rig store that meant bd count --type task = 23,777 vs a list --include-infra cardinality of 33,601: a 29% undercount that blocks Gas City from implementing an exact Counter over the bd CLI (its bounded-read pagination needs Total to be exact). Changes: - cmd/bd/count.go: new --include-infra flag mirroring bd list's flag. applyCountIncludeInfra reproduces the buildListFilter defaults that determine list's cardinality under --include-infra: wisps merge (SkipWisps=false), template exclusion (IsTemplate=false), default gate exclusion unless --type gate, and infra-type routing to the ephemeral tier using the store-configured infra set. Without the flag the filter construction is unchanged (SkipWisps=true), keeping the widely-scripted default byte-identical. - internal/storage/{dolt,embeddeddolt}/counts.go: CountIssues now delegates to issueops.CountIssuesInTx (extended with the query param) instead of a hardcoded SELECT COUNT(*) FROM issues, so SkipWisps/Ephemeral routing matches SearchIssuesInTx. CountIssuesInTx previously had no production callers. - internal/storage/issueops/count.go: CountIssuesByGroupInTx now honors SkipWisps/Ephemeral with the same merge semantics, so --by-* grouped counts under --include-infra report merged buckets instead of silently-wrong durable-only numbers. - Tests (TDD): cmd/bd/count_filter_test.go pins the count filter against buildListFilter field-by-field; internal/storage/dolt/ count_include_wisps_test.go asserts CountIssues == len(SearchIssues) for the trap filters (templates, no_history, ephemeral) and merged grouped counts; cmd/bd/count_embedded_test.go adds CLI-level count==list parity. - Docs: regenerated CLI reference (also picks up pre-existing dep/import help-text drift so scripts/check-doc-flags.sh passes) and one pre-existing gofmt fix in issueops/search.go for ci-pr-lint. Verification on the production gascity rig store (read-only): bd count --include-infra --type task = 33,601 bd list --include-infra --type task --all --json --limit 0 | len = 33,601 bd count --include-infra = 42,631 (list equivalent: 42,631) bd count --include-infra --status open = 1,969 (list equivalent: 1,969) bd count --include-infra --by-type : total 42,631, task bucket 33,601 bd count --type task (no flag) = 23,777 (stock bd 1.0.5: 23,777) Gates: make ci-pr-core (go test -race -short), ci-pr-policy, ci-pr-lint, go vet ./..., embedded count/list suites, full dolt + embeddeddolt storage packages. Fixes #4387 Co-Authored-By: Claude Fable 5 * fix(cli): write-intent routing for all mutating commands; count ephemeral parity; pin bulk dep cycle gate Adopt-PR review fixes for PR #4389 on top of the pre-review CI repair. Routed write surface (#4141, bd-6dnrw.32, GH#3231): bd-6dnrw.32 gave read-only opens a real read-only path, which silently broke routed sibling writes -- prefix-routed resolution opened the target read-only, so a mutating command on a routes.jsonl-routed ID failed with "store is read-only". The earlier CI repair restored update/comment/comments add/note/reopen; review found the rest of the mutating surface still broken. Write intent now covers every prefix-routed mutating command: assign, priority, tag, edit, delete (single + batch), close (resolveCloseTargets), human respond/dismiss, link, and dep add/--blocks/remove/bulk (via a new resolveIDWithRoutingForWrite). The source issue's store opens writable so the write commits on the target head; read paths, dependency-target ID resolution, dep tree, and contributor auto-routing stay read-only, preserving the bd-6dnrw.32/GH#3231 guarantee that routed reads never mutate a foreign project's history. Regression test TestEmbeddedRoutedMutatingSiblingWritesCommitTargetHead pins assign/tag/ dep add/delete/close routed writes committing on the target head. Count ephemeral parity (GH#4387): CountIssuesInTx returned the wisps count unconditionally for an Ephemeral=true filter, while SearchIssuesInTx falls through to the durable issues table when the wisps tier is empty. The scalar fall-through landed first, but review (attempt 2) found the same fall-through missing from the two sibling functions, so grouped counts and count-projection searches still dropped a durable issues-table row flagged ephemeral=1: CountIssuesByGroupInTx returned empty buckets while the scalar Total fell through (sum(groups) != Total), and SearchIssuesWithCountsInTx returned nil where SearchIssues returned the row. CountIssuesByGroupInTx and SearchIssuesWithCountsInTx now mirror the scalar/list fall-through, so bd count --include-infra --by-* and bd search --counts --include-infra match bd list cardinality when only durable rows match. The scalar fall-through comment is corrected to describe the durable ephemeral=1 defensive state (a promoted bead carries ephemeral=0, so it never reaches this branch). Regression tests TestCountIssuesEphemeralFallsThroughToDurable (scalar), TestCountIssuesByGroupEphemeralFallsThroughToDurable (grouped), and TestSearchIssuesWithCountsEphemeralFallsThroughToDurable (counts projection) pin count==len(list) for that case; the merge path documents that list is the disjoint-table corruption detector. Bulk dep cycle gate (bd-6dnrw.8): unchanged from the pre-review repair -- TestEmbeddedDepBulkNoCycleCheckKeepsWholeGraphGate pins the whole-graph cycle gate on bulk --no-cycle-check adds. Validation (worktree, BEADS_TEST_EMBEDDED_DOLT=1, -tags gms_pure_go): routed-write and count-parity regression tests pass; TestEmbeddedDep*, cross-rig routing, dep/close/delete/link CLI suites, and the count CLI/issueops suites pass; go build, go vet, gofmt, git diff --check clean. Validation (attempt 2, grouped + counts-projection fall-through): go build (issueops, dolt, cmd/bd) and go vet (issueops, dolt) clean; git diff --check clean. The Dolt count/list parity suite passes against an isolated Dolt test container (TestCountIssuesMergedMatchesSearch, the three ephemeral fall-through regressions, TestCountIssuesByGroupIncludesWisps, TestPR4107SearchIssuesWithCountsEphemeralFalseIncludesNoHistoryOnly); all three fall-through regressions were verified failing on the pre-fix tree. Embedded-engine fixtures that need the CGO/ICU build are exercised by the GitHub PR workflow. Co-Authored-By: Claude Fable 5 Co-Authored-By: Claude Opus 4.8 --------- Co-authored-by: CI Bot Co-authored-by: Claude Fable 5 --- cmd/bd/assign.go | 4 +- cmd/bd/autocommit_embedded_test.go | 111 ++++++ cmd/bd/close.go | 5 +- cmd/bd/comment.go | 2 +- cmd/bd/comments.go | 4 +- cmd/bd/count.go | 50 ++- cmd/bd/count_embedded_test.go | 107 +++++ cmd/bd/count_filter_test.go | 114 ++++++ cmd/bd/delete.go | 10 +- cmd/bd/dep.go | 44 ++- cmd/bd/dep_embedded_test.go | 40 +- cmd/bd/edit.go | 6 +- cmd/bd/human.go | 10 +- cmd/bd/link.go | 6 +- cmd/bd/note.go | 2 +- cmd/bd/priority.go | 4 +- cmd/bd/reopen.go | 5 +- cmd/bd/routed.go | 41 +- cmd/bd/tag.go | 4 +- cmd/bd/update.go | 5 +- docs/CLI_REFERENCE.md | 22 +- .../storage/dolt/count_include_wisps_test.go | 368 ++++++++++++++++++ internal/storage/dolt/counts.go | 15 +- internal/storage/embeddeddolt/counts.go | 17 +- internal/storage/issueops/count.go | 98 ++++- internal/storage/issueops/search.go | 1 - internal/storage/issueops/search_counts.go | 20 +- website/docs/cli-reference/count.md | 2 + website/docs/cli-reference/dep.md | 4 +- website/docs/cli-reference/import.md | 16 + website/static/llms-full.txt | 22 +- .../version-1.0.0/cli-reference/count.md | 2 + .../version-1.0.0/cli-reference/dep.md | 4 +- .../version-1.0.0/cli-reference/import.md | 16 + .../version-1.0.4/cli-reference/count.md | 2 + .../version-1.0.4/cli-reference/dep.md | 4 +- .../version-1.0.4/cli-reference/import.md | 16 + .../version-1.0.5/cli-reference/count.md | 2 + .../version-1.0.5/cli-reference/dep.md | 4 +- .../version-1.0.5/cli-reference/import.md | 16 + 40 files changed, 1135 insertions(+), 90 deletions(-) create mode 100644 cmd/bd/count_filter_test.go create mode 100644 internal/storage/dolt/count_include_wisps_test.go diff --git a/cmd/bd/assign.go b/cmd/bd/assign.go index 24845dab2..df299b043 100644 --- a/cmd/bd/assign.go +++ b/cmd/bd/assign.go @@ -27,7 +27,9 @@ Examples: ctx := rootCtx - result, err := resolveAndGetIssueWithRouting(ctx, store, id) + // Write-intent routing: a prefix-routed target must open writable so the + // assignee update commits on the target head (#4141). + result, err := resolveAndGetIssueWithRoutingForWrite(ctx, store, id) if err != nil { if result != nil { result.Close() diff --git a/cmd/bd/autocommit_embedded_test.go b/cmd/bd/autocommit_embedded_test.go index 76542e345..e0970a2b7 100644 --- a/cmd/bd/autocommit_embedded_test.go +++ b/cmd/bd/autocommit_embedded_test.go @@ -245,3 +245,114 @@ func TestEmbeddedRoutedSiblingWritesCommitTargetHead(t *testing.T) { } }) } + +// TestEmbeddedRoutedMutatingSiblingWritesCommitTargetHead pins the rest of the +// prefix-routed mutating command surface to the same write-through contract as +// comment/note/reopen above. These commands (the assign/tag shorthands plus +// dep/delete/close) resolve a prefix-routed target through the write-intent +// router and must commit on the target head, not fail "store is read-only" +// (#4141). Each subtest creates the bead in the target rig, runs the command +// from the source rig so resolution must route, and asserts both that the +// target HEAD advanced and that the mutation persisted in the target store. +func TestEmbeddedRoutedMutatingSiblingWritesCommitTargetHead(t *testing.T) { + if os.Getenv("BEADS_TEST_EMBEDDED_DOLT") != "1" { + t.Skip("set BEADS_TEST_EMBEDDED_DOLT=1 to run embedded dolt auto-commit tests") + } + t.Parallel() + + bd := buildEmbeddedBD(t) + + t.Run("assign", func(t *testing.T) { + sourceDir, targetDir, targetBeadsDir := setupRoutedEmbeddedRepo(t, bd, "sas", "tas") + issue := bdCreate(t, bd, targetDir, "Routed assign target") + before := embeddedCurrentCommit(t, targetBeadsDir, "tas") + + bdCommand(t, bd, sourceDir, "assign", issue.ID, "alice") + + assertEmbeddedHeadAdvanced(t, targetBeadsDir, "tas", before, "routed assign") + targetStore := openStore(t, targetBeadsDir, "tas") + got, err := targetStore.GetIssue(t.Context(), issue.ID) + if err != nil { + t.Fatalf("GetIssue: %v", err) + } + if got.Assignee != "alice" { + t.Fatalf("target assignee = %q, want alice", got.Assignee) + } + }) + + t.Run("tag", func(t *testing.T) { + sourceDir, targetDir, targetBeadsDir := setupRoutedEmbeddedRepo(t, bd, "stg", "ttg") + issue := bdCreate(t, bd, targetDir, "Routed tag target") + before := embeddedCurrentCommit(t, targetBeadsDir, "ttg") + + bdCommand(t, bd, sourceDir, "tag", issue.ID, "routed-label") + + assertEmbeddedHeadAdvanced(t, targetBeadsDir, "ttg", before, "routed tag") + targetStore := openStore(t, targetBeadsDir, "ttg") + labels, err := targetStore.GetLabelsForIssues(t.Context(), []string{issue.ID}) + if err != nil { + t.Fatalf("GetLabelsForIssues: %v", err) + } + if !slices.Contains(labels[issue.ID], "routed-label") { + t.Fatalf("target labels = %v, want routed-label", labels[issue.ID]) + } + }) + + t.Run("dep_add", func(t *testing.T) { + sourceDir, targetDir, targetBeadsDir := setupRoutedEmbeddedRepo(t, bd, "sdp", "tdp") + from := bdCreate(t, bd, targetDir, "Routed dep source") + to := bdCreate(t, bd, targetDir, "Routed dep target") + before := embeddedCurrentCommit(t, targetBeadsDir, "tdp") + + bdCommand(t, bd, sourceDir, "dep", "add", from.ID, to.ID) + + assertEmbeddedHeadAdvanced(t, targetBeadsDir, "tdp", before, "routed dep add") + targetStore := openStore(t, targetBeadsDir, "tdp") + deps, err := targetStore.GetDependencies(t.Context(), from.ID) + if err != nil { + t.Fatalf("GetDependencies: %v", err) + } + found := false + for _, d := range deps { + if d.ID == to.ID { + found = true + break + } + } + if !found { + t.Fatalf("routed dep add did not persist %s -> %s in target store (deps=%v)", from.ID, to.ID, deps) + } + }) + + t.Run("delete", func(t *testing.T) { + sourceDir, targetDir, targetBeadsDir := setupRoutedEmbeddedRepo(t, bd, "sdl", "tdl") + issue := bdCreate(t, bd, targetDir, "Routed delete target") + before := embeddedCurrentCommit(t, targetBeadsDir, "tdl") + + bdCommand(t, bd, sourceDir, "delete", issue.ID, "--force") + + assertEmbeddedHeadAdvanced(t, targetBeadsDir, "tdl", before, "routed delete") + targetStore := openStore(t, targetBeadsDir, "tdl") + if _, err := targetStore.GetIssue(t.Context(), issue.ID); err == nil { + t.Fatalf("routed delete did not remove %s from target store", issue.ID) + } + }) + + t.Run("close", func(t *testing.T) { + sourceDir, targetDir, targetBeadsDir := setupRoutedEmbeddedRepo(t, bd, "scl", "tcl") + issue := bdCreate(t, bd, targetDir, "Routed close target") + before := embeddedCurrentCommit(t, targetBeadsDir, "tcl") + + bdCommand(t, bd, sourceDir, "close", issue.ID, "--reason", "routed close") + + assertEmbeddedHeadAdvanced(t, targetBeadsDir, "tcl", before, "routed close") + targetStore := openStore(t, targetBeadsDir, "tcl") + got, err := targetStore.GetIssue(t.Context(), issue.ID) + if err != nil { + t.Fatalf("GetIssue: %v", err) + } + if got.Status != types.StatusClosed { + t.Fatalf("target status = %s, want %s", got.Status, types.StatusClosed) + } + }) +} diff --git a/cmd/bd/close.go b/cmd/bd/close.go index 76c2b221e..df7c785af 100644 --- a/cmd/bd/close.go +++ b/cmd/bd/close.go @@ -613,7 +613,10 @@ func resolveCloseTargets(ctx context.Context, localStore storage.DoltStorage, id cleanup() return nil, func() {}, fmt.Errorf("resolving ID %s: %w", id, err) } - if r, err := resolveViaPrefixRouting(ctx, id); err == nil { + // Write-intent: a prefix-routed target opens writable so the close + // commits on the target head (#4141). Contributor auto-routing below + // stays read-only: it hydrates foreign projects that must not be mutated. + if r, err := resolveViaPrefixRoutingMode(ctx, id, true); err == nil { results = append(results, r) continue } diff --git a/cmd/bd/comment.go b/cmd/bd/comment.go index 665cf01f1..8a456f4ed 100644 --- a/cmd/bd/comment.go +++ b/cmd/bd/comment.go @@ -62,7 +62,7 @@ Examples: ctx := rootCtx - result, err := resolveAndGetIssueWithRouting(ctx, store, id) + result, err := resolveAndGetIssueWithRoutingForWrite(ctx, store, id) if err != nil { if result != nil { result.Close() diff --git a/cmd/bd/comments.go b/cmd/bd/comments.go index 2977320ec..7306bd657 100644 --- a/cmd/bd/comments.go +++ b/cmd/bd/comments.go @@ -156,7 +156,9 @@ Examples: } ctx := rootCtx - result, err := resolveAndGetIssueWithRouting(ctx, store, issueID) + // Write-intent: comments add writes through the routed target store, + // matching the `bd comment` shorthand (#4141). + result, err := resolveAndGetIssueWithRoutingForWrite(ctx, store, issueID) if err != nil { if result != nil { result.Close() diff --git a/cmd/bd/count.go b/cmd/bd/count.go index ad27ea40e..21aea4007 100644 --- a/cmd/bd/count.go +++ b/cmd/bd/count.go @@ -29,6 +29,7 @@ Examples: bd count --by-assignee # Group count by assignee bd count --by-label # Group count by label bd count --assignee alice --by-status # Count alice's issues by status + bd count --include-infra # Count issues + wisps tier (matches 'bd list --include-infra --all' cardinality) `, Run: func(cmd *cobra.Command, args []string) { status, _ := cmd.Flags().GetString("status") @@ -197,7 +198,15 @@ Examples: filter.PriorityMax = &priorityMax } - filter.SkipWisps = true // bd count never needs ephemeral wisp results + if includeInfra, _ := cmd.Flags().GetBool("include-infra"); includeInfra { + cfg, err := loadDirectListFilterConfig(ctx, store) + if err != nil { + FatalError("%v", err) + } + applyCountIncludeInfra(&filter, issueType, cfg) + } else { + filter.SkipWisps = true // durable tier only; bd count's historical default + } // Q1: SQL COUNT(*) aggregate — avoids materializing all rows. if groupBy == "" { @@ -261,6 +270,40 @@ Examples: }, } +// applyCountIncludeInfra switches the count filter to the wisps-inclusive +// mode of `bd list --include-infra` (GH#4387). It mirrors the buildListFilter +// defaults that determine list's cardinality so that, for any filter set, +// `bd count --include-infra ` returns exactly the number of rows +// `bd list --include-infra --all` materializes: +// +// - the wisps table is merged into the count (SkipWisps=false), picking up +// no_history beads (durable work stored in the wisps tier) and ephemeral +// wisps, exactly like list's merge path; +// - template molecules are excluded (list's default without +// --include-templates); +// - gate beads are excluded unless gates are explicitly requested via +// --type gate (list's default without --include-gates); +// - counting an infra type (agent/rig/role/message, or the store-configured +// set) routes to the ephemeral wisps tier, like list's infra-type listing. +// +// The non-flag path never calls this function: bd count without +// --include-infra keeps its historical durable-only semantics. +func applyCountIncludeInfra(filter *types.IssueFilter, issueType string, cfg listFilterConfig) { + filter.SkipWisps = false + + isTemplate := false + filter.IsTemplate = &isTemplate + + if issueType != "gate" { + filter.ExcludeTypes = append(filter.ExcludeTypes, "gate") + } + + if issueType != "" && cfg.isInfra(issueType) { + ephemeral := true + filter.Ephemeral = &ephemeral + } +} + func init() { // Filter flags (same as list command) countCmd.Flags().StringP("status", "s", "", "Filter by stored status (open, in_progress, blocked, deferred, closed). Note: dependency-blocked issues use 'bd blocked'") @@ -294,6 +337,11 @@ func init() { countCmd.Flags().Int("priority-min", 0, "Filter by minimum priority (inclusive)") countCmd.Flags().Int("priority-max", 0, "Filter by maximum priority (inclusive)") + // Wisps tier (GH#4387): mirrors bd list's flag of the same name so + // `bd count --include-infra ` returns exactly the cardinality of + // `bd list --include-infra --all`. + countCmd.Flags().Bool("include-infra", false, "Include infrastructure beads and the wisps tier (matches 'bd list --include-infra --all' cardinality)") + // Grouping flags countCmd.Flags().Bool("by-status", false, "Group count by status") countCmd.Flags().Bool("by-priority", false, "Group count by priority") diff --git a/cmd/bd/count_embedded_test.go b/cmd/bd/count_embedded_test.go index a7f4e939a..f4649dc20 100644 --- a/cmd/bd/count_embedded_test.go +++ b/cmd/bd/count_embedded_test.go @@ -465,6 +465,113 @@ func TestEmbeddedCount(t *testing.T) { }) } +// TestEmbeddedCountIncludeInfra is the CLI-level guard for GH#4387: +// `bd count --include-infra ` must return exactly the cardinality of +// `bd list --include-infra --all` (modulo list's --limit), including +// the wisps tier (no_history + ephemeral beads) and honoring list's default +// template exclusion. Without the flag, bd count keeps today's durable-only +// semantics. +func TestEmbeddedCountIncludeInfra(t *testing.T) { + if os.Getenv("BEADS_TEST_EMBEDDED_DOLT") != "1" { + t.Skip("set BEADS_TEST_EMBEDDED_DOLT=1 to run embedded dolt integration tests") + } + t.Parallel() + + bd := buildEmbeddedBD(t) + dir, _, _ := bdInit(t, bd, "--prefix", "ci") + + // Durable issues tier. + bdCreate(t, bd, dir, "Infra durable task one", "--type", "task") + bdCreate(t, bd, dir, "Infra durable task two", "--type", "task") + bdCreate(t, bd, dir, "Infra durable bug", "--type", "bug") + closedIssue := bdCreate(t, bd, dir, "Infra durable task closed", "--type", "task") + bdClose(t, bd, dir, closedIssue.ID) + // Wisps tier: no_history beads are durable work that bd list --include-infra + // returns; ephemeral beads are GC-eligible wisps. + bdCreate(t, bd, dir, "Infra nohistory task one", "--type", "task", "--no-history") + bdCreate(t, bd, dir, "Infra nohistory task two", "--type", "task", "--no-history") + bdCreate(t, bd, dir, "Infra ephemeral task", "--type", "task", "--ephemeral") + + countOf := func(args ...string) int { + t.Helper() + m := bdCountJSON(t, bd, dir, args...) + return int(m["count"].(float64)) + } + listCardinality := func(args ...string) int { + t.Helper() + fullArgs := append([]string{"--include-infra", "--all", "--limit", "0"}, args...) + return len(bdListJSON(t, bd, dir, fullArgs...)) + } + + t.Run("default_stays_durable_only", func(t *testing.T) { + if got := countOf("--type", "task"); got != 3 { + t.Errorf("bd count --type task = %d, want 3 (durable tasks only; default must stay byte-identical)", got) + } + }) + + t.Run("include_infra_counts_wisps_tier", func(t *testing.T) { + // 3 durable tasks + 2 no_history tasks + 1 ephemeral task. + if got := countOf("--include-infra", "--type", "task"); got != 6 { + t.Errorf("bd count --include-infra --type task = %d, want 6", got) + } + }) + + t.Run("include_infra_matches_list_cardinality", func(t *testing.T) { + for _, filters := range [][]string{ + nil, + {"--type", "task"}, + {"--type", "bug"}, + {"--status", "open"}, + {"--status", "closed"}, + } { + want := listCardinality(filters...) + got := countOf(append([]string{"--include-infra"}, filters...)...) + if got != want { + t.Errorf("bd count --include-infra %v = %d, but bd list --include-infra --all %v returned %d rows", filters, got, filters, want) + } + } + }) + + t.Run("include_infra_grouped_by_type", func(t *testing.T) { + m := bdCountJSON(t, bd, dir, "--include-infra", "--by-type") + total := int(m["total"].(float64)) + if want := listCardinality(); total != want { + t.Errorf("bd count --include-infra --by-type total = %d, want list cardinality %d", total, want) + } + groups, ok := m["groups"].([]interface{}) + if !ok { + t.Fatal("expected groups array") + } + byType := make(map[string]int) + for _, g := range groups { + gm := g.(map[string]interface{}) + byType[gm["group"].(string)] = int(gm["count"].(float64)) + } + if byType["task"] != 6 { + t.Errorf("grouped task count = %d, want 6 (wisps tier missing from --by-type)", byType["task"]) + } + if byType["bug"] != 1 { + t.Errorf("grouped bug count = %d, want 1", byType["bug"]) + } + }) + + t.Run("grouped_without_flag_stays_durable_only", func(t *testing.T) { + m := bdCountJSON(t, bd, dir, "--by-type") + groups, ok := m["groups"].([]interface{}) + if !ok { + t.Fatal("expected groups array") + } + for _, g := range groups { + gm := g.(map[string]interface{}) + if gm["group"] == "task" { + if got := int(gm["count"].(float64)); got != 3 { + t.Errorf("bd count --by-type task = %d, want 3 (durable only)", got) + } + } + } + }) +} + // TestEmbeddedCountConcurrent exercises count operations concurrently. func TestEmbeddedCountConcurrent(t *testing.T) { if os.Getenv("BEADS_TEST_EMBEDDED_DOLT") != "1" { diff --git a/cmd/bd/count_filter_test.go b/cmd/bd/count_filter_test.go new file mode 100644 index 000000000..7610e51e9 --- /dev/null +++ b/cmd/bd/count_filter_test.go @@ -0,0 +1,114 @@ +//go:build cgo + +package main + +import ( + "reflect" + "testing" + + "github.com/steveyegge/beads/internal/types" +) + +// TestApplyCountIncludeInfraMirrorsListFilter pins `bd count --include-infra` +// to the exact cardinality semantics of `bd list --include-infra --all` +// (GH#4387): for any filter set, the count must equal the number of rows the +// equivalent list invocation returns. The trap dimensions are the wisps merge +// (SkipWisps), template exclusion (IsTemplate), the default gate exclusion +// (ExcludeTypes), and infra-type routing to the ephemeral tier (Ephemeral). +func TestApplyCountIncludeInfraMirrorsListFilter(t *testing.T) { + cfg := listFilterConfig{} + for _, issueType := range []string{"", "task", "gate", "message"} { + name := issueType + if name == "" { + name = "none" + } + t.Run("type_"+name, func(t *testing.T) { + in := listInput{allFlag: true, includeInfra: true, issueType: issueType} + want, err := buildListFilter(in, cfg) + if err != nil { + t.Fatalf("buildListFilter(%q): %v", issueType, err) + } + + got := types.IssueFilter{} + if issueType != "" { + it := types.IssueType(issueType) + got.IssueType = &it + } + applyCountIncludeInfra(&got, issueType, cfg) + + if got.SkipWisps != want.SkipWisps { + t.Errorf("SkipWisps = %v, list --include-infra --all uses %v", got.SkipWisps, want.SkipWisps) + } + if !reflect.DeepEqual(got.IsTemplate, want.IsTemplate) { + t.Errorf("IsTemplate = %v, list --include-infra --all uses %v", ptrStr(got.IsTemplate), ptrStr(want.IsTemplate)) + } + if !reflect.DeepEqual(got.ExcludeTypes, want.ExcludeTypes) { + t.Errorf("ExcludeTypes = %v, list --include-infra --all uses %v", got.ExcludeTypes, want.ExcludeTypes) + } + if !reflect.DeepEqual(got.Ephemeral, want.Ephemeral) { + t.Errorf("Ephemeral = %v, list --include-infra --all uses %v", ptrStr(got.Ephemeral), ptrStr(want.Ephemeral)) + } + if !reflect.DeepEqual(got.IssueType, want.IssueType) { + t.Errorf("IssueType = %v, list --include-infra --all uses %v", got.IssueType, want.IssueType) + } + // bd count defaults to all statuses and all pinned states, which is + // exactly what list's --all flag selects: none of these dimensions + // may carry a filter on either side. + if !reflect.DeepEqual(got.Status, want.Status) { + t.Errorf("Status = %v, list --include-infra --all uses %v", got.Status, want.Status) + } + if !reflect.DeepEqual(got.Statuses, want.Statuses) { + t.Errorf("Statuses = %v, list --include-infra --all uses %v", got.Statuses, want.Statuses) + } + if !reflect.DeepEqual(got.ExcludeStatus, want.ExcludeStatus) { + t.Errorf("ExcludeStatus = %v, list --include-infra --all uses %v", got.ExcludeStatus, want.ExcludeStatus) + } + if !reflect.DeepEqual(got.Pinned, want.Pinned) { + t.Errorf("Pinned = %v, list --include-infra --all uses %v", ptrStr(got.Pinned), ptrStr(want.Pinned)) + } + }) + } +} + +// TestApplyCountIncludeInfraCustomInfraTypes verifies that the infra-type +// routing honors a store-configured infra set, exactly like bd list does. +func TestApplyCountIncludeInfraCustomInfraTypes(t *testing.T) { + cfg := listFilterConfig{infraSet: map[string]bool{"robot": true}} + + var robot types.IssueFilter + applyCountIncludeInfra(&robot, "robot", cfg) + if robot.Ephemeral == nil || !*robot.Ephemeral { + t.Errorf("custom infra type %q must route to the ephemeral tier (Ephemeral=true), got %v", "robot", ptrStr(robot.Ephemeral)) + } + + // "message" is a default infra type but NOT part of the custom set, so it + // must not route to the ephemeral tier (mirrors listFilterConfig.isInfra). + var msg types.IssueFilter + applyCountIncludeInfra(&msg, "message", cfg) + if msg.Ephemeral != nil { + t.Errorf("non-infra type under custom set must keep Ephemeral=nil, got %v", ptrStr(msg.Ephemeral)) + } +} + +// TestApplyCountIncludeInfraDefaultUntouched documents that the helper is only +// invoked under --include-infra: the no-flag path must keep today's +// durable-only semantics (SkipWisps=true, no template/gate exclusion). +func TestApplyCountIncludeInfraDefaultUntouched(t *testing.T) { + // The default path in count.go does not call applyCountIncludeInfra; it + // sets SkipWisps=true and nothing else. Pin the flag's existence and + // default value so scripted callers keep byte-identical behavior. + flag := countCmd.Flags().Lookup("include-infra") + if flag == nil { + t.Fatal("bd count must expose an --include-infra flag (GH#4387)") + } + if flag.DefValue != "false" { + t.Fatalf("--include-infra must default to false, got %q", flag.DefValue) + } +} + +func ptrStr[T any](p *T) string { + if p == nil { + return "" + } + return "&" + reflect.ValueOf(*p).String() +} diff --git a/cmd/bd/delete.go b/cmd/bd/delete.go index 6a25a2d4d..442d8cf2f 100644 --- a/cmd/bd/delete.go +++ b/cmd/bd/delete.go @@ -88,8 +88,10 @@ Force: Delete and orphan dependents // Single issue deletion (legacy behavior) issueID := issueIDs[0] ctx := rootCtx - // Get the issue to be deleted, using prefix-based routing - routedResult, err := resolveAndGetIssueWithRouting(ctx, store, issueID) + // Get the issue to be deleted, using prefix-based routing. Write-intent: + // a prefix-routed target opens writable so the delete commits on the + // target head (#4141). + routedResult, err := resolveAndGetIssueWithRoutingForWrite(ctx, store, issueID) if err != nil { if isNotFoundErr(err) { FatalError("issue %s not found", issueID) @@ -252,7 +254,9 @@ func deleteBatch(_ *cobra.Command, issueIDs []string, force bool, dryRun bool, c notFound := []string{} var routedStore storage.DoltStorage for _, id := range issueIDs { - result, err := resolveAndGetIssueWithRouting(ctx, store, id) + // Write-intent: the batch delete mutates this routed store below, so it + // must open writable to commit on the target head (#4141). + result, err := resolveAndGetIssueWithRoutingForWrite(ctx, store, id) if err != nil { if isNotFoundErr(err) { notFound = append(notFound, id) diff --git a/cmd/bd/dep.go b/cmd/bd/dep.go index 97685db75..d762377ab 100644 --- a/cmd/bd/dep.go +++ b/cmd/bd/dep.go @@ -22,8 +22,30 @@ import ( // If the issue routes to a different database, a routed store is returned // and must be closed by the caller via the returned cleanup function. // If the issue is in the local store, cleanup is a no-op. +// +// The routed store is opened read-only; callers that mutate the returned store +// (e.g. dep add/remove/link writing through the source issue's store) must use +// resolveIDWithRoutingForWrite instead. func resolveIDWithRouting(ctx context.Context, localStore storage.DoltStorage, id string) (resolvedID string, targetStore storage.DoltStorage, cleanup func(), err error) { - result, err := resolveAndGetIssueWithRouting(ctx, localStore, id) + return resolveIDWithRoutingMode(ctx, localStore, id, false) +} + +// resolveIDWithRoutingForWrite is the write-intent variant of +// resolveIDWithRouting: a prefix-routed target store is opened writable so a +// dependency write through it commits on the target head (#4141). Read-only +// resolution (e.g. resolving the depends-on target ID, or dep tree) must keep +// resolveIDWithRouting so a routed read never mutates a foreign project's +// history (bd-6dnrw.32, GH#3231). +func resolveIDWithRoutingForWrite(ctx context.Context, localStore storage.DoltStorage, id string) (resolvedID string, targetStore storage.DoltStorage, cleanup func(), err error) { + return resolveIDWithRoutingMode(ctx, localStore, id, true) +} + +func resolveIDWithRoutingMode(ctx context.Context, localStore storage.DoltStorage, id string, forWrite bool) (resolvedID string, targetStore storage.DoltStorage, cleanup func(), err error) { + resolve := resolveAndGetIssueWithRouting + if forWrite { + resolve = resolveAndGetIssueWithRoutingForWrite + } + result, err := resolve(ctx, localStore, id) if err != nil { return "", nil, func() {}, fmt.Errorf("resolving issue ID %s: %w", id, err) } @@ -123,8 +145,10 @@ Examples: ctx := rootCtx depType := "blocks" - // Resolve partial IDs with routing support - fromID, fromStore, fromCleanup, err := resolveIDWithRouting(ctx, store, blocksID) + // Resolve partial IDs with routing support. The source issue's store + // is mutated below, so resolve it write-intent (#4141); the blocker + // target is only resolved by ID and stays read-only. + fromID, fromStore, fromCleanup, err := resolveIDWithRoutingForWrite(ctx, store, blocksID) if err != nil { FatalErrorRespectJSON("%v", err) } @@ -280,7 +304,9 @@ Examples: // Check if toID is an external reference (don't resolve it) isExternalRef := strings.HasPrefix(dependsOnArg, "external:") - fromID, fromStore, fromCleanup, err := resolveIDWithRouting(ctx, store, args[0]) + // Write-intent: the source issue's store is mutated by AddDependency + // below, so the routed target must open writable (#4141). + fromID, fromStore, fromCleanup, err := resolveIDWithRoutingForWrite(ctx, store, args[0]) if err != nil { FatalErrorRespectJSON("%v", err) } @@ -571,7 +597,9 @@ func validateBulkDepEdges(ctx context.Context, edges []bulkDepEdge) ([]bulkDepEd for _, edge := range edges { current := edge - fromID, fromStore, fromCleanup, err := resolveIDWithRouting(ctx, store, edge.IssueID) + // Write-intent: addBulkDependencies writes through current.Store (the + // source issue's store), so a routed target must open writable (#4141). + fromID, fromStore, fromCleanup, err := resolveIDWithRoutingForWrite(ctx, store, edge.IssueID) if err != nil { errs = append(errs, fmt.Sprintf("line %d: resolving issue ID %s: %v", edge.Line, edge.IssueID, err)) continue @@ -859,9 +887,11 @@ var depRemoveCmd = &cobra.Command{ CheckReadonly("dep remove") ctx := rootCtx - // Resolve partial IDs with routing support + // Resolve partial IDs with routing support. The source issue's store is + // mutated by RemoveDependency below, so resolve it write-intent (#4141); + // the depends-on target is only resolved by ID and stays read-only. var fromID, toID string - fromID, fromStore, fromCleanup, err := resolveIDWithRouting(ctx, store, args[0]) + fromID, fromStore, fromCleanup, err := resolveIDWithRoutingForWrite(ctx, store, args[0]) if err != nil { FatalErrorRespectJSON("%v", err) } diff --git a/cmd/bd/dep_embedded_test.go b/cmd/bd/dep_embedded_test.go index 7bd204c47..35739b5e3 100644 --- a/cmd/bd/dep_embedded_test.go +++ b/cmd/bd/dep_embedded_test.go @@ -79,6 +79,21 @@ func bdDepWithInput(t *testing.T, bd, dir, input string, args ...string) string return stdout.String() } +// bdDepWithInputFail runs "bd dep" with stdin input expecting failure. +func bdDepWithInputFail(t *testing.T, bd, dir, input string, args ...string) string { + t.Helper() + fullArgs := append([]string{"dep"}, args...) + cmd := exec.Command(bd, fullArgs...) + cmd.Dir = dir + cmd.Env = bdEnv(dir) + cmd.Stdin = strings.NewReader(input) + out, err := cmd.CombinedOutput() + if err == nil { + t.Fatalf("expected bd dep %s to fail, but succeeded:\n%s", strings.Join(args, " "), out) + } + return string(out) +} + func TestEmbeddedDep(t *testing.T) { if os.Getenv("BEADS_TEST_EMBEDDED_DOLT") != "1" { t.Skip("set BEADS_TEST_EMBEDDED_DOLT=1 to run embedded dolt integration tests") @@ -523,7 +538,12 @@ func TestEmbeddedDepNoCycleCheck(t *testing.T) { bdDep(t, bd, dir, extra.ID, "--blocks", ids[n-1], "--no-cycle-check") } -func TestEmbeddedDepBulkNoCycleCheckSkipsPerEdgeCycleValidation(t *testing.T) { +// TestEmbeddedDepBulkNoCycleCheckKeepsWholeGraphGate pins the bd-6dnrw.8 +// contract: bulk --no-cycle-check skips the per-edge recursive check for +// speed, but one whole-graph cycle check still gates the commit, so a bulk +// add that would introduce a cycle rolls back atomically instead of landing +// and poisoning ready-work. +func TestEmbeddedDepBulkNoCycleCheckKeepsWholeGraphGate(t *testing.T) { if os.Getenv("BEADS_TEST_EMBEDDED_DOLT") != "1" { t.Skip("set BEADS_TEST_EMBEDDED_DOLT=1 to run embedded dolt integration tests") } @@ -534,15 +554,25 @@ func TestEmbeddedDepBulkNoCycleCheckSkipsPerEdgeCycleValidation(t *testing.T) { a := bdCreate(t, bd, dir, "Bulk cycle A", "--type", "task") b := bdCreate(t, bd, dir, "Bulk cycle B", "--type", "task") - input := fmt.Sprintf("{\"from\":%q,\"to\":%q}\n{\"from\":%q,\"to\":%q}\n", a.ID, b.ID, b.ID, a.ID) + c := bdCreate(t, bd, dir, "Bulk cycle C", "--type", "task") - out := bdDepWithInput(t, bd, dir, input, "add", "--file", "-", "--no-cycle-check") + // Cycle-free bulk wiring succeeds with the per-edge check skipped. + okInput := fmt.Sprintf("{\"from\":%q,\"to\":%q}\n{\"from\":%q,\"to\":%q}\n", a.ID, b.ID, b.ID, c.ID) + out := bdDepWithInput(t, bd, dir, okInput, "add", "--file", "-", "--no-cycle-check") if !strings.Contains(out, "Added 2 dependencies") { t.Fatalf("expected bulk add summary, got: %s", out) } + // Closing the chain into a cycle is refused by the final whole-graph + // check, and the refused batch commits nothing. + cycleInput := fmt.Sprintf("{\"from\":%q,\"to\":%q}\n", c.ID, a.ID) + failOut := bdDepWithInputFail(t, bd, dir, cycleInput, "add", "--file", "-", "--no-cycle-check") + if !strings.Contains(failOut, "dependency cycle would be created") || !strings.Contains(failOut, "no edges added") { + t.Fatalf("expected whole-graph cycle rejection, got: %s", failOut) + } + cycles := bdDep(t, bd, dir, "cycles") - if !strings.Contains(cycles, "Found") { - t.Fatalf("expected skipped cycle validation to leave detectable cycle, got: %s", cycles) + if !strings.Contains(cycles, "No dependency cycles detected") { + t.Fatalf("expected rolled-back bulk add to leave the graph acyclic, got: %s", cycles) } } diff --git a/cmd/bd/edit.go b/cmd/bd/edit.go index 4999187c0..ddfe1b375 100644 --- a/cmd/bd/edit.go +++ b/cmd/bd/edit.go @@ -31,8 +31,10 @@ Examples: id := args[0] ctx := rootCtx - // Resolve ID with prefix routing (supports cross-rig edits like `bd edit xe-5ls`) - result, err := resolveAndGetIssueWithRouting(ctx, store, id) + // Resolve ID with prefix routing (supports cross-rig edits like `bd edit xe-5ls`). + // Write-intent: the routed target opens writable so the field update + // commits on the target head (#4141). + result, err := resolveAndGetIssueWithRoutingForWrite(ctx, store, id) if err != nil { FatalErrorRespectJSON("resolving %s: %v", id, err) } diff --git a/cmd/bd/human.go b/cmd/bd/human.go index 56615f370..b20c17a10 100644 --- a/cmd/bd/human.go +++ b/cmd/bd/human.go @@ -191,8 +191,9 @@ Examples: ctx := rootCtx issueID := args[0] - // Resolve partial ID and get issue - result, err := resolveAndGetIssueWithRouting(ctx, store, issueID) + // Resolve partial ID and get issue. Write-intent: a prefix-routed target + // opens writable so the comment/close commits on the target head (#4141). + result, err := resolveAndGetIssueWithRoutingForWrite(ctx, store, issueID) if err != nil { FatalErrorRespectJSON("resolving issue ID %s: %v", issueID, err) } @@ -263,8 +264,9 @@ Examples: ctx := rootCtx issueID := args[0] - // Resolve partial ID and get issue - result, err := resolveAndGetIssueWithRouting(ctx, store, issueID) + // Resolve partial ID and get issue. Write-intent: a prefix-routed target + // opens writable so the comment/close commits on the target head (#4141). + result, err := resolveAndGetIssueWithRoutingForWrite(ctx, store, issueID) if err != nil { FatalErrorRespectJSON("resolving issue ID %s: %v", issueID, err) } diff --git a/cmd/bd/link.go b/cmd/bd/link.go index 501c59049..32a774817 100644 --- a/cmd/bd/link.go +++ b/cmd/bd/link.go @@ -31,8 +31,10 @@ Examples: ctx := rootCtx - // Resolve partial IDs with routing support - fromID, fromStore, fromCleanup, err := resolveIDWithRouting(ctx, store, id1) + // Resolve partial IDs with routing support. The source issue's store is + // mutated by AddDependency below, so resolve it write-intent (#4141); the + // dependency target is only resolved by ID and stays read-only. + fromID, fromStore, fromCleanup, err := resolveIDWithRoutingForWrite(ctx, store, id1) if err != nil { FatalErrorRespectJSON("%v", err) } diff --git a/cmd/bd/note.go b/cmd/bd/note.go index e5f751394..095a7d8f3 100644 --- a/cmd/bd/note.go +++ b/cmd/bd/note.go @@ -60,7 +60,7 @@ Examples: ctx := rootCtx - result, err := resolveAndGetIssueWithRouting(ctx, store, id) + result, err := resolveAndGetIssueWithRoutingForWrite(ctx, store, id) if err != nil { if result != nil { result.Close() diff --git a/cmd/bd/priority.go b/cmd/bd/priority.go index 457ef48eb..ec4becb51 100644 --- a/cmd/bd/priority.go +++ b/cmd/bd/priority.go @@ -40,7 +40,9 @@ Examples: ctx := rootCtx - result, err := resolveAndGetIssueWithRouting(ctx, store, id) + // Write-intent routing: a prefix-routed target must open writable so the + // priority update commits on the target head (#4141). + result, err := resolveAndGetIssueWithRoutingForWrite(ctx, store, id) if err != nil { if result != nil { result.Close() diff --git a/cmd/bd/reopen.go b/cmd/bd/reopen.go index b3ee92569..dbe691072 100644 --- a/cmd/bd/reopen.go +++ b/cmd/bd/reopen.go @@ -31,8 +31,9 @@ This is more explicit than 'bd update --status open' and emits a Reopened event. diagHint()) } for _, id := range args { - // Resolve with prefix routing (supports cross-rig reopens like `bd reopen xe-5ls`) - result, err := resolveAndGetIssueWithRouting(ctx, store, id) + // Resolve with prefix routing (supports cross-rig reopens like `bd reopen xe-5ls`). + // Write-intent: reopen commits through the routed target store (#4141). + result, err := resolveAndGetIssueWithRoutingForWrite(ctx, store, id) if err != nil { fmt.Fprintf(os.Stderr, "Error resolving %s: %v\n", id, err) hasError = true diff --git a/cmd/bd/routed.go b/cmd/bd/routed.go index 1b4ddea6a..a13e2a22c 100644 --- a/cmd/bd/routed.go +++ b/cmd/bd/routed.go @@ -50,9 +50,26 @@ func (r *RoutedResult) Close() { // Tries the local store first, then prefix-based routing via routes.jsonl, // then falls back to contributor auto-routing. // +// Routed stores are opened read-only; mutating commands must use +// resolveAndGetIssueWithRoutingForWrite instead. +// // Returns a RoutedResult containing the issue, resolved ID, and the store to use. // The caller MUST call result.Close() when done to release any routed storage. func resolveAndGetIssueWithRouting(ctx context.Context, localStore storage.DoltStorage, id string) (*RoutedResult, error) { + return resolveAndGetIssueWithRoutingMode(ctx, localStore, id, false) +} + +// resolveAndGetIssueWithRoutingForWrite is the write-intent variant of +// resolveAndGetIssueWithRouting: a prefix-routed target store is opened +// writable so mutating commands can write through it and commit on the +// target store's head (#4141). Read paths must keep the read-only variant so +// a routed read can never write migrations or other open-time mutations into +// a foreign project's history (bd-6dnrw.32, GH#3231). +func resolveAndGetIssueWithRoutingForWrite(ctx context.Context, localStore storage.DoltStorage, id string) (*RoutedResult, error) { + return resolveAndGetIssueWithRoutingMode(ctx, localStore, id, true) +} + +func resolveAndGetIssueWithRoutingMode(ctx context.Context, localStore storage.DoltStorage, id string, forWrite bool) (*RoutedResult, error) { // Try local store first. result, err := resolveAndGetFromStore(ctx, localStore, id, false) if err == nil { @@ -63,12 +80,14 @@ func resolveAndGetIssueWithRouting(ctx context.Context, localStore storage.DoltS // This handles cross-rig lookups where the ID's prefix maps to a different // database (e.g., hr-8wn.1 routes to the herald rig's database). if isNotFoundErr(err) { - if prefixResult, prefixErr := resolveViaPrefixRouting(ctx, id); prefixErr == nil { + if prefixResult, prefixErr := resolveViaPrefixRoutingMode(ctx, id, forWrite); prefixErr == nil { return prefixResult, nil } } // If not found via prefix routing, try contributor auto-routing as fallback (GH#2345). + // Auto-routed stores stay read-only even for write-intent callers: this + // path hydrates foreign contributor projects, which must never be mutated. if isNotFoundErr(err) { if autoResult, autoErr := resolveViaAutoRouting(ctx, localStore, id); autoErr == nil { return autoResult, nil @@ -125,13 +144,21 @@ type prefixRoute struct { } // resolveViaPrefixRouting attempts to find an issue by looking up its prefix -// in routes.jsonl and opening the target rig's database. +// in routes.jsonl and opening the target rig's database read-only. // // This enables cross-rig lookups: when running from a redirected .beads directory // (e.g., crew/beercan → town/.beads with database "hq"), a bead ID like "hr-8wn.1" // can be resolved by following the "hr-" route to the herald rig's .beads directory, // which declares dolt_database="herald". func resolveViaPrefixRouting(ctx context.Context, id string) (*RoutedResult, error) { + return resolveViaPrefixRoutingMode(ctx, id, false) +} + +// resolveViaPrefixRoutingMode is resolveViaPrefixRouting with an explicit +// store-open mode. forWrite opens the routed target writable, behaving like +// running the command inside that rig; false keeps the read-only open that +// guarantees a routed read cannot mutate the target (bd-6dnrw.32). +func resolveViaPrefixRoutingMode(ctx context.Context, id string, forWrite bool) (*RoutedResult, error) { // Extract prefix from the bead ID (e.g., "hr-" from "hr-8wn.1") prefix := extractBeadPrefix(id) if prefix == "" { @@ -183,12 +210,18 @@ func resolveViaPrefixRouting(ctx context.Context, id string) (*RoutedResult, err debug.Logf("[routing] Prefix %q matched route to %s (database: %s)\n", prefix, matchedRoute.Path, targetDB) - // Open a read-only store for the target database. + // Open a store for the target database — read-only unless the caller + // declared write intent (routed writes must commit on the target head, + // which a read-only open refuses). // We need to temporarily override BEADS_DOLT_SERVER_DATABASE so the store // connects to the correct database on the shared Dolt server. + openStore := newReadOnlyStoreFromConfig + if forWrite { + openStore = newDoltStoreFromConfig + } origDB := os.Getenv("BEADS_DOLT_SERVER_DATABASE") _ = os.Setenv("BEADS_DOLT_SERVER_DATABASE", targetDB) - targetStore, err := newReadOnlyStoreFromConfig(ctx, targetBeadsDir) + targetStore, err := openStore(ctx, targetBeadsDir) // Restore the original env var if origDB != "" { _ = os.Setenv("BEADS_DOLT_SERVER_DATABASE", origDB) diff --git a/cmd/bd/tag.go b/cmd/bd/tag.go index 80646b7eb..3d77bf1e9 100644 --- a/cmd/bd/tag.go +++ b/cmd/bd/tag.go @@ -27,7 +27,9 @@ Examples: ctx := rootCtx - result, err := resolveAndGetIssueWithRouting(ctx, store, id) + // Write-intent routing: a prefix-routed target must open writable so the + // label add commits on the target head (#4141). + result, err := resolveAndGetIssueWithRoutingForWrite(ctx, store, id) if err != nil { if result != nil { result.Close() diff --git a/cmd/bd/update.go b/cmd/bd/update.go index 7b369c15d..77f30db7a 100644 --- a/cmd/bd/update.go +++ b/cmd/bd/update.go @@ -322,8 +322,9 @@ create, update, show, or close operation).`, pendingCloseResults = nil } for _, id := range args { - // Resolve and get issue with routing (e.g., gt-xyz routes to another rig) - result, err := resolveAndGetIssueWithRouting(ctx, store, id) + // Resolve and get issue with routing (e.g., gt-xyz routes to another rig). + // Write-intent: update commits through the routed target store (#4141). + result, err := resolveAndGetIssueWithRoutingForWrite(ctx, store, id) if err != nil { if result != nil { result.Close() diff --git a/docs/CLI_REFERENCE.md b/docs/CLI_REFERENCE.md index d5a6525ec..721aaa3c5 100644 --- a/docs/CLI_REFERENCE.md +++ b/docs/CLI_REFERENCE.md @@ -1505,6 +1505,7 @@ Examples: bd count --by-assignee # Group count by assignee bd count --by-label # Group count by label bd count --assignee alice --by-status # Count alice's issues by status + bd count --include-infra # Count issues + wisps tier (matches 'bd list --include-infra --all' cardinality) ``` @@ -1527,6 +1528,7 @@ bd count [flags] --desc-contains string Filter by description substring --empty-description Filter issues with empty description --id string Filter by specific issue IDs (comma-separated) + --include-infra Include infrastructure beads and the wisps tier (matches 'bd list --include-infra --all' cardinality) -l, --label strings Filter by labels (AND: must have ALL) --label-any strings Filter by labels (OR: must have AT LEAST ONE) --no-assignee Filter issues with no assignee @@ -1780,7 +1782,7 @@ bd dep [issue-id] [flags] ``` -b, --blocks string Issue ID that this issue blocks (shorthand for: bd dep add ) - --no-cycle-check Skip cycle detection after adding (use for bulk wiring — run 'bd dep cycles' to verify afterwards) + --no-cycle-check Skip per-edge cycle checks for speed (bulk wiring); bulk --file adds still run one final whole-graph check before commit ``` #### bd dep add @@ -1825,7 +1827,7 @@ bd dep add [issue-id] [depends-on-id] [flags] --blocked-by string Issue ID that blocks the first issue (alternative to positional arg) --depends-on string Issue ID that the first issue depends on (alias for --blocked-by) --file string Read dependency edges from JSONL file, or '-' for stdin - --no-cycle-check Skip cycle detection after adding (use for bulk wiring — run 'bd dep cycles' to verify afterwards) + --no-cycle-check Skip per-edge cycle checks for speed (bulk wiring); bulk --file adds still run one final whole-graph check before commit -t, --type string Dependency type (blocks|tracks|related|parent-child|discovered-from|until|caused-by|validates|relates-to|supersedes) (default "blocks") ``` @@ -2427,6 +2429,20 @@ Timestamps (created_at, updated_at, started_at, closed_at) are preserved when present in the JSONL and otherwise filled in by the importer. The legacy "wisp" boolean is accepted as an alias for "ephemeral". +By default a row only rewrites an existing local issue when its +updated_at is strictly newer. Older rows are skipped (reported as +stale_skipped_ids) and rows with the same updated_at keep every local +column — updated_at has second granularity, so a timestamp tie can be +two distinct same-second updates, and the local row wins the tie +(reported as tie_kept_local_ids; the row's labels/comments/dependencies +still merge). The guard is also enforced inside the upsert itself, so a +local update that lands while the import is running is preserved rather +than overwritten. Existing issues that the import did rewrite are listed +with a field-level summary (updated_issues), so local state changed by +an import is visible. To deliberately restore an older snapshot, pass +--allow-stale, which imports every row even when it overwrites newer +local state. + EXAMPLES: bd import # Import from configured import.path bd import backup.jsonl # Import from a specific file @@ -2435,6 +2451,7 @@ EXAMPLES: cat issues.jsonl | bd import - # Pipe JSONL from another tool bd import --dry-run # Show what would be imported bd import --dedup # Skip issues with duplicate titles + bd import --allow-stale old.jsonl # Restore an older snapshot (overwrites newer local rows) bd import --json # Structured output with created and skipped IDs ``` @@ -2444,6 +2461,7 @@ bd import [file|-] [flags] **Flags:** ``` + --allow-stale Import rows even when older than the local issue (required to restore an older snapshot) --dedup Skip lines whose title matches an existing open issue --dry-run Show what would be imported without importing -i, --input string Read JSONL from a specific file diff --git a/internal/storage/dolt/count_include_wisps_test.go b/internal/storage/dolt/count_include_wisps_test.go new file mode 100644 index 000000000..7402fb55b --- /dev/null +++ b/internal/storage/dolt/count_include_wisps_test.go @@ -0,0 +1,368 @@ +package dolt + +import ( + "context" + "testing" + "time" + + "github.com/steveyegge/beads/internal/types" +) + +// seedCountWispCorpus creates a mixed corpus spanning every cardinality trap +// from GH#4387: durable issues, a template, no_history wisps (durable work in +// the wisps table), and a true ephemeral wisp. +// +// Layout (prefix distinguishes per-test corpora on the shared branch store): +// +//

-perm-task-1 issues task open +//

-perm-task-2 issues task closed +//

-perm-bug issues bug open +//

-perm-tpl issues task open is_template=1 +//

-nohist-task wisps task open no_history=1 +//

-nohist-bug wisps bug open no_history=1 +//

-eph-task wisps task open ephemeral=1 +func seedCountWispCorpus(t *testing.T, ctx context.Context, store *DoltStore, p string) { + t.Helper() + now := time.Now() + mk := func(id string, mut func(*types.Issue)) { + t.Helper() + issue := &types.Issue{ + ID: p + "-" + id, + Title: id, + Status: types.StatusOpen, + Priority: 2, + IssueType: types.TypeTask, + } + if mut != nil { + mut(issue) + } + if err := store.CreateIssue(ctx, issue, "tester"); err != nil { + t.Fatalf("create %s: %v", issue.ID, err) + } + } + mk("perm-task-1", nil) + mk("perm-task-2", func(i *types.Issue) { + i.Status = types.StatusClosed + i.ClosedAt = &now + }) + mk("perm-bug", func(i *types.Issue) { i.IssueType = types.TypeBug }) + mk("perm-tpl", func(i *types.Issue) { i.IsTemplate = true }) + mk("nohist-task", func(i *types.Issue) { i.NoHistory = true }) + mk("nohist-bug", func(i *types.Issue) { + i.NoHistory = true + i.IssueType = types.TypeBug + }) + mk("eph-task", func(i *types.Issue) { i.Ephemeral = true }) +} + +// TestCountIssuesMergedMatchesSearch is the storage-side parity guard for +// GH#4387: for any filter, CountIssues with SkipWisps=false must return +// exactly len(SearchIssues) for the same filter — the merged issues+wisps +// cardinality that `bd list --include-infra` materializes. +func TestCountIssuesMergedMatchesSearch(t *testing.T) { + store, cleanup := setupTestStore(t) + defer cleanup() + + ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second) + defer cancel() + + seedCountWispCorpus(t, ctx, store, "cm") + + task := types.TypeTask + noTemplate := false + ephemeral := true + + cases := []struct { + name string + filter types.IssueFilter + want int64 + }{ + // 4 issues + 2 no_history wisps + 1 ephemeral wisp. + {"merged_all", types.IssueFilter{}, 7}, + // Durable tier only (today's bd count default). + {"durable_only", types.IssueFilter{SkipWisps: true}, 4}, + // Type filter applies identically to both tables. + {"merged_type_task", types.IssueFilter{IssueType: &task}, 5}, + // Template exclusion (bd list default) drops cm-perm-tpl. + {"merged_no_templates", types.IssueFilter{IsTemplate: &noTemplate}, 6}, + {"merged_no_templates_task", types.IssueFilter{IsTemplate: &noTemplate, IssueType: &task}, 4}, + // Ephemeral-only routes to the wisps tier (bd list --type ). + {"ephemeral_only", types.IssueFilter{Ephemeral: &ephemeral}, 1}, + } + + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + count, err := store.CountIssues(ctx, "", tc.filter) + if err != nil { + t.Fatalf("CountIssues: %v", err) + } + if count != tc.want { + t.Errorf("CountIssues = %d, want %d", count, tc.want) + } + + results, err := store.SearchIssues(ctx, "", tc.filter) + if err != nil { + t.Fatalf("SearchIssues: %v", err) + } + if count != int64(len(results)) { + t.Errorf("CountIssues = %d but SearchIssues returned %d rows; count/list parity broken (GH#4387)", count, len(results)) + } + }) + } +} + +// TestCountIssuesEphemeralFallsThroughToDurable pins the GH#4387 count/list +// parity fix for the ephemeral (infra-type) branch. SearchIssuesInTx, when an +// Ephemeral=true filter matches no wisps, falls through and searches the +// durable issues table (search.go "Fall through: wisps table doesn't exist or +// returned no results"). Before the fix CountIssuesInTx returned the wisps-only +// count and so reported 0 where list returned the durable row, breaking the +// "count == len(list) for any filter" contract. This reproduces the exact +// empty-wisps-but-durable-match state: a durable issues row carrying +// ephemeral=1 (what an infra bead that landed durable looks like), which normal +// creation never produces because it routes ephemeral/infra beads to the wisps +// table, so the row is inserted directly. +func TestCountIssuesEphemeralFallsThroughToDurable(t *testing.T) { + store, cleanup := setupTestStore(t) + defer cleanup() + + ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second) + defer cancel() + + // A durable, non-ephemeral task that the Ephemeral=true filter must exclude, + // so the test proves the filter is applied rather than counting everything. + if err := store.CreateIssue(ctx, &types.Issue{ + ID: "ed-task-1", + Title: "durable task", + Status: types.StatusOpen, + Priority: 2, + IssueType: types.TypeTask, + }, "tester"); err != nil { + t.Fatalf("create durable task: %v", err) + } + + // A durable issues-table row flagged ephemeral=1 with no matching wisp. + if _, err := store.db.ExecContext(ctx, + "INSERT INTO issues (id, title, description, design, acceptance_criteria, notes, status, priority, issue_type, ephemeral) "+ + "VALUES ('ed-infra-1', 'durable ephemeral', '', '', '', '', 'open', 2, 'agent', 1)"); err != nil { + t.Fatalf("seed durable ephemeral issue: %v", err) + } + + ephemeral := true + filter := types.IssueFilter{Ephemeral: &ephemeral} + + results, err := store.SearchIssues(ctx, "", filter) + if err != nil { + t.Fatalf("SearchIssues: %v", err) + } + count, err := store.CountIssues(ctx, "", filter) + if err != nil { + t.Fatalf("CountIssues: %v", err) + } + if count != int64(len(results)) { + t.Errorf("CountIssues = %d but SearchIssues returned %d rows; ephemeral fall-through parity broken (GH#4387)", count, len(results)) + } + if count != 1 { + t.Errorf("CountIssues = %d, want 1 (durable ephemeral row must be counted via fall-through to the issues table)", count) + } +} + +// TestCountIssuesByGroupIncludesWisps verifies the grouped-count paths honor +// SkipWisps the same way CountIssues does, so `bd count --include-infra +// --by-*` reports the merged issues+wisps numbers instead of silently-wrong +// durable-only buckets (GH#4387). +func TestCountIssuesByGroupIncludesWisps(t *testing.T) { + store, cleanup := setupTestStore(t) + defer cleanup() + + ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second) + defer cancel() + + seedCountWispCorpus(t, ctx, store, "cg") + if err := store.AddLabel(ctx, "cg-perm-task-1", "shared", "tester"); err != nil { + t.Fatalf("label cg-perm-task-1: %v", err) + } + if err := store.AddLabel(ctx, "cg-nohist-task", "shared", "tester"); err != nil { + t.Fatalf("label cg-nohist-task: %v", err) + } + + t.Run("by_type_merged", func(t *testing.T) { + counts, err := store.CountIssuesByGroup(ctx, types.IssueFilter{}, "type") + if err != nil { + t.Fatalf("CountIssuesByGroup: %v", err) + } + // task: perm-task-1, perm-task-2, perm-tpl, nohist-task, eph-task. + if counts["task"] != 5 { + t.Errorf("merged task count = %d, want 5 (wisps tier dropped from grouped count)", counts["task"]) + } + // bug: perm-bug, nohist-bug. + if counts["bug"] != 2 { + t.Errorf("merged bug count = %d, want 2", counts["bug"]) + } + }) + + t.Run("by_type_durable_only", func(t *testing.T) { + counts, err := store.CountIssuesByGroup(ctx, types.IssueFilter{SkipWisps: true}, "type") + if err != nil { + t.Fatalf("CountIssuesByGroup: %v", err) + } + if counts["task"] != 3 { + t.Errorf("durable task count = %d, want 3 (SkipWisps must keep today's semantics)", counts["task"]) + } + if counts["bug"] != 1 { + t.Errorf("durable bug count = %d, want 1", counts["bug"]) + } + }) + + t.Run("by_status_merged", func(t *testing.T) { + counts, err := store.CountIssuesByGroup(ctx, types.IssueFilter{}, "status") + if err != nil { + t.Fatalf("CountIssuesByGroup: %v", err) + } + if counts["open"] != 6 { + t.Errorf("merged open count = %d, want 6", counts["open"]) + } + if counts["closed"] != 1 { + t.Errorf("merged closed count = %d, want 1", counts["closed"]) + } + }) + + t.Run("by_label_merged", func(t *testing.T) { + counts, err := store.CountIssuesByGroup(ctx, types.IssueFilter{}, "label") + if err != nil { + t.Fatalf("CountIssuesByGroup: %v", err) + } + // "shared" sits on one durable issue and one no_history wisp. + if counts["shared"] != 2 { + t.Errorf("merged label count = %d, want 2 (wisp labels dropped)", counts["shared"]) + } + // 5 remaining beads carry no label. + if counts["(no labels)"] != 5 { + t.Errorf("merged (no labels) count = %d, want 5", counts["(no labels)"]) + } + }) + + t.Run("by_type_ephemeral_only", func(t *testing.T) { + ephemeral := true + counts, err := store.CountIssuesByGroup(ctx, types.IssueFilter{Ephemeral: &ephemeral}, "type") + if err != nil { + t.Fatalf("CountIssuesByGroup: %v", err) + } + if counts["task"] != 1 { + t.Errorf("ephemeral task count = %d, want 1", counts["task"]) + } + if counts["bug"] != 0 { + t.Errorf("ephemeral bug count = %d, want 0", counts["bug"]) + } + }) +} + +// seedDurableEphemeralRow inserts the exact GH#4387 fall-through trap: a durable +// issues-table row carrying ephemeral=1 with no matching wisp. Normal creation +// never produces this because ephemeral/infra beads route to the wisps table on +// insert, so the row is written directly. Returns the durable ephemeral row id. +func seedDurableEphemeralRow(t *testing.T, ctx context.Context, store *DoltStore, p string) string { + t.Helper() + // A durable, non-ephemeral task that the Ephemeral=true filter must exclude, + // so the test proves the filter is applied rather than counting everything. + if err := store.CreateIssue(ctx, &types.Issue{ + ID: p + "-task-1", + Title: "durable task", + Status: types.StatusOpen, + Priority: 2, + IssueType: types.TypeTask, + }, "tester"); err != nil { + t.Fatalf("create durable task: %v", err) + } + infraID := p + "-infra-1" + if _, err := store.db.ExecContext(ctx, + "INSERT INTO issues (id, title, description, design, acceptance_criteria, notes, status, priority, issue_type, ephemeral) "+ + "VALUES ('"+infraID+"', 'durable ephemeral', '', '', '', '', 'open', 2, 'agent', 1)"); err != nil { + t.Fatalf("seed durable ephemeral issue: %v", err) + } + return infraID +} + +// TestCountIssuesByGroupEphemeralFallsThroughToDurable is the grouped-count +// sibling of TestCountIssuesEphemeralFallsThroughToDurable. Before the fix, +// CountIssuesByGroupInTx returned the wisps-only grouped counts for an +// Ephemeral=true filter, so `bd count --include-infra --by-type` reported empty +// buckets (sum 0) while the scalar Total fell through to the durable issues +// table and reported 1 — sum(groups) != Total, breaking GH#4387 cardinality +// parity. This pins that the grouped path falls through to the durable issues +// table the same way the scalar path does. +func TestCountIssuesByGroupEphemeralFallsThroughToDurable(t *testing.T) { + store, cleanup := setupTestStore(t) + defer cleanup() + + ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second) + defer cancel() + + infraID := seedDurableEphemeralRow(t, ctx, store, "eg") + + ephemeral := true + filter := types.IssueFilter{Ephemeral: &ephemeral} + + groups, err := store.CountIssuesByGroup(ctx, filter, "type") + if err != nil { + t.Fatalf("CountIssuesByGroup: %v", err) + } + count, err := store.CountIssues(ctx, "", filter) + if err != nil { + t.Fatalf("CountIssues: %v", err) + } + + sum := 0 + for _, v := range groups { + sum += v + } + if int64(sum) != count { + t.Errorf("sum(CountIssuesByGroup)=%d but CountIssues=%d; grouped ephemeral fall-through parity broken (GH#4387)", sum, count) + } + // The durable ephemeral row has issue_type='agent'; the non-ephemeral + // durable task must be excluded by the Ephemeral=true filter. + if groups["agent"] != 1 { + t.Errorf("grouped agent count = %d, want 1 (durable ephemeral row %q must fall through to the issues table)", groups["agent"], infraID) + } + if len(groups) != 1 { + t.Errorf("grouped counts had %d buckets, want 1 (only the durable ephemeral agent row); groups=%v", len(groups), groups) + } +} + +// TestSearchIssuesWithCountsEphemeralFallsThroughToDurable is the +// counts-projection sibling of the same GH#4387 fix. Before the fix, +// SearchIssuesWithCountsInTx returned nil for an Ephemeral=true filter whenever +// no matching wisp existed, so `bd search --counts --include-infra` dropped a +// durable issues-table row flagged ephemeral=1 that plain SearchIssues (and +// CountIssues) still surface. This pins parity between the counts-projection +// search and the plain search for that durable-ephemeral state. +func TestSearchIssuesWithCountsEphemeralFallsThroughToDurable(t *testing.T) { + store, cleanup := setupTestStore(t) + defer cleanup() + + ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second) + defer cancel() + + infraID := seedDurableEphemeralRow(t, ctx, store, "es") + + ephemeral := true + filter := types.IssueFilter{Ephemeral: &ephemeral} + + withCounts, err := store.SearchIssuesWithCounts(ctx, "", filter) + if err != nil { + t.Fatalf("SearchIssuesWithCounts: %v", err) + } + plain, err := store.SearchIssues(ctx, "", filter) + if err != nil { + t.Fatalf("SearchIssues: %v", err) + } + if len(withCounts) != len(plain) { + t.Errorf("SearchIssuesWithCounts returned %d rows but SearchIssues returned %d; counts-projection ephemeral fall-through parity broken (GH#4387)", len(withCounts), len(plain)) + } + if len(withCounts) != 1 { + t.Fatalf("SearchIssuesWithCounts returned %d rows, want 1 (durable ephemeral row must fall through to the issues table)", len(withCounts)) + } + if withCounts[0] == nil || withCounts[0].Issue == nil || withCounts[0].Issue.ID != infraID { + t.Errorf("SearchIssuesWithCounts returned unexpected row %+v, want %q", withCounts[0], infraID) + } +} diff --git a/internal/storage/dolt/counts.go b/internal/storage/dolt/counts.go index ba346f9e3..98a236d39 100644 --- a/internal/storage/dolt/counts.go +++ b/internal/storage/dolt/counts.go @@ -3,8 +3,6 @@ package dolt import ( "context" "database/sql" - "fmt" - "strings" "github.com/steveyegge/beads/internal/storage/issueops" "github.com/steveyegge/beads/internal/types" @@ -24,20 +22,17 @@ const depTargetExpr = "COALESCE(depends_on_issue_id, depends_on_wisp_id, depends // CountIssues returns the number of issues matching query and filter. // Filter.Limit and Filter.Offset are ignored; all other fields apply. +// Wisps-merge semantics follow SearchIssues: SkipWisps=true counts the +// durable issues table only, otherwise the wisps tier is merged in (GH#4387). func (s *DoltStore) CountIssues(ctx context.Context, query string, filter types.IssueFilter) (int64, error) { var n int64 err := s.withReadTx(ctx, func(tx *sql.Tx) error { - whereClauses, args, err := issueops.BuildIssueFilterClauses(query, filter, issueops.IssuesFilterTables) + count, err := issueops.CountIssuesInTx(ctx, tx, query, filter) if err != nil { return err } - where := "" - if len(whereClauses) > 0 { - where = " WHERE " + strings.Join(whereClauses, " AND ") - } - //nolint:gosec // table name is a static constant; placeholders are bound - q := fmt.Sprintf(`SELECT count(*) FROM issues%s`, where) - return tx.QueryRowContext(ctx, q, args...).Scan(&n) + n = int64(count) + return nil }) return n, err } diff --git a/internal/storage/embeddeddolt/counts.go b/internal/storage/embeddeddolt/counts.go index 42620682f..8d1a3aec6 100644 --- a/internal/storage/embeddeddolt/counts.go +++ b/internal/storage/embeddeddolt/counts.go @@ -5,8 +5,6 @@ package embeddeddolt import ( "context" "database/sql" - "fmt" - "strings" "github.com/steveyegge/beads/internal/storage/issueops" "github.com/steveyegge/beads/internal/types" @@ -24,20 +22,19 @@ import ( // matches issueops.DepTargetExpr on main. const depTargetExpr = "COALESCE(depends_on_issue_id, depends_on_wisp_id, depends_on_external)" +// CountIssues returns the number of issues matching query and filter. +// Filter.Limit and Filter.Offset are ignored; all other fields apply. +// Wisps-merge semantics follow SearchIssues: SkipWisps=true counts the +// durable issues table only, otherwise the wisps tier is merged in (GH#4387). func (s *EmbeddedDoltStore) CountIssues(ctx context.Context, query string, filter types.IssueFilter) (int64, error) { var n int64 err := s.withConn(ctx, false, func(tx *sql.Tx) error { - whereClauses, args, err := issueops.BuildIssueFilterClauses(query, filter, issueops.IssuesFilterTables) + count, err := issueops.CountIssuesInTx(ctx, tx, query, filter) if err != nil { return err } - where := "" - if len(whereClauses) > 0 { - where = " WHERE " + strings.Join(whereClauses, " AND ") - } - //nolint:gosec // table name is a static constant; placeholders are bound - q := fmt.Sprintf(`SELECT count(*) FROM issues%s`, where) - return tx.QueryRowContext(ctx, q, args...).Scan(&n) + n = int64(count) + return nil }) return n, err } diff --git a/internal/storage/issueops/count.go b/internal/storage/issueops/count.go index 1ff95c977..5c2ebb7b4 100644 --- a/internal/storage/issueops/count.go +++ b/internal/storage/issueops/count.go @@ -9,18 +9,37 @@ import ( "github.com/steveyegge/beads/internal/types" ) -// CountIssuesInTx counts issues matching the filter within a transaction. -// Mirrors SearchIssuesInTx's wisps-merge semantics but returns only the count. -func CountIssuesInTx(ctx context.Context, tx *sql.Tx, filter types.IssueFilter) (int, error) { +// CountIssuesInTx counts issues matching the query and filter within a +// transaction. Mirrors SearchIssuesInTx's wisps-merge semantics but returns +// only the count: ephemeral-only filters route to the wisps table, +// SkipWisps=true counts the durable issues table only, and otherwise the +// wisps count is merged in (GH#4387). +func CountIssuesInTx(ctx context.Context, tx *sql.Tx, query string, filter types.IssueFilter) (int, error) { if filter.Ephemeral != nil && *filter.Ephemeral { - count, err := countTableInTx(ctx, tx, filter, WispsFilterTables) + wispCount, err := countTableInTx(ctx, tx, query, filter, WispsFilterTables) if err != nil && !isTableNotExistError(err) { return 0, fmt.Errorf("count wisps (ephemeral filter): %w", err) } + if wispCount > 0 { + return wispCount, nil + } + // Fall through: the wisps table is missing or has no matching rows. + // SearchIssuesInTx does the same — it searches the durable issues table + // in this case (search.go "Fall through: wisps table doesn't exist or + // returned no results"). Mirroring it keeps the GH#4387 count/list parity + // contract for an infra-type filter that matches only a durable + // issues-table row flagged ephemeral=1 — a defensive parity state that + // normal creation never produces (ephemeral/infra beads route to the + // wisps table on insert), but which would otherwise be reported as 0 by + // count while list returns it. + count, err := countTableInTx(ctx, tx, query, filter, IssuesFilterTables) + if err != nil { + return 0, fmt.Errorf("count issues (ephemeral fall-through): %w", err) + } return count, nil } - count, err := countTableInTx(ctx, tx, filter, IssuesFilterTables) + count, err := countTableInTx(ctx, tx, query, filter, IssuesFilterTables) if err != nil { return 0, fmt.Errorf("count issues: %w", err) } @@ -31,8 +50,10 @@ func CountIssuesInTx(ctx context.Context, tx *sql.Tx, filter types.IssueFilter) // Merge wisps count when caller hasn't opted out (same semantics as SearchIssuesInTx). // Issues and wisps are always in separate tables (PromoteFromEphemeral deletes the - // wisps row), so the two counts don't double-count. - wispCount, wispErr := countTableInTx(ctx, tx, filter, WispsFilterTables) + // wisps row), so the two counts don't double-count. count trusts that disjoint-table + // invariant; SearchIssuesInTx is the corruption detector — it errors loudly if an ID + // appears in both tables ("id %q exists in both issues and wisps"). + wispCount, wispErr := countTableInTx(ctx, tx, query, filter, WispsFilterTables) if wispErr != nil && !isTableNotExistError(wispErr) { return 0, fmt.Errorf("count wisps (merge): %w", wispErr) } @@ -42,12 +63,61 @@ func CountIssuesInTx(ctx context.Context, tx *sql.Tx, filter types.IssueFilter) // CountIssuesByGroupInTx counts issues grouped by a field within a transaction. // groupBy must be one of: status, priority, type, assignee, label. // Returns a map of group value → count, using the same display format as bd count. +// +// Mirrors CountIssuesInTx's wisps-merge semantics: ephemeral-only filters +// route to the wisps table, SkipWisps=true counts the durable issues table +// only, and otherwise the wisps tier is merged into each group (GH#4387). func CountIssuesByGroupInTx(ctx context.Context, tx *sql.Tx, filter types.IssueFilter, groupBy string) (map[string]int, error) { - tables := IssuesFilterTables if filter.Ephemeral != nil && *filter.Ephemeral { - tables = WispsFilterTables + wispCounts, err := countGroupForTablesInTx(ctx, tx, filter, groupBy, WispsFilterTables) + if err != nil && !isTableNotExistError(err) { + return nil, fmt.Errorf("count wisps by %s (ephemeral filter): %w", groupBy, err) + } + total := 0 + for _, v := range wispCounts { + total += v + } + if total > 0 { + return wispCounts, nil + } + // Fall through: the wisps table is missing or matched no rows. Mirror + // CountIssuesInTx's scalar ephemeral fall-through (and SearchIssuesInTx) + // so grouped counts also report a durable issues-table row flagged + // ephemeral=1. Without this the scalar Total (which falls through) would + // disagree with the sum of the grouped buckets (wisps-only), breaking + // the GH#4387 count/list cardinality parity for `bd count + // --include-infra --by-*`. + counts, err := countGroupForTablesInTx(ctx, tx, filter, groupBy, IssuesFilterTables) + if err != nil { + return nil, fmt.Errorf("count issues by %s (ephemeral fall-through): %w", groupBy, err) + } + return counts, nil } + counts, err := countGroupForTablesInTx(ctx, tx, filter, groupBy, IssuesFilterTables) + if err != nil { + return nil, err + } + + if filter.SkipWisps { + return counts, nil + } + + // Merge wisps counts when the caller hasn't opted out (same semantics as + // CountIssuesInTx / SearchIssuesInTx; the two tables never share an ID). + wispCounts, wispErr := countGroupForTablesInTx(ctx, tx, filter, groupBy, WispsFilterTables) + if wispErr != nil && !isTableNotExistError(wispErr) { + return nil, fmt.Errorf("count wisps by %s (merge): %w", groupBy, wispErr) + } + for k, v := range wispCounts { + counts[k] += v + } + return counts, nil +} + +// countGroupForTablesInTx runs a grouped count against one table set +// (issues or wisps) and normalizes keys to bd count's display format. +func countGroupForTablesInTx(ctx context.Context, tx *sql.Tx, filter types.IssueFilter, groupBy string, tables FilterTables) (map[string]int, error) { if groupBy == "label" { return countByLabelInTx(ctx, tx, filter, tables) } @@ -85,9 +155,9 @@ func CountIssuesByGroupInTx(ctx context.Context, tx *sql.Tx, filter types.IssueF return counts, nil } -// countTableInTx runs SELECT COUNT(*) FROM WHERE . -func countTableInTx(ctx context.Context, tx *sql.Tx, filter types.IssueFilter, tables FilterTables) (int, error) { - clauses, args, err := BuildIssueFilterClauses("", filter, tables) +// countTableInTx runs SELECT COUNT(*) FROM
WHERE . +func countTableInTx(ctx context.Context, tx *sql.Tx, query string, filter types.IssueFilter, tables FilterTables) (int, error) { + clauses, args, err := BuildIssueFilterClauses(query, filter, tables) if err != nil { return 0, err } @@ -96,9 +166,9 @@ func countTableInTx(ctx context.Context, tx *sql.Tx, filter types.IssueFilter, t whereSQL = " WHERE " + strings.Join(clauses, " AND ") } //nolint:gosec // G201: tables.Main is hardcoded to "issues" or "wisps" - query := fmt.Sprintf("SELECT COUNT(*) FROM %s%s", tables.Main, whereSQL) + countSQL := fmt.Sprintf("SELECT COUNT(*) FROM %s%s", tables.Main, whereSQL) var count int - if err := tx.QueryRowContext(ctx, query, args...).Scan(&count); err != nil { + if err := tx.QueryRowContext(ctx, countSQL, args...).Scan(&count); err != nil { return 0, err } return count, nil diff --git a/internal/storage/issueops/search.go b/internal/storage/issueops/search.go index 8e05eefe7..dcaa55712 100644 --- a/internal/storage/issueops/search.go +++ b/internal/storage/issueops/search.go @@ -266,4 +266,3 @@ func hydrateIssues(ctx context.Context, tx *sql.Tx, issues []*types.Issue, table return nil } - diff --git a/internal/storage/issueops/search_counts.go b/internal/storage/issueops/search_counts.go index 5dd3a7a56..46d51be3d 100644 --- a/internal/storage/issueops/search_counts.go +++ b/internal/storage/issueops/search_counts.go @@ -21,14 +21,26 @@ func SearchIssuesWithCountsInTx(ctx context.Context, tx *sql.Tx, query string, f if probeErr != nil { return nil, fmt.Errorf("search issues with counts: ephemeral wisp probe: %w", probeErr) } - if empty || !wispDepsExist { - return nil, nil + if !empty && wispDepsExist { + wisps, err := runFilterSearchQueryInTx(ctx, tx, query, filter, WispsFilterTables, true) + if err != nil && !isTableNotExistError(err) { + return nil, err + } + if len(wisps) > 0 { + return finishSearchIssuesWithCounts(wisps, filter), nil + } } - wisps, err := runFilterSearchQueryInTx(ctx, tx, query, filter, WispsFilterTables, true) + // Fall through: the wisps tier is missing/empty or matched no rows. + // Mirror SearchIssuesInTx / CountIssuesInTx so count-projection searches + // also surface a durable issues-table row flagged ephemeral=1 instead of + // dropping it. Use the same IssuesFilterTables query the non-ephemeral + // path uses, keeping the GH#4387 count/list cardinality parity for + // searches that project counts (e.g. `bd search --counts --include-infra`). + out, err := runFilterSearchQueryInTx(ctx, tx, query, filter, IssuesFilterTables, wispDepsExist) if err != nil { return nil, err } - return finishSearchIssuesWithCounts(wisps, filter), nil + return finishSearchIssuesWithCounts(out, filter), nil } out, err := runFilterSearchQueryInTx(ctx, tx, query, filter, IssuesFilterTables, wispDepsExist) diff --git a/website/docs/cli-reference/count.md b/website/docs/cli-reference/count.md index 3271dded4..2f9227503 100644 --- a/website/docs/cli-reference/count.md +++ b/website/docs/cli-reference/count.md @@ -24,6 +24,7 @@ Examples: bd count --by-assignee # Group count by assignee bd count --by-label # Group count by label bd count --assignee alice --by-status # Count alice's issues by status + bd count --include-infra # Count issues + wisps tier (matches 'bd list --include-infra --all' cardinality) ``` @@ -46,6 +47,7 @@ bd count [flags] --desc-contains string Filter by description substring --empty-description Filter issues with empty description --id string Filter by specific issue IDs (comma-separated) + --include-infra Include infrastructure beads and the wisps tier (matches 'bd list --include-infra --all' cardinality) -l, --label strings Filter by labels (AND: must have ALL) --label-any strings Filter by labels (OR: must have AT LEAST ONE) --no-assignee Filter issues with no assignee diff --git a/website/docs/cli-reference/dep.md b/website/docs/cli-reference/dep.md index 4d8035c7f..bf75b432f 100644 --- a/website/docs/cli-reference/dep.md +++ b/website/docs/cli-reference/dep.md @@ -30,7 +30,7 @@ bd dep [issue-id] [flags] ``` -b, --blocks string Issue ID that this issue blocks (shorthand for: bd dep add ) - --no-cycle-check Skip cycle detection after adding (use for bulk wiring — run 'bd dep cycles' to verify afterwards) + --no-cycle-check Skip per-edge cycle checks for speed (bulk wiring); bulk --file adds still run one final whole-graph check before commit ``` ### bd dep add @@ -75,7 +75,7 @@ bd dep add [issue-id] [depends-on-id] [flags] --blocked-by string Issue ID that blocks the first issue (alternative to positional arg) --depends-on string Issue ID that the first issue depends on (alias for --blocked-by) --file string Read dependency edges from JSONL file, or '-' for stdin - --no-cycle-check Skip cycle detection after adding (use for bulk wiring — run 'bd dep cycles' to verify afterwards) + --no-cycle-check Skip per-edge cycle checks for speed (bulk wiring); bulk --file adds still run one final whole-graph check before commit -t, --type string Dependency type (blocks|tracks|related|parent-child|discovered-from|until|caused-by|validates|relates-to|supersedes) (default "blocks") ``` diff --git a/website/docs/cli-reference/import.md b/website/docs/cli-reference/import.md index 628990a5e..a026785c2 100644 --- a/website/docs/cli-reference/import.md +++ b/website/docs/cli-reference/import.md @@ -48,6 +48,20 @@ Timestamps (created_at, updated_at, started_at, closed_at) are preserved when present in the JSONL and otherwise filled in by the importer. The legacy "wisp" boolean is accepted as an alias for "ephemeral". +By default a row only rewrites an existing local issue when its +updated_at is strictly newer. Older rows are skipped (reported as +stale_skipped_ids) and rows with the same updated_at keep every local +column — updated_at has second granularity, so a timestamp tie can be +two distinct same-second updates, and the local row wins the tie +(reported as tie_kept_local_ids; the row's labels/comments/dependencies +still merge). The guard is also enforced inside the upsert itself, so a +local update that lands while the import is running is preserved rather +than overwritten. Existing issues that the import did rewrite are listed +with a field-level summary (updated_issues), so local state changed by +an import is visible. To deliberately restore an older snapshot, pass +--allow-stale, which imports every row even when it overwrites newer +local state. + EXAMPLES: bd import # Import from configured import.path bd import backup.jsonl # Import from a specific file @@ -56,6 +70,7 @@ EXAMPLES: cat issues.jsonl | bd import - # Pipe JSONL from another tool bd import --dry-run # Show what would be imported bd import --dedup # Skip issues with duplicate titles + bd import --allow-stale old.jsonl # Restore an older snapshot (overwrites newer local rows) bd import --json # Structured output with created and skipped IDs ``` @@ -65,6 +80,7 @@ bd import [file|-] [flags] **Flags:** ``` + --allow-stale Import rows even when older than the local issue (required to restore an older snapshot) --dedup Skip lines whose title matches an existing open issue --dry-run Show what would be imported without importing -i, --input string Read JSONL from a specific file diff --git a/website/static/llms-full.txt b/website/static/llms-full.txt index e33962637..2ffa7e766 100644 --- a/website/static/llms-full.txt +++ b/website/static/llms-full.txt @@ -4202,6 +4202,7 @@ Examples: bd count --by-assignee # Group count by assignee bd count --by-label # Group count by label bd count --assignee alice --by-status # Count alice's issues by status + bd count --include-infra # Count issues + wisps tier (matches 'bd list --include-infra --all' cardinality) ``` @@ -4224,6 +4225,7 @@ bd count [flags] --desc-contains string Filter by description substring --empty-description Filter issues with empty description --id string Filter by specific issue IDs (comma-separated) + --include-infra Include infrastructure beads and the wisps tier (matches 'bd list --include-infra --all' cardinality) -l, --label strings Filter by labels (AND: must have ALL) --label-any strings Filter by labels (OR: must have AT LEAST ONE) --no-assignee Filter issues with no assignee @@ -4454,7 +4456,7 @@ bd dep [issue-id] [flags] ``` -b, --blocks string Issue ID that this issue blocks (shorthand for: bd dep add ) - --no-cycle-check Skip cycle detection after adding (use for bulk wiring — run 'bd dep cycles' to verify afterwards) + --no-cycle-check Skip per-edge cycle checks for speed (bulk wiring); bulk --file adds still run one final whole-graph check before commit ``` ### bd dep add @@ -4499,7 +4501,7 @@ bd dep add [issue-id] [depends-on-id] [flags] --blocked-by string Issue ID that blocks the first issue (alternative to positional arg) --depends-on string Issue ID that the first issue depends on (alias for --blocked-by) --file string Read dependency edges from JSONL file, or '-' for stdin - --no-cycle-check Skip cycle detection after adding (use for bulk wiring — run 'bd dep cycles' to verify afterwards) + --no-cycle-check Skip per-edge cycle checks for speed (bulk wiring); bulk --file adds still run one final whole-graph check before commit -t, --type string Dependency type (blocks|tracks|related|parent-child|discovered-from|until|caused-by|validates|relates-to|supersedes) (default "blocks") ``` @@ -6305,6 +6307,20 @@ Timestamps (created_at, updated_at, started_at, closed_at) are preserved when present in the JSONL and otherwise filled in by the importer. The legacy "wisp" boolean is accepted as an alias for "ephemeral". +By default a row only rewrites an existing local issue when its +updated_at is strictly newer. Older rows are skipped (reported as +stale_skipped_ids) and rows with the same updated_at keep every local +column — updated_at has second granularity, so a timestamp tie can be +two distinct same-second updates, and the local row wins the tie +(reported as tie_kept_local_ids; the row's labels/comments/dependencies +still merge). The guard is also enforced inside the upsert itself, so a +local update that lands while the import is running is preserved rather +than overwritten. Existing issues that the import did rewrite are listed +with a field-level summary (updated_issues), so local state changed by +an import is visible. To deliberately restore an older snapshot, pass +--allow-stale, which imports every row even when it overwrites newer +local state. + EXAMPLES: bd import # Import from configured import.path bd import backup.jsonl # Import from a specific file @@ -6313,6 +6329,7 @@ EXAMPLES: cat issues.jsonl | bd import - # Pipe JSONL from another tool bd import --dry-run # Show what would be imported bd import --dedup # Skip issues with duplicate titles + bd import --allow-stale old.jsonl # Restore an older snapshot (overwrites newer local rows) bd import --json # Structured output with created and skipped IDs ``` @@ -6322,6 +6339,7 @@ bd import [file|-] [flags] **Flags:** ``` + --allow-stale Import rows even when older than the local issue (required to restore an older snapshot) --dedup Skip lines whose title matches an existing open issue --dry-run Show what would be imported without importing -i, --input string Read JSONL from a specific file diff --git a/website/versioned_docs/version-1.0.0/cli-reference/count.md b/website/versioned_docs/version-1.0.0/cli-reference/count.md index 3271dded4..2f9227503 100644 --- a/website/versioned_docs/version-1.0.0/cli-reference/count.md +++ b/website/versioned_docs/version-1.0.0/cli-reference/count.md @@ -24,6 +24,7 @@ Examples: bd count --by-assignee # Group count by assignee bd count --by-label # Group count by label bd count --assignee alice --by-status # Count alice's issues by status + bd count --include-infra # Count issues + wisps tier (matches 'bd list --include-infra --all' cardinality) ``` @@ -46,6 +47,7 @@ bd count [flags] --desc-contains string Filter by description substring --empty-description Filter issues with empty description --id string Filter by specific issue IDs (comma-separated) + --include-infra Include infrastructure beads and the wisps tier (matches 'bd list --include-infra --all' cardinality) -l, --label strings Filter by labels (AND: must have ALL) --label-any strings Filter by labels (OR: must have AT LEAST ONE) --no-assignee Filter issues with no assignee diff --git a/website/versioned_docs/version-1.0.0/cli-reference/dep.md b/website/versioned_docs/version-1.0.0/cli-reference/dep.md index 4d8035c7f..bf75b432f 100644 --- a/website/versioned_docs/version-1.0.0/cli-reference/dep.md +++ b/website/versioned_docs/version-1.0.0/cli-reference/dep.md @@ -30,7 +30,7 @@ bd dep [issue-id] [flags] ``` -b, --blocks string Issue ID that this issue blocks (shorthand for: bd dep add ) - --no-cycle-check Skip cycle detection after adding (use for bulk wiring — run 'bd dep cycles' to verify afterwards) + --no-cycle-check Skip per-edge cycle checks for speed (bulk wiring); bulk --file adds still run one final whole-graph check before commit ``` ### bd dep add @@ -75,7 +75,7 @@ bd dep add [issue-id] [depends-on-id] [flags] --blocked-by string Issue ID that blocks the first issue (alternative to positional arg) --depends-on string Issue ID that the first issue depends on (alias for --blocked-by) --file string Read dependency edges from JSONL file, or '-' for stdin - --no-cycle-check Skip cycle detection after adding (use for bulk wiring — run 'bd dep cycles' to verify afterwards) + --no-cycle-check Skip per-edge cycle checks for speed (bulk wiring); bulk --file adds still run one final whole-graph check before commit -t, --type string Dependency type (blocks|tracks|related|parent-child|discovered-from|until|caused-by|validates|relates-to|supersedes) (default "blocks") ``` diff --git a/website/versioned_docs/version-1.0.0/cli-reference/import.md b/website/versioned_docs/version-1.0.0/cli-reference/import.md index 628990a5e..a026785c2 100644 --- a/website/versioned_docs/version-1.0.0/cli-reference/import.md +++ b/website/versioned_docs/version-1.0.0/cli-reference/import.md @@ -48,6 +48,20 @@ Timestamps (created_at, updated_at, started_at, closed_at) are preserved when present in the JSONL and otherwise filled in by the importer. The legacy "wisp" boolean is accepted as an alias for "ephemeral". +By default a row only rewrites an existing local issue when its +updated_at is strictly newer. Older rows are skipped (reported as +stale_skipped_ids) and rows with the same updated_at keep every local +column — updated_at has second granularity, so a timestamp tie can be +two distinct same-second updates, and the local row wins the tie +(reported as tie_kept_local_ids; the row's labels/comments/dependencies +still merge). The guard is also enforced inside the upsert itself, so a +local update that lands while the import is running is preserved rather +than overwritten. Existing issues that the import did rewrite are listed +with a field-level summary (updated_issues), so local state changed by +an import is visible. To deliberately restore an older snapshot, pass +--allow-stale, which imports every row even when it overwrites newer +local state. + EXAMPLES: bd import # Import from configured import.path bd import backup.jsonl # Import from a specific file @@ -56,6 +70,7 @@ EXAMPLES: cat issues.jsonl | bd import - # Pipe JSONL from another tool bd import --dry-run # Show what would be imported bd import --dedup # Skip issues with duplicate titles + bd import --allow-stale old.jsonl # Restore an older snapshot (overwrites newer local rows) bd import --json # Structured output with created and skipped IDs ``` @@ -65,6 +80,7 @@ bd import [file|-] [flags] **Flags:** ``` + --allow-stale Import rows even when older than the local issue (required to restore an older snapshot) --dedup Skip lines whose title matches an existing open issue --dry-run Show what would be imported without importing -i, --input string Read JSONL from a specific file diff --git a/website/versioned_docs/version-1.0.4/cli-reference/count.md b/website/versioned_docs/version-1.0.4/cli-reference/count.md index 3271dded4..2f9227503 100644 --- a/website/versioned_docs/version-1.0.4/cli-reference/count.md +++ b/website/versioned_docs/version-1.0.4/cli-reference/count.md @@ -24,6 +24,7 @@ Examples: bd count --by-assignee # Group count by assignee bd count --by-label # Group count by label bd count --assignee alice --by-status # Count alice's issues by status + bd count --include-infra # Count issues + wisps tier (matches 'bd list --include-infra --all' cardinality) ``` @@ -46,6 +47,7 @@ bd count [flags] --desc-contains string Filter by description substring --empty-description Filter issues with empty description --id string Filter by specific issue IDs (comma-separated) + --include-infra Include infrastructure beads and the wisps tier (matches 'bd list --include-infra --all' cardinality) -l, --label strings Filter by labels (AND: must have ALL) --label-any strings Filter by labels (OR: must have AT LEAST ONE) --no-assignee Filter issues with no assignee diff --git a/website/versioned_docs/version-1.0.4/cli-reference/dep.md b/website/versioned_docs/version-1.0.4/cli-reference/dep.md index 4d8035c7f..bf75b432f 100644 --- a/website/versioned_docs/version-1.0.4/cli-reference/dep.md +++ b/website/versioned_docs/version-1.0.4/cli-reference/dep.md @@ -30,7 +30,7 @@ bd dep [issue-id] [flags] ``` -b, --blocks string Issue ID that this issue blocks (shorthand for: bd dep add ) - --no-cycle-check Skip cycle detection after adding (use for bulk wiring — run 'bd dep cycles' to verify afterwards) + --no-cycle-check Skip per-edge cycle checks for speed (bulk wiring); bulk --file adds still run one final whole-graph check before commit ``` ### bd dep add @@ -75,7 +75,7 @@ bd dep add [issue-id] [depends-on-id] [flags] --blocked-by string Issue ID that blocks the first issue (alternative to positional arg) --depends-on string Issue ID that the first issue depends on (alias for --blocked-by) --file string Read dependency edges from JSONL file, or '-' for stdin - --no-cycle-check Skip cycle detection after adding (use for bulk wiring — run 'bd dep cycles' to verify afterwards) + --no-cycle-check Skip per-edge cycle checks for speed (bulk wiring); bulk --file adds still run one final whole-graph check before commit -t, --type string Dependency type (blocks|tracks|related|parent-child|discovered-from|until|caused-by|validates|relates-to|supersedes) (default "blocks") ``` diff --git a/website/versioned_docs/version-1.0.4/cli-reference/import.md b/website/versioned_docs/version-1.0.4/cli-reference/import.md index 628990a5e..a026785c2 100644 --- a/website/versioned_docs/version-1.0.4/cli-reference/import.md +++ b/website/versioned_docs/version-1.0.4/cli-reference/import.md @@ -48,6 +48,20 @@ Timestamps (created_at, updated_at, started_at, closed_at) are preserved when present in the JSONL and otherwise filled in by the importer. The legacy "wisp" boolean is accepted as an alias for "ephemeral". +By default a row only rewrites an existing local issue when its +updated_at is strictly newer. Older rows are skipped (reported as +stale_skipped_ids) and rows with the same updated_at keep every local +column — updated_at has second granularity, so a timestamp tie can be +two distinct same-second updates, and the local row wins the tie +(reported as tie_kept_local_ids; the row's labels/comments/dependencies +still merge). The guard is also enforced inside the upsert itself, so a +local update that lands while the import is running is preserved rather +than overwritten. Existing issues that the import did rewrite are listed +with a field-level summary (updated_issues), so local state changed by +an import is visible. To deliberately restore an older snapshot, pass +--allow-stale, which imports every row even when it overwrites newer +local state. + EXAMPLES: bd import # Import from configured import.path bd import backup.jsonl # Import from a specific file @@ -56,6 +70,7 @@ EXAMPLES: cat issues.jsonl | bd import - # Pipe JSONL from another tool bd import --dry-run # Show what would be imported bd import --dedup # Skip issues with duplicate titles + bd import --allow-stale old.jsonl # Restore an older snapshot (overwrites newer local rows) bd import --json # Structured output with created and skipped IDs ``` @@ -65,6 +80,7 @@ bd import [file|-] [flags] **Flags:** ``` + --allow-stale Import rows even when older than the local issue (required to restore an older snapshot) --dedup Skip lines whose title matches an existing open issue --dry-run Show what would be imported without importing -i, --input string Read JSONL from a specific file diff --git a/website/versioned_docs/version-1.0.5/cli-reference/count.md b/website/versioned_docs/version-1.0.5/cli-reference/count.md index 3271dded4..2f9227503 100644 --- a/website/versioned_docs/version-1.0.5/cli-reference/count.md +++ b/website/versioned_docs/version-1.0.5/cli-reference/count.md @@ -24,6 +24,7 @@ Examples: bd count --by-assignee # Group count by assignee bd count --by-label # Group count by label bd count --assignee alice --by-status # Count alice's issues by status + bd count --include-infra # Count issues + wisps tier (matches 'bd list --include-infra --all' cardinality) ``` @@ -46,6 +47,7 @@ bd count [flags] --desc-contains string Filter by description substring --empty-description Filter issues with empty description --id string Filter by specific issue IDs (comma-separated) + --include-infra Include infrastructure beads and the wisps tier (matches 'bd list --include-infra --all' cardinality) -l, --label strings Filter by labels (AND: must have ALL) --label-any strings Filter by labels (OR: must have AT LEAST ONE) --no-assignee Filter issues with no assignee diff --git a/website/versioned_docs/version-1.0.5/cli-reference/dep.md b/website/versioned_docs/version-1.0.5/cli-reference/dep.md index 4d8035c7f..bf75b432f 100644 --- a/website/versioned_docs/version-1.0.5/cli-reference/dep.md +++ b/website/versioned_docs/version-1.0.5/cli-reference/dep.md @@ -30,7 +30,7 @@ bd dep [issue-id] [flags] ``` -b, --blocks string Issue ID that this issue blocks (shorthand for: bd dep add ) - --no-cycle-check Skip cycle detection after adding (use for bulk wiring — run 'bd dep cycles' to verify afterwards) + --no-cycle-check Skip per-edge cycle checks for speed (bulk wiring); bulk --file adds still run one final whole-graph check before commit ``` ### bd dep add @@ -75,7 +75,7 @@ bd dep add [issue-id] [depends-on-id] [flags] --blocked-by string Issue ID that blocks the first issue (alternative to positional arg) --depends-on string Issue ID that the first issue depends on (alias for --blocked-by) --file string Read dependency edges from JSONL file, or '-' for stdin - --no-cycle-check Skip cycle detection after adding (use for bulk wiring — run 'bd dep cycles' to verify afterwards) + --no-cycle-check Skip per-edge cycle checks for speed (bulk wiring); bulk --file adds still run one final whole-graph check before commit -t, --type string Dependency type (blocks|tracks|related|parent-child|discovered-from|until|caused-by|validates|relates-to|supersedes) (default "blocks") ``` diff --git a/website/versioned_docs/version-1.0.5/cli-reference/import.md b/website/versioned_docs/version-1.0.5/cli-reference/import.md index 628990a5e..a026785c2 100644 --- a/website/versioned_docs/version-1.0.5/cli-reference/import.md +++ b/website/versioned_docs/version-1.0.5/cli-reference/import.md @@ -48,6 +48,20 @@ Timestamps (created_at, updated_at, started_at, closed_at) are preserved when present in the JSONL and otherwise filled in by the importer. The legacy "wisp" boolean is accepted as an alias for "ephemeral". +By default a row only rewrites an existing local issue when its +updated_at is strictly newer. Older rows are skipped (reported as +stale_skipped_ids) and rows with the same updated_at keep every local +column — updated_at has second granularity, so a timestamp tie can be +two distinct same-second updates, and the local row wins the tie +(reported as tie_kept_local_ids; the row's labels/comments/dependencies +still merge). The guard is also enforced inside the upsert itself, so a +local update that lands while the import is running is preserved rather +than overwritten. Existing issues that the import did rewrite are listed +with a field-level summary (updated_issues), so local state changed by +an import is visible. To deliberately restore an older snapshot, pass +--allow-stale, which imports every row even when it overwrites newer +local state. + EXAMPLES: bd import # Import from configured import.path bd import backup.jsonl # Import from a specific file @@ -56,6 +70,7 @@ EXAMPLES: cat issues.jsonl | bd import - # Pipe JSONL from another tool bd import --dry-run # Show what would be imported bd import --dedup # Skip issues with duplicate titles + bd import --allow-stale old.jsonl # Restore an older snapshot (overwrites newer local rows) bd import --json # Structured output with created and skipped IDs ``` @@ -65,6 +80,7 @@ bd import [file|-] [flags] **Flags:** ``` + --allow-stale Import rows even when older than the local issue (required to restore an older snapshot) --dedup Skip lines whose title matches an existing open issue --dry-run Show what would be imported without importing -i, --input string Read JSONL from a specific file