Struct ReductionPlan 

pub struct ReductionPlan {

    pub turn_id: TurnId,
    pub acts: Vec<PlannedAct>,
    pub batches: Vec<CommandBatch<Value>>,
    pub policy_decisions: Vec<PolicyDecision>,
    pub answer_tasks: Vec<AnswerTask>,
    pub constraints_applied: Vec<ConstraintKind>,
    pub notices: Vec<ServerNotice>,
    pub pre_execution_interactions: Vec<InteractionSpec>,
    pub plan_hash: Digest,
    pub superseded_operations: Vec<OperationKey>,
    pub refusals: Vec<NarratableFact>,
    pub changed_nothing: Vec<NarratableFact>,
    pub awaiting_confirmation: Vec<NarratableFact>,
}

The reducer’s output (spec §13).

Fields

turn_id: TurnId

The turn.

acts: Vec<PlannedAct>

One entry per input act, by index (I11).

batches: Vec<CommandBatch<Value>>

Command batches ready for execution, grouped by atomicity scope. Commands are erased to JSON; the registry converts them at the boundary.

policy_decisions: Vec<PolicyDecision>

Policy decisions for every command.

answer_tasks: Vec<AnswerTask>

Questions to answer.

constraints_applied: Vec<ConstraintKind>

Constraints that were applied.

notices: Vec<ServerNotice>

Notices to show (e.g. “Nothing has been submitted”).

pre_execution_interactions: Vec<InteractionSpec>

Interactions to persist before any command executes (clarifications and confirmations). Deduplicated by InteractionSpec::key.

plan_hash: Digest

Digest of everything above (see Self::compute_hash).

superseded_operations: Vec<OperationKey>

Operations of acts a correction or a cancel in the same message replaced.

Supersession is the one reduction rule that makes a turn do less than its plan said, and until it was counted a message carrying four data that produced one command was only discoverable by reading the conversation that followed. One entry per dropped act, in plan order.

refusals: Vec<NarratableFact>

Domain refusals, as facts the narration stage may rest on.

The notice beside them tells the user deterministically; these tell the narrator, so its prose does not ask for something else as though the refusal had not happened.

changed_nothing: Vec<NarratableFact>

Acts that were accepted and changed nothing, as facts the narration stage may rest on.

Beside Self::refusals and not inside it, because the two are different outcomes and one of them is counted: the runtime raises its refusal signal once per entry there, and a no-op filed among them would be a refusal in every dashboard that reads it. They travel together only at the point where both become facts for the writer.

awaiting_confirmation: Vec<NarratableFact>

Acts this turn prepared and held behind a confirmation card, as facts the narration stage may rest on.

Separate from Self::refusals and not folded into it, because these are not refusals: that list is counted as Signal::ActRefused, and an act waiting for a click is one the server intends to run. See NarratableFact::ActAwaitingConfirmation.

Implementations

impl ReductionPlan

pub fn compute_hash(&self) -> Result<Digest, HashError>

Computes the digest of every field except plan_hash.

pub fn with_hash(self) -> Result<ReductionPlan, HashError>

Sets plan_hash from the current content.

pub fn verify_hash(&self) -> Result<bool, HashError>

Returns true when plan_hash matches the content.

pub fn validate(&self, understood: &[ActId]) -> Result<(), ReductionError>

Structural consistency checks.

Everything here is a property a correct reducer already has; the point is that a plan which fails one of them must never reach execution, so a reducer bug becomes a refused turn instead of an unauthorized command:

• every act of the understanding appears exactly once (I11);
• every ReadyToExecute command reference points at a batch command;
• a ReadyToExecute act resolved its target exactly, unless it starts a workflow or picks a target (spec §12.2, I8), and its commands run on the case it resolved to;
• every batched command has exactly one PolicyDecision, that decision allows it, and its origin satisfies the policy the decision recorded (origin_satisfies, I9, I12);
• no refused decision names a command that is nevertheless batched;
• every spec embedded in an act result is listed in pre_execution_interactions (by key);
• PerCase batches target a single case.

pub fn command_refs(&self) -> Vec<CommandRef>

All command references in batch order.

pub fn has_no_effects(&self) -> bool

Returns true when nothing will execute this turn.

Trait Implementations

impl Clone for ReductionPlan

fn clone(&self) -> ReductionPlan

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ReductionPlan

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ReductionPlan

fn deserialize<__D>( __deserializer: __D, ) -> Result<ReductionPlan, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for ReductionPlan

impl PartialEq for ReductionPlan

fn eq(&self, other: &ReductionPlan) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for ReductionPlan

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ReductionPlan