Struct IssueRun 

pub struct IssueRun {
    pub issue: i64,
    pub title: String,
    pub status: Status,
    pub pr: Option<String>,
    pub rounds: u32,
    pub disputes: Vec<Dispute>,
    pub filed: Vec<String>,
    pub noted: Vec<Finding>,
    pub notes: Vec<String>,
    pub followup_writes_uncertain: bool,
}

The outcome of working one issue, or resuming one PR.

Fields

issue: i64

title: String

status: Status

pr: Option<String>

rounds: u32

disputes: Vec<Dispute>

filed: Vec<String>

noted: Vec<Finding>

Real points a reviewer judged smaller than another round.

Nothing else carries them. The round comment is off under the default pr_comments = "outcome" and a non-blocking finding is not filed under the default file_non_blocking = false, so without this the severity ladder is a way to make a finding disappear rather than a way to stop it costing a round. Silence on a pull request should mean nothing was found, not that nothing was gated.

notes: Vec<String>

followup_writes_uncertain: bool

Runtime circuit breaker after an external follow-up write could not be verified. A later invocation rechecks GitHub before any new write.

Implementations

impl IssueRun

pub fn new(issue: i64, title: impl Into<String>) -> Self

Examples found in repository

examples/preview.rs (line 199)

fn main() {
    let loose = std::env::args().any(|a| a == "--loose");
    let style = if loose {
        Style {
            terse: false,
            ..Style::default()
        }
    } else {
        Style::default()
    };
    if loose {
        println!("(concision gate OFF: this is what a model would post unedited)");
    }

    rule("A clean review");
    println!(
        "{}",
        review_comment(
            "codex",
            1,
            &Review {
                verdict: Verdict::Approve,
                next_action: NextAction::Merge,
                summary: "I reviewed the changes on this branch carefully and I am happy to \
                          report that the retry path is correct, the backoff calculation is \
                          sound, and the new test covers the 429 case that the issue described. \
                          I have no objections to this change landing as it stands."
                    .into(),
                findings: vec![],
            },
            &style
        )
    );

    rule("A review with real work in it");
    println!(
        "{}",
        review_comment(
            "codex",
            2,
            &Review {
                verdict: Verdict::ChangesRequested,
                next_action: NextAction::HandBack,
                summary: "There is one genuine defect here that should block, along with a \
                          couple of improvements that I do not think need to gate this \
                          particular pull request, and one pre-existing problem I noticed \
                          while reading the surrounding code."
                    .into(),
                findings: vec![
                    finding(
                        "blocking",
                        "Retry loop never terminates when max_attempts is unset",
                        "I confirmed this by running the 429 test with max_attempts left at its \
                         default of None: the loop spins forever because the guard on line 91 \
                         compares against Some(0) rather than checking for None first. This is \
                         not a theoretical concern, the test hangs and I had to kill it.",
                        "src/net.rs:88",
                        true,
                    ),
                    finding(
                        "non-blocking",
                        "The request timeout is hard coded to thirty seconds",
                        "It would be better if this were configurable, since a slow upstream \
                         will now fail rather than wait, but the previous code had the same \
                         limitation so this is not a regression introduced by the change.",
                        "src/net.rs:44",
                        true,
                    ),
                    finding(
                        "nit",
                        "Log line says \"retrying\" without saying how many attempts remain",
                        "Purely a readability point for whoever is reading the logs at 3am.",
                        "src/net.rs:102",
                        true,
                    ),
                    finding(
                        "blocking",
                        "Config loader swallows a parse error",
                        "Unrelated to this PR, but load_config discards the error from serde and \
                         returns Default::default(), so a typo in the config file is silently \
                         ignored.",
                        "src/config.rs:210",
                        false,
                    ),
                ],
            },
            &style
        )
    );

    rule("Answering that review");
    println!(
        "{}",
        disposition_comment(
            "claude",
            &ResponseDoc {
                summary: "One of the two blocking points was right and I have fixed it. I do not \
                          agree with the other and have explained why below rather than changing \
                          working code to make the review go away."
                    .into(),
                dispositions: vec![],
            },
            &["Retry loop never terminates when max_attempts is unset".to_string()],
            &[
                "Config loader swallows a parse error. The caller already validates the file \
               against the schema before load_config is reached, so the discarded error is \
               unreachable in practice."
                    .to_string()
            ],
            &["https://github.com/you/thing/issues/512".to_string()],
            &style
        )
        .unwrap_or_default()
    );

    rule("The pull request body");
    println!(
        "{}",
        pr_body(
            478,
            &Implementation {
                summary: "Retry a 429 with exponential backoff instead of failing the request."
                    .into(),
                problem: "A rate limited response was treated as fatal, so a single throttled \
                          call ended a run that had hours of work left in it. The retry path \
                          existed but only covered connection errors, and nothing in the logs \
                          said which of the two had happened."
                    .into(),
                changes: vec![
                    "`send` now retries a 429, honouring `Retry-After` when the server sets it \
                     and backing off exponentially when it does not"
                        .into(),
                    "the retry budget is bounded at five attempts, so a permanent 429 still \
                     ends the call rather than spinning"
                        .into(),
                    "a retry logs the status it is retrying, which is what made the original \
                     failure impossible to tell apart from a dropped connection"
                        .into(),
                ],
                testing: vec![
                    "`cargo test retries_a_rate_limited_request`, which fakes a 429 with a \
                     `Retry-After` of 2 and asserts the wait"
                        .into(),
                    "point it at a throttled endpoint and watch a run finish rather than stop \
                     on the first 429"
                        .into(),
                ],
                notes: Some(
                    "Streaming calls do not go through `send` and are unchanged, which is worth \
                     a follow-up but not this one."
                        .into()
                ),
                ..Implementation::default()
            },
            Some("cargo test"),
            &style
        )
    );

    rule("What a whole run leaves on the PR (the default, one comment)");
    let mut ended = IssueRun::new(482, "t");
    ended.disputes = vec![Dispute {
        title: "Config loader swallows a parse error".into(),
        file: "src/config.rs".into(),
        reasoning: "the caller validates against the schema before load_config is reached".into(),
    }];
    ended.filed = vec![
        "https://github.com/you/thing/issues/485".into(),
        "https://github.com/you/thing/issues/486".into(),
    ];
    println!(
        "{}",
        outcome_comment(
            &ended,
            &spar::model::Ledger::new(),
            &Ending::OutOfRounds,
            &style
        )
        .unwrap_or_default()
    );
    println!("\n  (and a clean run that filed nothing posts no comment at all)");

    rule("What a run leaves when the closing pass did not sign it off");
    let mut left = IssueRun::new(482, "t");
    left.noted = vec![finding(
        "non-blocking",
        "Timeout is not configurable",
        "The retry budget is fixed at three.",
        "src/net.rs",
        true,
    )];
    let unresolved = vec![finding(
        "blocking",
        "The retry fix never reaches the 429 path",
        "The guard added in round 2 sits after the early return on line 88, so a rate limited \
         response still takes the old path. Reproduced with the 429 test.",
        "src/net.rs:88",
        true,
    )];
    println!(
        "{}",
        outcome_comment(
            &left,
            &spar::model::Ledger::new(),
            &Ending::Unresolved(&unresolved),
            &style
        )
        .unwrap_or_default()
    );

    rule("A review of somebody else's pull request (spar review)");
    let judged = |standing, severity, title: &str, detail: &str, file: &str, by: &str| Judged {
        finding: finding(severity, title, detail, file, true),
        raised_by: by.to_string(),
        standing,
        counterpoint: None,
        defence: None,
        rated: None,
    };
    let mut disputed = judged(
        FindingStanding::Disputed,
        "blocking",
        "Config loader swallows a parse error",
        "load_config discards the error from serde and returns a default.",
        "src/config.rs:210",
        "claude",
    );
    disputed.counterpoint =
        Some("the caller validates against the schema before load_config is reached".into());
    println!(
        "{}",
        verdict_comment(
            &[
                judged(
                    FindingStanding::Corroborated,
                    "blocking",
                    "Retry loop never terminates when max_attempts is unset",
                    "Both reviewers reproduced this: the guard on line 91 compares against \
                     Some(0) rather than checking for None, so the 429 test hangs.",
                    "src/net.rs:88",
                    "claude and codex",
                ),
                judged(
                    FindingStanding::Confirmed,
                    "non-blocking",
                    "The request timeout is hard coded",
                    "Not a regression, the previous code had the same limitation.",
                    "src/net.rs:44",
                    "codex",
                ),
                judged(
                    FindingStanding::Unverified,
                    "nit",
                    "Log line does not say how many attempts remain",
                    "Readability for whoever reads the logs at 3am.",
                    "src/net.rs:102",
                    "claude",
                ),
                disputed,
                judged(
                    FindingStanding::Withdrawn,
                    "blocking",
                    "Off by one in the backoff",
                    "Withdrawn after the other reviewer pointed at the test that covers it.",
                    "src/net.rs:70",
                    "codex",
                ),
            ],
            &style
        )
    );

    rule("A second look at that pull request, after the author pushed (spar review --recheck)");
    let recorded = |severity: &str, title: &str, detail: &str, file: &str, standing| {
        spar::model::RecordedFinding {
            title: title.into(),
            file: file.into(),
            severity: Severity::parse_lenient(severity).expect("severity"),
            detail: detail.into(),
            in_scope: true,
            raised_by: "claude and codex".into(),
            standing,
            counterpoint: None,
            defence: None,
        }
    };
    println!(
        "{}",
        recheck_comment(
            &Delta {
                from: "0123abcdef".into(),
                commits: vec![
                    "a1b2c3d check for None before comparing attempts".into(),
                    "e4f5a6b make the request timeout configurable".into(),
                ],
                rewritten: false,
            },
            &[
                Rechecked {
                    recorded: recorded(
                        "blocking",
                        "Retry loop never terminates when max_attempts is unset",
                        "The guard on line 91 compares against Some(0) rather than checking for None.",
                        "src/net.rs:88",
                        FindingStanding::Corroborated,
                    ),
                    resolution: Resolution::Fixed(
                        "src/net.rs:91 now matches on None first, and the 429 test that used to \
                         hang passes in 0.3s when run with cargo test retry"
                            .into(),
                    ),
                },
                Rechecked {
                    recorded: recorded(
                        "non-blocking",
                        "The request timeout is hard coded",
                        "Not a regression, the previous code had the same limitation.",
                        "src/net.rs:44",
                        FindingStanding::Confirmed,
                    ),
                    resolution: Resolution::Rebutted(
                        "the author's reply is right that the timeout comes from the caller's \
                         Client builder since e4f5a6b, so there is nothing left to make configurable \
                         here"
                            .into(),
                    ),
                },
                Rechecked {
                    recorded: recorded(
                        "blocking",
                        "Config loader swallows a parse error",
                        "load_config discards the error from serde and returns a default.",
                        "src/config.rs:210",
                        FindingStanding::Confirmed,
                    ),
                    resolution: Resolution::Open(
                        "codex still sees it: load_config still returns Default on a parse error, \
                         and nothing upstream validates the file first"
                            .into(),
                    ),
                },
            ],
            &[judged(
                FindingStanding::Corroborated,
                "non-blocking",
                "The new None branch logs at error level on every retry",
                "Each retry now writes an error line, so a flaky upstream fills the log with \
                 errors for a request that succeeds on the third try.",
                "src/net.rs:93",
                "claude and codex",
            )],
            &style,
            2
        )
    );

    rule("An issue both reviewers declined");
    println!(
        "{}",
        skip_comment(
            &SkippedItem {
                issue: 91,
                title: "Add a dark mode".into(),
                tracker: false,
                reasons: [
                    (
                        "claude".to_string(),
                        "This was already implemented in 1.4 and shipped behind the theme \
                         setting, so there is nothing left to do here."
                            .to_string()
                    ),
                    (
                        "codex".to_string(),
                        "Duplicate of #62, which is still open and has the full discussion."
                            .to_string()
                    ),
                ]
                .into_iter()
                .collect(),
            },
            &style
        )
    );
    rule("Answering a comment in its own thread");
    for item in [
        settled(
            Ask::Implement,
            "alice",
            "src/retry.rs:91",
            "Added the guard on the retry path and a test that reproduces the original failure.",
            "",
            true,
        ),
        settled(
            Ask::Decline,
            "bob",
            "src/pool.rs:14",
            "",
            "Every caller of this function already holds the pool lock, so the check on line 14 \
             cannot be reached with a null connection. I ran the suite with an assertion in its \
             place and nothing tripped it.",
            false,
        ),
        settled(
            Ask::Defer,
            "carol",
            "src/electrum.rs:203",
            "",
            "This is real and it predates the branch: the reconnect monitor puts a stopped wallet \
             back into the header router. It is not caused by anything here, so fixing it in this \
             pull request would put an unrelated change in front of whoever reviews it.",
            false,
        ),
    ] {
        println!("{}\n", thread_reply(&item, &style));
    }

    rule("What a check-in leaves on the pull request");
    let mut fixed = settled(
        Ask::Implement,
        "alice",
        "the pull request",
        "Retried the 429 with the backoff the issue asked for.",
        "",
        true,
    );
    fixed.pending.file = None;
    let mut parked = settled(
        Ask::Decline,
        "dave",
        "the pull request",
        "",
        "The two reviewers read the same code and did not agree about whether the guard is \
         reachable.",
        false,
    );
    parked.pending.file = None;
    parked.parked = true;
    println!(
        "{}",
        checkin_comment(&[fixed, parked], &style)
            .unwrap_or_else(|| "(nothing to say, so no comment is posted)".into())
    );
    println!("\n  (and a check-in with nothing outstanding posts no comment at all)");

    rule("An idea filed from a brainstorm");
    let idea = Candidate {
        id: 1,
        idea: Idea {
            title: "Batch settlement with hash timelocks".into(),
            combines: vec![
                "hash time locked contracts".into(),
                "batch auctions".into(),
                "the OP_CHECKSEQUENCEVERIFY delay".into(),
            ],
            how_it_works: "Each trade posts a hash timelock, and one batch auction clears every \
                           one of them at the deadline together, so the batch is the settlement."
                .into(),
            why_new: "The nearest thing is a plain escrow, which settles one trade at a time \
                      and cannot net them against each other."
                .into(),
            enables: "Settling many trades in one transaction.".into(),
            risks: "A fee spike at the deadline makes the batch uneconomic.".into(),
            first_experiment: "Simulate ten trades on regtest and count the bytes.".into(),
        },
        proposers: vec!["claude".into()],
        parent: None,
        objection: Some((
            "codex".into(),
            "Coinjoin coordinators already batch settlement.".into(),
        )),
        defence: Some(
            "A coordinator batches inputs, not conditional trades; nothing there clears a hash \
             lock."
                .into(),
        ),
        standing: Standing::Defended,
        rank_sum: 3,
    };
    println!("{}", issue_body(&idea, &style));
    println!("\n  (who proposed and who objected stays in the session file, never in the issue)");

    println!();
}

pub fn succeeded(&self) -> bool

Whether this outcome counts as the run having done its job.

A review that produced findings did its job: the findings are the product, and a PR needing work is not a failure of the reviewer.

Trait Implementations

impl Clone for IssueRun

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for IssueRun

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for IssueRun

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for IssueRun

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.