[JacobStephens2]

Summary

The Claim now handles its whole lifecycle. The Run makes it, then hands it the goal the run reached, or none for a Failed run. The Claim decides what that means.

 run
-  let claim = claim::make(issue)
+  let claim = claim::make(issue, launch)
   let outcome = run_in_worktree(..)
-  match outcome
-    Merged      => claim.remove_if_closed()
-    ReadyForReview => {}
-    Failed      => claim.release_if_nothing_on_origin(launch)
+  claim.end(outcome.ok().map(goal))

src/claim.rs
├── make / Claim::end       # public interface: make it, end it once
├── Claimed                 # the rules: label, remove if closed, release if nothing on origin
├── retry_if_interrupted    # "an interrupt doesn't stop it", asked through the seam
├── trait Outside           # labels, state, started on origin, apply Edit, interrupted?, step, warn
├── OnGitHub                # production adapter: gh, branch::started, interrupt, progress
└── in_memory::InMemory     # test fake: labels, open, started, interrupted, failing reads/edits

Progress lines, warnings and the requests sent are unchanged.

Evidence

• Before: the Claim's rules had no unit tests. Every rule was checked by running a whole Run against the fake gh, git and claude, and the retry while interrupted could only be reached by sending a signal to a real process.
  After: 19 unit tests in claim::tests use the in-memory fake and cover making the Claim, ending it as Merged, Ready for review and Failed, the warnings with their commands to run by hand, and a failed step tried once more while interrupted. For example:

  release fails once, interrupted
    => Started, Labels, Step, Edit(fails), Interrupted, Started, Labels, Step, Edit
    => labels back to [ready-for-agent], no warning
  

  This PR removes 15 end-to-end tests that only checked a Claim rule. One wiring test stays for each path in the issue's list.
  cargo test (32 suites, all pass), cargo clippy --all-targets and cargo fmt --check are all clean.

Merge Danger

Door: two-way

This is a refactor inside one module plus its single caller. Nothing persistent or user-facing changes.

Blast Radius: labels

If the wiring were wrong, issue labels (in-progress, ready-for-agent) could be left wrong at the end of a Run or a Spec run. The wiring tests that remain cover making, keeping, releasing and removing the Claim.

Unaddressed findings

Standards

• Duplicated Code (retry_if_interrupted repeats interrupt::retry_if_interrupted): the Claim's copy has to ask the seam whether the run was interrupted, and it passes the same &mut outside to both the step and that question. Sharing one helper would mean closures that borrow the seam twice, while the helper itself is only two lines. delivery.rs keeps the original.
• Primitive Obsession (Option<Goal>, None = Failed): the issue chose this on purpose: "The outcome is given as the Goal reached, or none for a Failed run."
• Middle Man (Claim::end wraps Claimed::end): this split lets unit tests use Claimed without a Git for the Launch directory. Claim only binds the production adapter.
• Fake's fail_if uses only the first entry per call: this is test-only and no test sets the same call to fail twice.

Spec

• Merge path keeps two end-to-end tests: an_issue_github_closed_after_the_merge_has_its_claim_removed_too mainly checks that the Delivery skips gh issue close on an issue GitHub has already closed. That is not a Claim rule, so it stays.
• Tests that create the in-progress label in the repository stay in fresh_run.rs: they check how Edit adds a missing label to the repository, which is a labels rule rather than a Claim rule, and the fake can't reach it.

Closes #382

🤖 Generated with Claude Code