Runs: reinstating a run goes through claim exclusivity; a run claims an item once

Withdrawing a run's closure now asks docs.claim_holder, the same owner the
opening rule uses, and refuses AlreadyClaimed when another live run holds a
claim. Duplicate claims within a run are refused at validate. Tests pin the
reinstatement sequence, second-claim holders, and same-key different-content
IdentityCollision.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Meta Vens 2026-10-09 16:30:14 +02:00
commit f1a4449300
3 changed files with 95 additions and 4 deletions

View file

@ -481,6 +481,9 @@ fn run_is_well_formed(run: &PipelineRun, at: &str) -> Result<(), PipelineRefusal
if !matches!(claim.kind, PipelineKind::CutSpec | PipelineKind::Finding | PipelineKind::FollowUp) {
return Err(format_error(&format!("{at}.claims[{index}].kind"), claim.kind.name()));
}
if run.claims[..index].contains(claim) {
return Err(format_error(&format!("{at}.claims[{index}]"), &claim.id.0));
}
}
let (whole, fraction) = run.budget_usd.0.split_once('.').map_or((run.budget_usd.0.as_str(), None), |(whole, fraction)| (whole, Some(fraction)));
let digits = |text: &str| !text.is_empty() && text.bytes().all(|byte| byte.is_ascii_digit());
@ -1525,6 +1528,18 @@ mod tests {
}
}
/// A run claims an item once: a repeated claim is refused at validate.
#[test]
fn a_run_cannot_claim_one_item_twice() {
let claim = PipelineRef { kind: PipelineKind::FollowUp, id: id("follow_up", "F1") };
let other = PipelineRef { kind: PipelineKind::FollowUp, id: id("follow_up", "F2") };
let mut run = run_sample();
run.claims = vec![claim.clone(), other.clone()];
assert_eq!(PipelineDocument::Run(run.clone()).validate(), Ok(()));
run.claims = vec![claim.clone(), other, claim];
assert!(matches!(PipelineDocument::Run(run).validate(), Err(PipelineRefusal::InvalidFormat { field, .. }) if field == "run.claims[2]"));
}
/// The budget has one spelling per amount.
#[test]
fn a_runs_budget_is_a_canonical_decimal() {

View file

@ -529,10 +529,7 @@ fn check(docs: &Docs, staged: &Staged, mind: &Slug) -> Result<(), MindRefusal> {
if !replay && !docs.in_force(claim.kind, &claim.id.0) {
return Err(MindRefusal::CitesResolvedDocument { kind: claim.kind, id: claim.id.0.clone() });
}
let holder = docs.of_kind(K::Run).find_map(|(other_key, document)| match document {
D::Run(other) if other_key != key && other.claims.contains(claim) && docs.in_force(K::Run, other_key) => Some(other_key),
_ => None,
});
let holder = docs.claim_holder(key, claim);
if let Some(holder) = holder {
return Err(MindRefusal::AlreadyClaimed { item: claim.id.0.clone(), run: holder.into() });
}
@ -679,6 +676,20 @@ fn resolution_rule(docs: &Docs, resolution: &PipelineResolution) -> Result<(), M
later: later.into(),
});
}
// Withdrawing a run's closure puts the run back in force, and a run in
// force holds its claims: refuse while another run in force holds one.
if matches!(resolution.outcome, ResolutionOutcome::Withdrawn { .. })
&& subject_kind == K::Resolution
&& let Some(D::Resolution(reinstating)) = docs.find(K::Resolution, subject_id)
&& reinstating.subject.kind == K::Run
&& let Some(D::Run(run)) = docs.find(K::Run, &reinstating.subject.id.0)
{
for claim in &run.claims {
if let Some(holder) = docs.claim_holder(&reinstating.subject.id.0, claim) {
return Err(MindRefusal::AlreadyClaimed { item: claim.id.0.clone(), run: holder.into() });
}
}
}
for (_, referent) in outcome_citations(&resolution.outcome) {
if !docs.in_force(referent.kind, &referent.id.0) {
return Err(MindRefusal::CitesResolvedDocument { kind: referent.kind, id: referent.id.0 });
@ -2032,6 +2043,57 @@ mod tests {
);
}
/// Withdrawing a run's Recorded resolution puts the run back in force, so
/// it goes through the same exclusivity as an opening: refused while
/// another live run holds one of its claims, allowed when none does.
#[test]
fn reinstating_a_run_over_a_live_holder_is_already_claimed() {
let closure = r(K::Resolution, &format!("{INSTANCE}:resolution:run.a.n1"));
let mut mind = with_specs();
committed(admit(&mut mind, vec![run("a", &[spec_ref("1")])]));
committed(admit(&mut mind, vec![recorded("a")]));
committed(admit(&mut mind, vec![run("c", &[spec_ref("1")])]));
assert_eq!(
refusal(admit(&mut mind, vec![resolution(closure.clone(), withdrawn())])),
MindRefusal::AlreadyClaimed { item: spec_ref("1").id.0, run: run_key("c") }
);
let mut free = with_specs();
committed(admit(&mut free, vec![run("a", &[spec_ref("1")])]));
committed(admit(&mut free, vec![recorded("a")]));
committed(admit(&mut free, vec![resolution(closure, withdrawn())]));
}
/// A holder is found by any of its claims, not only the first.
#[test]
fn a_holder_is_found_by_its_second_claim() {
let mut mind = with_specs();
committed(admit(&mut mind, vec![run("a", &[spec_ref("2"), spec_ref("1")])]));
assert_eq!(
refusal(admit(&mut mind, vec![run("b", &[spec_ref("1")])])),
MindRefusal::AlreadyClaimed { item: spec_ref("1").id.0, run: run_key("a") }
);
}
/// A key already holding a run is taken: the same key with different
/// content is an IdentityCollision, never a replay; only byte-identical
/// content answers AlreadyAdmitted.
#[test]
fn a_run_key_reused_with_different_content_is_an_identity_collision() {
let mut mind = with_specs();
committed(admit(&mut mind, vec![run("a", &[spec_ref("1")])]));
let D::Run(mut changed) = run("a", &[spec_ref("1")]) else { panic!() };
changed.budget_usd = "6".into();
assert_eq!(
refusal(admit(&mut mind, vec![D::Run(changed)])),
MindRefusal::IdentityCollision { kind: K::Run, id: run_key("a") }
);
assert_eq!(
refusal(admit(&mut mind, vec![run("a", &[spec_ref("2")])])),
MindRefusal::IdentityCollision { kind: K::Run, id: run_key("a") }
);
}
/// A5 for runs: a run of another instance is a ForeignInstance.
#[test]
fn a_run_of_another_mind_is_a_foreign_instance() {

View file

@ -215,6 +215,20 @@ impl Docs {
self.of_kind(kind).find(|(key, other)| later_than(base, other) && self.in_force(kind, key)).map(|(key, _)| key)
}
/// The in-force run, other than `run_key`, that holds `claim`: the one
/// consumption fact run-is-the-grant rests on, asked by a run's opening
/// and by the withdrawal that would put a closed run back in force.
pub(crate) fn claim_holder(&self, run_key: &str, claim: &PipelineRef) -> Option<&str> {
self.of_kind(PipelineKind::Run).find_map(|(other_key, document)| match document {
PipelineDocument::Run(other)
if other_key != run_key && other.claims.contains(claim) && self.in_force(PipelineKind::Run, other_key) =>
{
Some(other_key)
}
_ => None,
})
}
/// The stewardship of `(mind, repo)` a hand-off acts on: the one whose
/// withdrawal already carries `hand_off_key`, when image or batch holds
/// that withdrawal, so a replay derives the same withdrawal again and A9