beads/cmd/bd/close.go
Julian Knutsen d801ec43dc
feat(issueops): put every issue capability behind one library surface
Beads had two implementations of most issue verbs: one for the direct route
(the CLI talking to a store it opened itself) and one for the proxied-server
route (the CLI talking through a unit of work over a running Dolt server).
They drifted — different commit messages, different transaction boundaries,
different refusals, occasionally different answers.

Seven role interfaces now live in the leaf package issueops: Lifecycle,
Reader, ReadyClaimer, BatchCloser, DependencyEditor, Commenter and Relations.
Each is reached only through a store accessor, never a constructor, because
the accessor is where the hook and telemetry decorators add their layers.
Three implementations back every role — dolt, embeddeddolt, and the
unit-of-work provider the proxied route uses. Both routes call the same role
for close, dep add/remove/list, comment, ready --claim and update.

A depguard rule (httpapi-domain-boundary) denies internal/storage/domain from
internal/httpapi, so a handler cannot reach uw.IssueUseCase() past the roles
and open a second front door one lint-clean commit at a time.

Behaviour users will notice, all in the CHANGELOG:
  - bd close a b c is one Dolt commit, not three, and --claim-next moved
    inside that transaction so it fires only when something landed
  - the open-children guard moved into the transaction and its hand-rolled
    cmd/bd copy is gone, removing a read-then-write window that made
    bd close <child> <parent> depend on argument order
  - bd dep add --file honours deferred version commit
  - embedded bd comment writes the role's message and author
  - dep verb commit messages are the role's on the direct route

Wisp-sourced dependency edges are restored. Moving bd dep add onto the role
had pinned an edge's SOURCE to the issues plane, and the two routes did not
even fail alike: direct refused with "issue <id> not found", proxied threw an
fk_dep_issue violation. The comment justifying the pin claimed the issues
plane was "the only one its unit-of-work sibling can reach" — that was false;
domain.DependencyUseCase declared a full set of wisp twins with no production
caller. All three implementations now route per edge by the edge's own
source. A mixed request stays one transaction: parent-child-first ordering
and the whole-graph cycle gate span both planes, and a refusal rolls back
both. Behind the role, three bulk add verbs collapsed into one source-routed
AddDependencies, so no plane-pinned variant is left to reach for by mistake.

Six Provenance fields with no production caller were deleted rather than
wired — CloseRequest, CloseBatchRequest, ClaimNextRequest, AddCommentRequest,
AddDependenciesRequest, RemoveDependencyRequest. Each role already composes an
id-bearing message, so a caller could only restate the default and make it
unreachable from production. Two are not caller-settable even in principle:
CloseBatchCommitMessage names what LANDED and ClaimNextCommitMessage names the
id the claim WON. UpdateRequest and ReopenRequest keep theirs; commit messages
users see are unchanged.

Verified: build, vet and gofmt clean; golangci-lint 0 issues; protocol corpus
byte-identical under BEADS_PROTOCOL_REQUIRE_DOLT=1; all twelve
DependencyEditor conformance wirings green (four contract functions against
each implementation); TestEmbeddedDepAddWispSource runs bd dep add <wisp-id>
at the front door and was demonstrated RED against the pinned routing first.
Three internal/storage/dolt failures reproduce on pristine origin/main.

Known gaps are enumerated in the PR description rather than left to be found:
comment listing is on no role, bd dep tree and bd dep cycles have no role,
bd create and bd reopen are on Lifecycle only on the direct route, per-edge
line attribution is lost in bd dep add --file, multi-store bd close
--claim-next rides only the first store's batch, and the is_blocked staging gap
(bd-2y9ke, predates this change). Seven of the eight role interfaces now have a
shared conformance contract in backend/conformance, run at all three
implementations; main's Claimer, added in parallel by #5334, is the eighth and
has none yet.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
2026-08-04 12:27:56 -07:00

746 lines
27 KiB
Go

package main
import (
"context"
"fmt"
"os"
"strings"
"time"
"github.com/spf13/cobra"
"github.com/steveyegge/beads/internal/audit"
"github.com/steveyegge/beads/internal/config"
"github.com/steveyegge/beads/internal/debug"
"github.com/steveyegge/beads/internal/metrics"
"github.com/steveyegge/beads/internal/storage"
"github.com/steveyegge/beads/internal/types"
"github.com/steveyegge/beads/internal/ui"
"github.com/steveyegge/beads/internal/validation"
"github.com/steveyegge/beads/issueops"
)
var closeCmd = &cobra.Command{
Use: "close [id...]",
Aliases: []string{"done"},
GroupID: "issues",
Short: "Close one or more issues",
Long: `Close one or more issues.
If no issue ID is provided, closes the last touched issue (from most recent
create, update, show, or close operation).
When closing multiple issues, provide one --reason for all IDs or repeat
--reason once per ID. Reasons map positionally: the first --reason applies
to the first ID, the second --reason to the second ID, regardless of where
the flags appear in the command line.`,
Args: cobra.MinimumNArgs(0),
SilenceUsage: true,
SilenceErrors: true,
RunE: func(cmd *cobra.Command, args []string) error {
CheckReadonly("close")
evt := metrics.NewCommandEvent("close")
defer func() {
if c := metrics.Global(); c != nil {
c.CloseEventAndAdd(evt)
}
}()
if usesProxiedServer() {
return runCloseProxiedServer(cmd, rootCtx, args)
}
// If no IDs provided, use last touched issue
if len(args) == 0 {
lastTouched := GetLastTouchedID()
if lastTouched == "" {
return HandleErrorRespectJSON("no issue ID provided and no last touched issue")
}
args = []string{lastTouched}
}
reasons, updatedArgs, err := resolveCloseReasons(cmd, args)
if err != nil {
return HandleErrorRespectJSON("%v", err)
}
args = updatedArgs
if err := validateCloseReasons(reasons); err != nil {
return HandleErrorRespectJSON("%v", err)
}
force, _ := cmd.Flags().GetBool("force")
continueFlag, _ := cmd.Flags().GetBool("continue")
noAuto, _ := cmd.Flags().GetBool("no-auto")
suggestNext, _ := cmd.Flags().GetBool("suggest-next")
claimNext, _ := cmd.Flags().GetBool("claim-next")
session, _ := cmd.Flags().GetString("session")
if session == "" {
session = os.Getenv("CLAUDE_SESSION_ID")
}
ctx := rootCtx
opsCtx, err := issueOpsContext(ctx)
if err != nil {
return HandleErrorRespectJSON("%v", err)
}
if continueFlag && len(args) > 1 {
return HandleErrorRespectJSON("--continue only works when closing a single issue")
}
if suggestNext && len(args) > 1 {
return HandleErrorRespectJSON("--suggest-next only works when closing a single issue")
}
results, cleanup, resolveErr := resolveCloseTargets(ctx, store, args)
defer cleanup()
if resolveErr != nil {
return HandleErrorRespectJSON("%v", resolveErr)
}
resolvedIDs := make([]string, 0, len(results))
for _, r := range results {
resolvedIDs = append(resolvedIDs, r.ResolvedID)
}
// Track which stores were mutated so routed closes can commit before
// cleanup closes the routed handle. Deduped by pointer.
mutatedStores := map[storage.DoltStorage][]string{}
// Pick a store for post-close work (--suggest-next, --continue, --claim-next).
// All three flags are documented as single-issue paths; for the multi-id case
// we use the first resolved ID's store, which matches the common case where
// every ID routes to the same place.
postCloseStore := store
if len(results) > 0 && results[0].Store != nil {
postCloseStore = results[0].Store
}
// THE BATCH. The CLI's own close policy runs first and read-only, then
// every id it passed goes to the BatchCloser role as one request per
// store: one transaction, one Dolt commit over N ids, and an id the
// batch refuses skipped while the survivors commit. --claim-next rides
// inside that transaction, and the engine's own is_blocked guard runs
// there too (GH#962), so there is no read-then-write TOCTOU window
// between the check and the close.
plan := closeDirectPreflight(results, resolvedIDs, reasons, force)
outcomes, claimedNext := closeDirectRun(opsCtx, closeDirectBatches(plan.items), len(resolvedIDs),
session, force, postCloseStore, closeClaimNextRequest(claimNext, continueFlag))
// Report and follow up on every argument, in the order it was typed.
closedIssues := []*types.Issue{}
closedCount := 0
alreadyClosed := 0
firstSettledID := ""
for i, id := range resolvedIDs {
res := outcomes[i]
if res == nil {
// The CLI's own close policy refused this argument, so the
// batch never saw it.
fmt.Fprintln(os.Stderr, plan.refusals[i])
continue
}
if res.Err != nil {
fmt.Fprintln(os.Stderr, closeDirectRefusal(id, res.Err))
continue
}
// Open children only survive to here when --force waived the
// engine's refusal. Say so, so orphaned children are never silent.
if res.OpenChildren > 0 {
fmt.Fprintf(os.Stderr, "warning: closing %s with %d open child issue(s) still active\n", id, res.OpenChildren)
}
activeStore := results[i].Store
reason := reasonForCloseIndex(reasons, i)
// Pre-close snapshot, for the audit entry's old status and the
// success line's title.
issue := results[i].Issue
if !res.Changed {
// Already closed: an idempotent no-op on the step's stored state. The
// old CloseIssue path also returned nil here and still reported the
// (already-closed) issue, so keep OUTPUT parity via the shared display
// block below — the issue stays in --json output and the text report
// exactly as before. Suppress the step's own real-state-change side
// effects (the audit entry, so no spurious closed→closed; the
// closedCount bump; step-level pending-commit tracking, since the step
// write itself is a no-op), but still count the command as a successful
// close for its retry-safe post-close contracts (last-touched,
// --continue, --suggest-next, --claim-next) via alreadyClosed below.
// Exit stays 0.
alreadyClosed++
// Molecule auto-close is itself a retry-safe, fully state-derived
// post-close contract, so it must replay on an already-closed re-close
// just like the contracts above. If the final step's real close
// persisted but its molecule auto-close did not (a crash between the two
// commits, or the root CloseIssue failing with only a warning), this
// idempotent re-close is the ONLY thing that re-drives it — otherwise the
// molecule root is stranded open forever. autoCloseCompletedMolecule
// early-returns unless the root is genuinely open, auto-close-eligible,
// and complete, so it heals only that case and reintroduces none of the
// suppressed real-close side effects (no audit, no closed→closed on the
// step). Register the store when it actually closed the root so the
// pending-commit sweep persists it — closedCount==0 would not commit.
if molID := autoCloseCompletedMolecule(ctx, activeStore, id, actor, session); molID != "" {
mutatedStores[activeStore] = append(mutatedStores[activeStore], molID)
}
} else {
mutatedStores[activeStore] = append(mutatedStores[activeStore], id)
// Audit log the close (survives Dolt GC flatten)
oldStatus := "open"
if issue != nil {
oldStatus = string(issue.Status)
}
audit.LogFieldChange(id, "status", oldStatus, "closed", actor, reason)
closedCount++
// Auto-close parent molecule if all steps are now complete.
// Runs against the same store the step was closed in.
autoCloseCompletedMolecule(ctx, activeStore, id, actor, session)
}
// First id this command settled as closed — a real close or an
// already-closed no-op both "touch" it. Drives the retry-safe last-touched
// contract below so a re-close still points default-target commands at it.
if firstSettledID == "" {
firstSettledID = id
}
// The operation's own post-state snapshot is what gets reported. A
// real close and an idempotent no-op both report the closed issue
// here, matching the historical output shape. Dependency records are
// dropped from it because `bd close` has never printed them: the
// re-read this replaced did not hydrate them either.
closedIssue := res.Issue
if closedIssue != nil {
closedIssue.Dependencies = nil
}
if jsonOutput {
if closedIssue != nil {
closedIssues = append(closedIssues, closedIssue)
}
} else {
debug.PrintNormal("%s Closed %s: %s\n", ui.RenderPass("✓"), formatFeedbackID(id, issueTitleOrEmpty(issue)), reason)
}
}
// A close command "succeeds" for its user-facing, retry-safe contracts when it
// settled the target as closed — whether it performed the real state change
// (closedCount) or confirmed an already-closed idempotent no-op
// (alreadyClosed). last-touched, --continue, --suggest-next, and --claim-next
// all re-derive their result from current state, so they must replay on an
// already-closed retry; `bd close --continue` in particular is a workflow-
// advancement trigger a crash/retry has to be able to re-drive. The real
// close-mutation side effects (audit, event, molecule auto-close) stay
// suppressed for an already-closed no-op via the `else` branch above; the
// pending-commit sweep is gated on mutatedStores, which a post-close claim
// also populates.
closedForCommand := closedCount > 0 || alreadyClosed > 0
// Record the closed issue as last-touched so `bd close` honors its own
// documented contract (the "last touched issue ... from create, update,
// show, or close" behavior) and downstream write-marker consumers see the
// close (GH#3965). Mirrors bd update's firstUpdatedID pattern. A later
// --claim-next overwrites this with the claimed issue (the newer touch).
if closedForCommand {
SetLastTouchedID(firstSettledID)
}
if suggestNext && len(resolvedIDs) == 1 && closedForCommand {
unblocked, err := postCloseStore.GetNewlyUnblockedByClose(ctx, resolvedIDs[0])
if err == nil && len(unblocked) > 0 {
if jsonOutput {
return outputJSON(map[string]interface{}{
"closed": closedIssues,
"unblocked": unblocked,
})
}
fmt.Printf("\nNewly unblocked:\n")
for _, issue := range unblocked {
fmt.Printf(" • %s (P%d)\n", formatFeedbackID(issue.ID, issue.Title), issue.Priority)
}
}
}
if continueFlag && len(resolvedIDs) == 1 && closedForCommand {
autoClaim := !noAuto
result, err := AdvanceToNextStep(ctx, newStandaloneStoreMolWriter(postCloseStore), resolvedIDs[0], autoClaim, actor)
if err != nil {
fmt.Fprintf(os.Stderr, "Warning: could not advance to next step: %v\n", err)
} else if result != nil {
// Mirror --claim-next: when AdvanceToNextStep auto-claims the
// next step, update .beads/last-touched so subsequent default-
// target commands (e.g. bare `bd update`, `bd close`) target
// it. Without this, last-touched stays pointed at the just-
// closed step. See gastownhall/beads#3769.
if result.AutoAdvanced && result.NextStep != nil {
SetLastTouchedID(result.NextStep.ID)
// The auto-claim mutated postCloseStore's working set. Register it
// so the pending-commit sweep below persists the advance — parity
// with --claim-next, and required when the close itself was an
// already-closed no-op (closedCount==0 wouldn't otherwise commit).
// Same-pointer key dedupes with the closed store on a real close.
mutatedStores[postCloseStore] = append(mutatedStores[postCloseStore], result.NextStep.ID)
}
if jsonOutput {
return outputJSON(map[string]interface{}{
"closed": closedIssues,
"continue": result,
})
}
PrintContinueResult(result)
}
}
// Report --claim-next. The claim itself already happened, inside the
// batch's own transaction and only when something landed, so what is
// left here is the report and the last-touched hand-off. Register the
// claimed store anyway: the batch committed the claim, but the sweep
// below still has to name it if a molecule auto-close made the store
// dirty again.
var claimedNextIssue *types.Issue
if claimNext && closedForCommand && !continueFlag {
if claimedNext != nil {
claimedNextIssue = claimedNext.Issue
mutatedStores[postCloseStore] = append(mutatedStores[postCloseStore], claimedNextIssue.ID)
if !jsonOutput {
debug.PrintNormal("%s Auto-claimed next ready issue: %s (P%d)\n", ui.RenderPass("✓"), formatFeedbackID(claimedNextIssue.ID, claimedNextIssue.Title), claimedNextIssue.Priority)
}
SetLastTouchedID(claimedNextIssue.ID)
} else if !jsonOutput {
debug.PrintNormal("\n%s No ready issues available to claim.\n", ui.RenderWarn("✨"))
}
}
if jsonOutput && len(closedIssues) > 0 {
if claimedNextIssue != nil {
if err := outputJSON(map[string]interface{}{
"closed": closedIssues,
"claimed": claimedNextIssue,
}); err != nil {
return err
}
} else {
if err := outputJSON(closedIssues); err != nil {
return err
}
}
}
// Commit whenever a store was actually mutated — a real close, an auto-claimed
// --continue advance, or a --claim-next claim. Gating on mutatedStores rather
// than closedCount matters for an already-closed re-close that still advanced
// or claimed via a retry-safe post-close flag: the mutation lives in the
// working set and must be persisted, not left for a later write to sweep. For
// existing paths this is equivalent to closedCount>0 (only real closes and
// post-close claims populate mutatedStores). Commit is a no-op if there is
// genuinely nothing pending.
if len(mutatedStores) > 0 {
for s, ids := range mutatedStores {
if s == nil {
continue
}
if err := commitPendingIfEmbedded(ctx, s, actor, doltAutoCommitParams{
Command: "close",
IssueIDs: ids,
}); err != nil {
return HandleErrorRespectJSON("failed to commit: %v", err)
}
}
}
totalAttempted := len(resolvedIDs)
if totalAttempted > 0 && closedCount == 0 && alreadyClosed == 0 {
return SilentExit()
}
return nil
},
}
func init() {
registerCloseReasonFlag(closeCmd)
closeCmd.Flags().String("resolution", "", "Alias for --reason (Jira CLI convention)")
_ = closeCmd.Flags().MarkHidden("resolution") // Hidden alias for agent/CLI ergonomics
closeCmd.Flags().StringP("message", "m", "", "Alias for --reason (git commit convention)")
_ = closeCmd.Flags().MarkHidden("message") // Hidden alias for agent/CLI ergonomics
closeCmd.Flags().String("comment", "", "Alias for --reason")
_ = closeCmd.Flags().MarkHidden("comment") // Hidden alias for agent/CLI ergonomics
closeCmd.Flags().String("reason-file", "", "Read close reason from file (use - for stdin)")
closeCmd.Flags().BoolP("force", "f", false, "Force close pinned issues or unsatisfied gates")
closeCmd.Flags().Bool("continue", false, "Auto-advance to next step in molecule")
closeCmd.Flags().Bool("no-auto", false, "With --continue, show next step but don't claim it")
closeCmd.Flags().Bool("suggest-next", false, "Show newly unblocked issues after closing")
closeCmd.Flags().Bool("claim-next", false, "Automatically claim the next highest priority available issue")
closeCmd.Flags().String("session", "", "Claude Code session ID (or set CLAUDE_SESSION_ID env var)")
closeCmd.ValidArgsFunction = issueIDCompletion
rootCmd.AddCommand(closeCmd)
}
type closeReasonFlagValue struct {
values []string
}
func registerCloseReasonFlag(cmd *cobra.Command) {
cmd.Flags().VarP(&closeReasonFlagValue{}, "reason", "r", "Reason for closing")
}
func (v *closeReasonFlagValue) Set(s string) error {
v.values = append(v.values, s)
return nil
}
func (v *closeReasonFlagValue) String() string {
if len(v.values) == 0 {
return ""
}
return v.values[len(v.values)-1]
}
func (v *closeReasonFlagValue) Type() string {
return "string"
}
func (v *closeReasonFlagValue) Values() []string {
out := make([]string, len(v.values))
copy(out, v.values)
return out
}
func resolveCloseReasons(cmd *cobra.Command, args []string) ([]string, []string, error) {
reasons, err := collectCloseReasonFlags(cmd)
if err != nil {
return nil, args, err
}
if fileReason, ok, err := resolveReasonFile(cmd, len(reasons) > 0); err != nil {
return nil, args, err
} else if ok {
reasons = []string{fileReason}
}
// Desire-path: "bd done <id> <message>" treats last positional arg as reason
// when no reason flag was explicitly provided (hq-pe8ce)
if len(reasons) == 0 && cmd.CalledAs() == "done" && len(args) >= 2 {
reasons = []string{args[len(args)-1]}
args = args[:len(args)-1]
}
if len(reasons) == 0 {
reasons = []string{"Closed"}
}
if len(reasons) > 1 && len(reasons) != len(args) {
return nil, args, fmt.Errorf("got %d close reasons for %d issue IDs; provide exactly one shared reason or one reason per issue", len(reasons), len(args))
}
return reasons, args, nil
}
func collectCloseReasonFlags(cmd *cobra.Command) ([]string, error) {
if flag := cmd.Flags().Lookup("reason"); flag != nil {
if v, ok := flag.Value.(interface{ Values() []string }); ok {
if reasons := nonEmptyCloseReasons(v.Values()); len(reasons) > 0 {
return reasons, nil
}
}
}
for _, name := range []string{"resolution", "message", "comment"} {
reason, err := cmd.Flags().GetString(name)
if err != nil {
return nil, err
}
if reason != "" {
return []string{reason}, nil
}
}
return nil, nil
}
func nonEmptyCloseReasons(reasons []string) []string {
out := make([]string, 0, len(reasons))
for _, reason := range reasons {
if reason != "" {
out = append(out, reason)
}
}
return out
}
func reasonForCloseIndex(reasons []string, i int) string {
if len(reasons) == 1 {
return reasons[0]
}
return reasons[i]
}
// closeClaimNextRequest is --claim-next as the batch expresses it. BOTH of
// `bd close`'s routes build it here, so the claim asks one question no matter
// which door it came through.
//
// The role runs it inside the closes' transaction and only when at least one
// item landed, which is the rule each route used to enforce by hand; --continue
// still wins, because the two flags have always been mutually exclusive here.
//
// It asks for priority order and no limit. The old two-step read the single top
// ready row and warned if that one row happened to be taken; the role's claim
// walks the ready order and takes the first row it can win, so a race with
// another agent now claims the next candidate instead of claiming nothing.
func closeClaimNextRequest(claimNext, continueOn bool) *issueops.ReadyRequest {
if !claimNext || continueOn {
return nil
}
return &issueops.ReadyRequest{Sort: string(types.SortPolicyPriority)}
}
func validateCloseReasons(reasons []string) error {
closeValidation := config.GetString("validation.on-close")
if closeValidation != "error" && closeValidation != "warn" {
return nil
}
for _, reason := range reasons {
if err := validation.ValidateCloseReason(reason); err != nil {
if closeValidation == "error" {
return err
}
// warn mode: print warning but proceed
fmt.Fprintf(os.Stderr, "%s %v\n", ui.RenderWarn("⚠"), err)
}
}
return nil
}
// isMachineCheckableGate returns true if the issue is a gate with a machine-checkable await type.
func isMachineCheckableGate(issue *types.Issue) bool {
if issue == nil || issue.IssueType != "gate" {
return false
}
switch {
case strings.HasPrefix(issue.AwaitType, "gh:pr"):
return true
case strings.HasPrefix(issue.AwaitType, "gh:run"):
return true
case issue.AwaitType == "timer":
return true
case issue.AwaitType == "bead":
return true
default:
return false
}
}
// checkGateSatisfaction checks whether a gate issue's condition is satisfied.
// Returns nil if the gate is satisfied (or not a machine-checkable gate), or an error describing why it cannot be closed.
func checkGateSatisfaction(issue *types.Issue) error {
if !isMachineCheckableGate(issue) {
return nil
}
var resolved bool
var escalated bool
var reason string
var err error
switch {
case strings.HasPrefix(issue.AwaitType, "gh:run"):
resolved, escalated, reason, err = checkGHRun(issue, func(gateID, runID string) error { return updateGateAwaitIDFunc(nil, gateID, runID) })
case strings.HasPrefix(issue.AwaitType, "gh:pr"):
resolved, escalated, reason, err = checkGHPR(issue)
case issue.AwaitType == "timer":
resolved, escalated, reason, err = checkTimer(issue, time.Now())
case issue.AwaitType == "bead":
resolved, reason = checkBeadGate(rootCtx, store, issue.AwaitID)
if resolved {
return nil
}
return fmt.Errorf("gate condition not satisfied: %s (use --force to override)", reason)
}
if err != nil {
// If we can't check the condition, allow close with a warning
fmt.Fprintf(os.Stderr, "Warning: could not evaluate gate condition: %v\n", err)
return nil
}
if resolved {
return nil
}
if escalated {
return fmt.Errorf("gate condition not satisfied: %s (use --force to override)", reason)
}
return fmt.Errorf("gate condition not satisfied: %s (use --force to override)", reason)
}
// autoCloseCompletedMolecule checks if closing a step completed an auto-closing
// parent molecule, and if so, closes the molecule root. Ordinary epics remain
// open when all children finish so they can become explicitly close-eligible
// instead of being closed as a side effect of the final child close. It returns
// the molecule root ID when it actually closed the root (and "" otherwise) so a
// caller that did not otherwise mutate the store — an already-closed re-close in
// particular — can register the store for the pending-commit sweep. The check is
// fully state-derived and idempotent: it early-returns unless the root is open,
// auto-close-eligible, and has all steps complete, so re-invoking it never
// double-closes or reintroduces side effects.
func autoCloseCompletedMolecule(ctx context.Context, s storage.DoltStorage, closedStepID, actorName, session string) string {
moleculeID := findParentMolecule(ctx, s, closedStepID)
if moleculeID == "" {
return "" // Not part of a molecule
}
// Check if molecule root is already closed
root, err := s.GetIssue(ctx, moleculeID)
if err != nil || root == nil || root.Status == types.StatusClosed || !shouldAutoCloseCompletedRoot(root) {
return ""
}
// Load progress to check completion
progress, err := getMoleculeProgress(ctx, s, moleculeID)
if err != nil {
return "" // Best effort — don't fail the close
}
if progress.Completed < progress.Total {
return "" // Not all steps complete yet
}
// All steps complete — auto-close the molecule root
if err := s.CloseIssue(ctx, moleculeID, "all steps complete", actorName, session); err != nil {
fmt.Fprintf(os.Stderr, "Warning: could not auto-close completed molecule %s: %v\n", moleculeID, err)
return ""
}
if !jsonOutput {
debug.PrintNormal("%s Auto-closed completed molecule %s\n", ui.RenderPass("✓"), formatFeedbackID(moleculeID, root.Title))
}
return moleculeID
}
// shouldAutoCloseCompletedRoot returns true for molecule roots that should
// auto-close when their final step closes. Regular epics stay open and become
// explicit close-eligible work, while ephemeral wisps, template-driven
// molecules, and molecule-type coordination roots keep their cleanup behavior.
func shouldAutoCloseCompletedRoot(root *types.Issue) bool {
if root == nil {
return false
}
if root.IssueType == types.TypeMolecule || root.Ephemeral {
return true
}
if root.IssueType != types.TypeEpic {
return false
}
for _, label := range root.Labels {
if label == BeadsTemplateLabel {
return true
}
}
return false
}
// resolveReasonFile resolves the --reason-file flag for `bd close`.
// Returns (content, true, nil) when --reason-file was set and read successfully.
// Returns (_, false, nil) when --reason-file was not set.
// Returns an error on conflict with an existing reason, file read failure, or empty content.
// Mirrors the --body-file pattern from `bd create` so agents can pass structured close
// templates without shell-escaping hell.
func resolveReasonFile(cmd *cobra.Command, hasExistingReason bool) (string, bool, error) {
if !cmd.Flags().Changed("reason-file") {
return "", false, nil
}
if hasExistingReason {
return "", false, fmt.Errorf("cannot specify both --reason-file and --reason/--resolution/--message/--comment")
}
path, _ := cmd.Flags().GetString("reason-file")
content, err := readBodyFile(path)
if err != nil {
return "", false, fmt.Errorf("reading reason file %q: %w", path, err)
}
if strings.TrimSpace(content) == "" {
return "", false, fmt.Errorf("--reason-file %q is empty; close reason is required", path)
}
return content, true, nil
}
// resolveCloseTargets resolves a batch of partial issue IDs for `bd close`,
// preserving input order. For each ID it tries the local store first, then
// explicit prefix routing via routes.jsonl, then a shared contributor-routed
// store. This matches resolveAndGetIssueWithRouting's routing precedence.
//
// The contributor-routed handle is shared across the batch so bulk close does
// not repeatedly open the same planning store and every result has a clear store
// owner for subsequent close-time checks and writes.
//
// Each returned RoutedResult.Store points to whichever store actually owns the
// issue. The caller invokes cleanup() once when done; per-result Close() is a
// no-op for routed-via-shared-handle entries because they don't own the handle.
func resolveCloseTargets(ctx context.Context, localStore storage.DoltStorage, ids []string) ([]*RoutedResult, func(), error) {
results := make([]*RoutedResult, 0, len(ids))
var sharedRouted storage.DoltStorage
var sharedRoutedTried bool
cleanup := func() {
for _, r := range results {
r.Close()
}
if sharedRouted != nil {
_ = sharedRouted.Close()
}
}
ensureShared := func() (storage.DoltStorage, error) {
if sharedRouted != nil {
return sharedRouted, nil
}
if sharedRoutedTried {
return nil, fmt.Errorf("no auto-routed store available")
}
sharedRoutedTried = true
rs, routed, _, err := openRoutedReadStore(ctx, localStore)
if err != nil {
return nil, err
}
if !routed {
return nil, fmt.Errorf("no auto-routed store available")
}
sharedRouted = rs
return rs, nil
}
for _, id := range ids {
// Local first.
if r, err := resolveAndGetFromStore(ctx, localStore, id, false); err == nil {
results = append(results, r)
continue
} else if !isNotFoundErr(err) {
cleanup()
return nil, func() {}, fmt.Errorf("resolving ID %s: %w", id, err)
}
// 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 := resolveViaPrefixRoutingWithAccess(ctx, id, true); err == nil {
results = append(results, r)
continue
}
// Contributor auto-routing uses one shared store for the whole batch.
if rs, rerr := ensureShared(); rerr == nil {
if r, err := resolveAndGetFromStore(ctx, rs, id, true); err == nil {
// Per-id RoutedResult does not own the shared handle; cleanup() does.
results = append(results, r)
continue
}
}
cleanup()
return nil, func() {}, fmt.Errorf("resolving ID %s: no issue found matching %q", id, id)
}
return results, cleanup, nil
}