Struct RefinePlan 

pub struct RefinePlan {
    pub completed: HashSet<(String, String)>,
    pub seen_identities: HashSet<(String, String)>,
    pub completed_hashes: HashMap<(String, String), PriorCompletion>,
    pub next_exec_id: u64,
    pub prior_outcomes_seen: usize,
    pub scope: RefineScope,
}

Pre-computed skip set + next-execution id for one refine invocation.

Fields

completed: HashSet<(String, String)>

(phase_name, phase_labels) pairs that have at least one prior outcome with status "completed" across any execution of the session. The phase-walk gate checks each phase against this set before dispatching its per-cycle work.

seen_identities: HashSet<(String, String)>

Every (phase_name, phase_labels) pair that has ANY prior outcome (regardless of status). Used by the --on-removed= policy to detect phases that exist in the session’s history but no longer appear in the freshly pre-mapped workload — those are candidates for the error / keep / drop decision.

completed_hashes: HashMap<(String, String), PriorCompletion>

Prior (name, labels) → provenance for completed phases: the BASE hash (phase_outcomes.phase_hash) plus the SRD-107 consumed-params JSON. Used by the hash gates: at phase activation the executor computes the current base hash and param digests and compares via Self::unchanged_verdict. Legacy rows (either field NULL) always flag as changed, so the conservative behavior runs the phase rather than wrongly skipping it.

next_exec_id: u64

The execution id this refine invocation will record new outcomes under. One greater than the maximum exec_id observed in the prior phase_outcomes rows; at least 1 for sessions with no prior outcomes (degenerate, but supported).

prior_outcomes_seen: usize

Total prior outcome rows examined. Surfaced in the startup log so the operator can sanity-check the session their refine attached to.

scope: RefineScope

SRD-77 scope mode: Missing (skip prior-completed), Changed (skip prior-completed AND prior_hash matches current_hash), or All (no skip — empty completed). Set by the runner from the scope= CLI param; the executor’s phase walk consults it to decide which gate to apply.

Implementations

impl RefinePlan

pub fn is_completed(&self, phase_name: &str, phase_labels: &str) -> bool

O(1) check used by the executor’s phase-walk gate.

pub fn is_unchanged( &self, phase_name: &str, phase_labels: &str, current_hex: &str, current_params: &HashMap<String, String>, ) -> bool

SRD-77 --scope=changed — true iff this phase has a prior completed outcome AND the prior outcome’s phase_hash matches current_hex. False when:

• No prior completion: phase is new → run.
• Prior completion but hash differs: program shape changed → re-run.
• Prior completion with phase_hash = NULL: legacy row from before the column was added → conservatively re-run (we can’t prove unchanged, so default to “do the work”).

pub fn unchanged_verdict( &self, phase_name: &str, phase_labels: &str, current_hex: &str, current_params: &HashMap<String, String>, ) -> Result<(), SkipBlocker>

SRD-107 Push 3 — the three-way skip-validity check with a NAMED blocker on failure: base hash equal AND every stored consumed param’s current value digests to its stored digest. Conservative on any gap (legacy rows, unreadable stored map): re-run rather than wrongly skip.

pub fn should_skip( &self, phase_name: &str, phase_labels: &str, current_hex: &str, current_params: &HashMap<String, String>, ) -> bool

Should this phase be skipped per the plan’s scope? Centralises the scope→gate dispatch so the executor walker stays a single conditional. The hash arg is only consulted under Changed; passing "" is fine for Missing / All callers that don’t know it yet.

pub fn load_from_session_dir(session_dir: &Path) -> Option<Self>

Open the session directory’s metrics.db, read every phase_outcomes row, and compute the skip plan.

Returns None when:

• The session directory doesn’t exist
• The sqlite file doesn’t exist (no prior run captured outcomes)
• The sqlite file exists but the phase_outcomes table is missing (legacy session predating SRD-76)

Sqlite errors mid-query log at WARN and produce an empty plan — refine falls back to “run everything” rather than failing the invocation, on the principle that a half-readable database shouldn’t block the operator from making progress.

Trait Implementations

impl Clone for RefinePlan

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 RefinePlan

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

Formats the value using the given formatter.