[zzylol]

Summary

• Problem: at PR 4's head Stage 2 was todo!(), so every planning run stopped there; Count-Min weight signs were a WeightDomain proof on each update, set by Pass 1 and checked by the executor.
• Change: generate_physical_asap_memo_candidates expands each logical candidate Pass 2 kept into its offered $p^{\mathrm{phys}} = (\tau, \ell)$ (decision-tree levels 3–4), each logical edge into physical edges with $\alpha^{\log}$ and $\alpha^{\mathrm{phys}}$, and records every rejected alternative with its PruneReason; a Count-Min build's weight sign is now the state group's column_sign.
• Effect: for query A of the concepts doc, quantile_over_time(0.95, latency[1m]) every 60 s, Stage 2 offers the chain (QT, None), (QT, OneEvaluation), (QT, AcrossEvaluations), (IT, AcrossEvaluations), prunes its (IT, None) as ReachesNoQueryOutput, and emits 12 physical edges into the chain from the scan's three alternatives; planning now stops at Stage 3 (select_plan, PR 6).

Review guide

• Position: PR 5 of the Tracking: implement the optimization formulation (memo candidates, properties, edges y_{u,c,i}, MILP) as named code per stage #1207 stack (row "5. Stage 2" of Tracking: implement the optimization formulation (memo candidates, properties, edges y_{u,c,i}, MILP) as named code per stage #1207's Order); part of the Tracking: implement the optimization formulation (memo candidates, properties, edges y_{u,c,i}, MILP) as named code per stage #1207 merge unit, not merged on its own. Base refactor(stage1-pass2): rollup from the finest common group, readout requirements, dead-candidate elimination, chain groups (#1207 PR 4) #1234 (refactor/1207-pass2, PR 4); refactor(stage3): baseline selection MILP and its PhysicalASAPDAG; executor θ, native chains and a time-indexed store (#1207 PR 6) #1236 (PR 6) builds on it. One commit, head 4c77ec62d.
• Reading order:
  1. stage2-physical-optimization/src/catalog/configurations.rs (enumerate_candidate_configurations, read_at_absolute_time, counter_state_rows_ordered, count_min_weights_not_proven_non_negative): offered values and prune rules.
  2. catalog/mod.rs (generate_physical_asap_memo_candidates, ingestion_time_offered_per_group): physical edges.
  3. catalog/pruning.rs (prune_reasons): buildability fixed point and reach.
  4. types/src/stages/physical/memo_candidates.rs: PhysicalASAPMemoCandidates::new and the admissible-edge indexes.
• Mechanical: deletion of WeightDomain/NonNegativeWeightProof and weight_domain: lines in every test; shared memo fixtures replacing per-crate copies (Pass 2's try_candidate, candidate, group, series_schema, scan_operator; Pass 1's cfg(test) scan_operator); thiserror dropped from Stage 2; doc lines in planner-layering.md, asap-primitive-schema.md, glossary.md.
• Careful: the ingestion-time closure (C2), the Count-Min sign source (C3), the query-output definition (C4), A4 and A7 in configurations.rs; executor checks removed in physical_planner/mod.rs, summary_kernels/factory.rs and capability.rs (C5).

Behavior: before → after

Query A of the concepts doc (test offers_each_candidate_its_timings_and_lifetimes): quantile_over_time(0.95, latency[1m]) every 60 s at phase 0, over ingesting data (rows_per_second 1000, max_out_of_order_ms None); the deployment retains raw data and query-time results. It serves the design need of the formulation: Stage 3 chooses among all physical alternatives, Stage 2 only enumerates and records why an alternative is removed.

	Before (PR 4)	After (this PR)
Stage 2	todo!(); planning stops	PhysicalASAPMemoCandidates with physical edges, admissible-edge indexes and the pruned list; planning stops at Stage 3 (select_plan's todo!() of PR 6)
G1, G2[0], G2[1], G4, G5	—	(QT, None), (QT, OneEvaluation), (QT, AcrossEvaluations): time-dependent, so no ingestion time; on the 60 s grid, so AcrossEvaluations
G0 Scan	—	(QT, None), (QT, OneEvaluation), (IT, None): no grid, so no AcrossEvaluations
G3 chain	—	(QT, None), (QT, OneEvaluation), (QT, AcrossEvaluations), (IT, AcrossEvaluations); (IT, None) pruned ReachesNoQueryOutput
Count-Min weight sign	WeightDomain proof on SummaryUpdate, executor refusal	the state group's column_sign; unproven → CountMinWeightsNotProvenNonNegative

Interfaces

crates/stage2-physical-optimization/src/catalog/mod.rs

 /// Stage 2: expand every logical candidate Pass 2 kept into its offered (τ, ℓ), every logical
 /// edge into physical edges; record each rejected alternative with its reason. Cannot fail.
 /// Signature unchanged; was `todo!()`.
 pub fn generate_physical_asap_memo_candidates(
     logical: &LogicalASAPMemoCandidates,
     data: &DataWorkload,
     capabilities: &DeploymentCapabilities,
 ) -> PhysicalASAPMemoCandidates;

crates/types/src/stages/physical/memo_candidates.rs

+impl PhysicalEdge {
+    /// Whether a plan may use the edge: α^log = α^phys = 1. Stage 2's pruning, the indexes and Stage 3 call it.
+    pub fn is_logically_and_physically_admissible(&self) -> bool;
+}
 impl PhysicalASAPMemoCandidates {
     /// Stage 2's output, with the admissible-edge indexes built once (signature unchanged; was `todo!()`).
     pub fn new(
         logical_candidates: LogicalASAPMemoCandidates,
         physical_candidates: Vec<PhysicalCandidate>,
         edges: Vec<PhysicalEdge>,
         pruned_candidates: Vec<PrunedCandidate<PhysicalCandidate>>,
     ) -> Self;
     /// P^adm_{c,i}: the admissible edges into input i of `consumer`; empty when none (was `todo!()`).
     pub fn admissible_edges_into(
         &self,
         consumer: PhysicalCandidateId,
         input_index_of_consumer: usize,
     ) -> &[PhysicalEdgeId];
     /// The admissible edges out of `producer` (was `todo!()`).
     pub fn admissible_edges_out_of(&self, producer: PhysicalCandidateId) -> &[PhysicalEdgeId];
 }

crates/types/src/stages/pruning.rs

 /// Why a stage removed a candidate. Stays; variants unchanged, Stage 2's are now produced.
 pub enum PruneReason {
     /// Stage 2: IT, and the data has no ingestion pipeline (at rest or unknown arrival). Input fact.
     NoIngestionPipeline,
-    /// Stage 2: it scans raw data at query time, and the deployment does not retain raw data.
+    /// Stage 2: it scans raw data at query time, or retains the raw rows it scans across
+    /// evaluations, and the deployment does not retain raw data. Input fact.
     RawDataNotRetained,
-    /// Stage 2: a query-time result materialized (`OneEvaluation` or `AcrossEvaluations`), and the
-    /// deployment retains no query-time results.
+    /// Stage 2: a query-time result materialized across evaluations, and the deployment retains
+    /// none (`DeploymentCapabilities::query_time_results_retained`); C1.
     QueryTimeResultsNotRetained,
     /// Stage 2: an input has no buildable admissible producer.
     InputHasNoBuildableProducer,
     /// Stage 2: no query output reads it over admissible edges.
     ReachesNoQueryOutput,
     /// Stage 2: a Count-Min build (`Cms`, `CmsWithHeap`, `HydraCms`) whose state column's
     /// `column_sign` is not `NonNegative`.
     CountMinWeightsNotProvenNonNegative,
     /// Stage 3: dominated by the named candidate.
     DominatedBy(PhysicalCandidateId),
     /// Stage 3: `asap-cost` could not cost it.
     UsageNotCostable,
 }

crates/types/src/ir/schema/sketch.rs · crates/types/src/ir/schema/mod.rs

 /// One summary-state update. Stays; loses `weight_domain`.
 pub struct SummaryUpdate {
     /// The key the row is counted under, for keyed summary types.
     pub item: Option<SummaryInputExpr>,
     /// The value added to the state.
     pub weight: SummaryInputExpr,
-    /// Planner proof for algorithms that need a non-negative stream.
-    #[serde(default)]
-    pub weight_domain: WeightDomain,
 }
-/// The proven or required sign of an update's weights. Removed.
-pub enum WeightDomain {
-    /// No proof (default).
-    #[default]
-    UnknownOrSigned,
-    /// Proven non-negative.
-    NonNegative {
-        proof: NonNegativeWeightProof,
-    },
-    /// Open requirement: raw data samples of `metric`, confirmed from source facts.
-    #[serde(rename = "samples_of_metric")]
-    RawDataSamplesOfMetric {
-        metric: String,
-    },
-    /// Open requirement: reset-corrected `rate`/`increase`/`irate` of `metric`'s samples.
-    CounterDerivativeOfMetric {
-        metric: String,
-    },
-}
-/// Why weights are non-negative. Removed.
-pub enum NonNegativeWeightProof {
-    /// A unit count.
-    UnitCount,
-    /// `rate`/`increase`/`irate` of a counter's samples.
-    ResetAwareCounterDerivative,
-    /// Raw data samples of a metric declared a counter.
-    #[serde(rename = "counter_samples")]
-    CounterRawDataSamples,
-    /// Raw data samples of a metric declared non-negative.
-    #[serde(rename = "declared_non_negative_samples")]
-    DeclaredNonNegativeRawDataSamples,
-    /// A constant weight greater than 0.
-    PositiveConstant,
-}

Removed (decision 2026-11-09): the state group's column_sign (derived from the weight's sign and the declared source signs) replaces them, read by Stage 2's CountMinWeightsNotProvenNonNegative; schema::mod no longer re-exports either.

crates/types/src/test_support.rs (test-support feature only; review D11)

+/// `[ts, value, labels...]`, time index 0, series identity realized (closed, `$promql_series_identity` last).
+pub fn series_schema(labels: &[&str]) -> Schema;
+/// A `TimeSeries(metric)` scan with `schema`, filtered by `predicates`.
+pub fn time_series_scan<C>(
+    metric: &str,
+    schema: Schema,
+    predicates: Vec<Predicate<C>>,
+) -> Operator<C>;
+/// Adds `operator` with `parameters` to `group` as Pass 1 does (no input requirement, no fused group);
+/// a merge or a `TimeRange` over a chain gets the θ of the states it reads (A1).
+pub fn add_candidate(
+    memo: &mut Memo,
+    group: MemoGroupId,
+    operator: Operator<MemoGroupId>,
+    parameters: Option<SketchParams>,
+) -> Result<CandidateForMemoGroupId, CandidateError>;
+/// The group of `operator`, with `operator` as its own candidate.
+pub fn group_with_own_candidate(memo: &mut Memo, operator: Operator<MemoGroupId>) -> MemoGroupId;

Example: group_with_own_candidate(&mut memo, time_series_scan("latency", series_schema(&["job"]), vec![])) is query A's scan group; Pass 2's and Stage 2's tests build their memos with these.

Also removed (crate-private, so no block): Pass 1's CmsWithHeap gate on unproven weights in realize_keyed_additive_summary_input, raw_data_samples_of_metric, with_raw_data_samples_requirement, SingleMeasure::raw_data_samples_of (Stage 2's Count-Min prune replaces them); Pass 1's private reads_only_time_series(memo, input) and Stage 2's recursive copy (the group property GroupProperties::reads_only_time_series, PR 2, N7); the executor's CmsWithHeap "nonnegative weight contract" check (physical_planner), the rate-weight refusal in create_planner_accumulator (keyed off ResetAwareCounterDerivative) and the Hydra "weight's sign is unknown" binding check (the planner proves the sign before offering a Count-Min build; the Hydra build still rejects a negative weight value at run time, invalid_weight_values_fail_the_build).

Not reintroduced from the old PR 5 head (decisions after it): executor_can_run / PerEntityAggregateNotExecutable (G4/H3: no executor-support check), AcrossEvaluationsWithoutWindowLayout (F1/C7: a value-set rule, not a prune reason), PhysicalCandidateKey, PrunedCandidate.group, PhysicalASAPMemoCandidates::query_roots, the private Deployment struct (D1–D4, F2, F3; the PR 0 types already have these shapes).

Usage, end to end (test offers_each_candidate_its_timings_and_lifetimes at 513a1e78e, query A of the concepts doc):

// What the user writes: quantile_over_time(0.95, latency[1m]), every 60 s at phase 0, over
// ingesting data (rows_per_second 1000, max_out_of_order_ms None); the deployment retains raw
// data and query-time results (`data`, `capabilities`, read by Stage 2's offered values and prune rules).
// `logical`: what Stage 0 + Pass 1 + Pass 2 give (built by the test as they build it):
// G0 Scan latency; G1 TimeRange 1m (G0); G2 KLL state with [0] SummaryAgg(G1) and [1] SummaryMerge(G4);
// G3 SummaryTumblingWindowChain[KLL, w = 60 s](G0); G4 TimeRange 1m (G3); G5 p95 readout (root).
// evaluation_grid_of_group: 60 s @ 0 for G1, G2, G4, G5; None for G0 and G3 (time-independent).
// `physical`: Stage 2's output, which the planner facade hands to Stage 3 (PR 6).
let physical = generate_physical_asap_memo_candidates(&logical, &data, &capabilities);
// G1, G2[0], G2[1], G4, G5: (QT, None), (QT, OneEvaluation), (QT, AcrossEvaluations).
// G0 Scan: (QT, None), (QT, OneEvaluation), (IT, None).
// G3 chain: (QT, None), (QT, OneEvaluation), (QT, AcrossEvaluations), (IT, AcrossEvaluations);
//   pruned_candidates: G3 (IT, None) ReachesNoQueryOutput (only an ingestion-time consumer could read it).
// edges: into G3's four alternatives from G0's three: 12 edges (test `edges_carry_both_requirements`);
//   is_logically_and_physically_admissible exactly when both run at the same timing.
// E.g. the edge from the scan's (QT, None) into the chain's (IT, AcrossEvaluations) has
//   satisfies_logical_requirement: true, satisfies_physical_requirement: false, so neither
//   pruning nor admissible_edges_into lists it.

Algorithm changes

Stage 2 expansion and pruning

New; the previous head's version was written against the old memo and is replaced.

• Problem: at PR 4's head every planning run stopped at Stage 2's todo!().

• After:

  Step	Code	What it decides
  1. Offered values	catalog/configurations.rs enumerate_candidate_configurations	τ = QueryTime always; IngestionTime only for a candidate whose group is time-independent (GroupProperties::depends_on_evaluation_time false) or an input of one (ingestion_time_offered_per_group), and for a counter state (rate/increase/irate) only when its rows are ordered (max_out_of_order_ms declared, or PromQL rows); ℓ = None, OneEvaluation(Memory), and AcrossEvaluations(Memory) only for a chain or a group with a known evaluation_grid_of_group. Values not offered are not recorded
  2. Prune rules (levels 3–4)	same	CountMinWeightsNotProvenNonNegative, NoIngestionPipeline (IT, arrival AtRest/Unknown), RawDataNotRetained (a Scan at QT, or materialized across evaluations: either retains raw rows), QueryTimeResultsNotRetained (QT AcrossEvaluations)
  3. Physical edges	catalog/mod.rs	Pass 2's edges in (consumer, input) chunks; every pair of the two candidates' alternatives, $\alpha^{\log}$ copied, $\alpha^{\mathrm{phys}}$ = producer_satisfies_physical_requirements(producer, consumer_timing)
  4. Unusable alternatives	catalog/pruning.rs	InputHasNoBuildableProducer (least fixed point of "every input has a buildable admissible producer"), ReachesNoQueryOutput (not reached from a query output: an alternative of a root group a query-time consumer may read)
  5. Output	PhysicalASAPMemoCandidates::new	emitted candidates renumbered; edges grouped by (consumer, input) with a stable sort; admissible-edge indexes (HashMap<(consumer, input), Vec<PhysicalEdgeId>>, Vec<Vec<PhysicalEdgeId>> by producer) built once

  Candidates Pass 2 eliminated (LogicalASAPMemoCandidates::pruned) are not expanded. Stage 2 checks no executor support and costs nothing; alignment with each execution context stays Stage 3's (PhysicalCandidate::delivers_on, PR 1).

• Correctness: an emitted candidate has, for each input, an admissible edge from an emitted producer, and is reachable from a query output (checked by every test's generate helper, which also checks the edge order and the indexes); a pruned alternative is recorded exactly once, with the first reason that applies (the Count-Min sign is checked first: it holds for every (τ, ℓ)).

• Complexity: O(|C|·5) alternatives; O(Σ_{(c,i)} |alt(c)|·Σ_u |alt(u)|) ≤ 25·|logical edges| physical edges; the buildable fixed point O(depth·|E|), reach O(|E|).

• Assumptions and limits: Memory storage only (the capabilities offer no disk, Executor: store Disk-medium materialized views and one-evaluation results on disk #1217); no executor-support check (G4/H3: executor gaps are PR 6's).

Representation: PhysicalCandidate { logical_candidate_id, physical_properties }; PhysicalEdge { …, satisfies_logical_requirement, satisfies_physical_requirement }; PrunedCandidate<PhysicalCandidate> { candidate, reason }. Enumeration: every offered (τ, ℓ) per kept logical candidate; every producer/consumer alternative pair per logical edge. Stage 3 chooses.

Decisions and open questions

Needs reviewer decision: None.

Decided:

• 2026-11-07: F1–F3 and D1–D13 of the PR 5 review; G2-counter; G4/H3 (no executor-support check anywhere); L8a (Count-Min prune via column_sign); time indexing (any grid-evaluated group may be AcrossEvaluations).
• 2026-11-09: WeightDomain deleted in PR 5 (rejected: keeping a per-update proof set by Pass 1 and checked by the executor).
• 2026-11-09 (N7, was N1 here): PhysicalEdge::is_admissible renamed is_logically_and_physically_admissible before landing (the name says both requirements; no alias). Rejected: is_admissible.
• 2026-11-09 (N7, was N2): reads_only_time_series is the group property GroupProperties::reads_only_time_series, derived once in PR 2; the recursive asap_types::stages::reads_only_time_series is gone. Example: for rate(c_total[5m])'s chain over Scan(TimeSeries c_total) it is true, so the counter chain is offered ingestion time with max_out_of_order_ms: None; over Scan(Table events) false, so only with Some(_).
• 2026-11-09 (N3, D11): shared memo fixtures under test-support (above).
• C1 (R6): QueryTimeResultsNotRetained prunes only (QueryTime, AcrossEvaluations). The prune-reason table and PR 0's comment said OneEvaluation too; the decision-tree diagram, DeploymentCapabilities::query_time_results_retained (default false) and the old PR 5 said AcrossEvaluations only. Rejected: OneEvaluation too, which with default capabilities removes every within-evaluation sharing (C3: a None producer has at most one consumer per context). Query A keeps the readout's (QT, OneEvaluation) and prunes its (QT, AcrossEvaluations). The concepts doc's row now reads "QueryTime with ℓ = AcrossEvaluations".
• C2 (R7): ingestion time is offered through inputs transitively (the closure). Rejected: a one-level rule, which could not build anything below an @ T. Example: sum_over_time(m[1m] @ 1000): TimeShift @1000 is time-independent; its input TimeRange 1m and that one's Scan are offered (IT, None) (an_at_t_subtree_is_offered_ingestion_time). Without @ T the closure adds nothing.
• C3 (R7): the Count-Min weight sign is read from the build's own state group (Stage 0 derives it from the weight: a constant's sign, or the weight column's column_sign), equal for every candidate of the group. Rejected: a second derivation of the weight's sign. Example: CmsWithHeap keyed by series, weighted by SampleValue of m: pruned in all three alternatives (QT None, QT One, IT None) without a declaration, offered with column_signs: {"value": "non_negative"} (a_count_min_build_needs_weights_proven_non_negative).
• C4 (R7, review G3): a query reads its output as a query-time consumer: any query-time alternative of a root group and (IngestionTime, AcrossEvaluations); (IngestionTime, None) is not, since its result is gone when the query runs. Example: sum_over_time(m[1m] @ 1000)'s root TimeShift keeps (QT, None) and (QT, OneEvaluation); its (IT, None) is ReachesNoQueryOutput.
• C5 (R7): the executor no longer refuses rate-weighted updates in create_planner_accumulator (with the proof gone the factory cannot tell a rate weight from a sum weight); typed binding of window-weighted heaps listed for PR 6.
• A4 (2026-11-09): no summary build (SummaryAgg, chain, MaintainPopulation) is offered (IngestionTime, None): fed at ingestion it keeps its state between batches, so it is materialized; matches the exported plan's validation. Downstream: example 3a and o11y q18/q21 get valid plans (PR 9 snapshots).
• A7 (2026-11-09, option (a)): under an absolute @ T with no known horizon end, no AcrossEvaluations candidate (its consumer reaches back horizon end − T + range, unbounded); it still runs at query time. Example: x @ 1700000000 [5m]: the scan keeps (QT, None), (QT, OneEvaluation), (IT, None). A producer deeper below (a chain under the TimeRange) is not excluded here: Stage 3 gives it no $h_v$ (PR 7, P4).
• Fix (2026-11-09): RawDataNotRetained also rejects an ingestion-time Scan materialized across evaluations (it retains raw rows; a no-raw plan held a raw Scan buffer at ingestion). PruneReason doc, planner-layering.md, asap-aware-mapping-contracts.md and the concepts doc prune table say so.

Verification

cargo fmt --all -- --check, cargo clippy --workspace --all-features --all-targets -- -D warnings clean; crate_graph passes. Per crate cargo test -p <crate> --all-features. By test name against the base PR 4 (5d3f6de85): 0 newly failing, 13 newly passing (the new Stage 2 tests), 2 removed (weighted_topk_binding::rate_updates_cannot_enter_integer_heap_factory, hydra_cms_execution::unknown_sign_weight_is_rejected, with the checks they tested).

Scope	Passed / failed / ignored	Newly failing vs base	Notes (where failures stop)
asap-types	206 / 0 / 0	0
asap-accuracy	24 / 0 / 0	0
asap-cost	31 / 1 / 0	0	PR 6: θ on the exported node (1)
asap-frontend-common	49 / 0 / 0	0
asap-sql-function-catalog	10 / 0 / 0	0
metricsql_common	3 / 0 / 0	0
asap-frontend-promql	218 / 0 / 0	0
asap-frontend-metricsql	15 / 0 / 0	0
asap-frontend-sql	175 / 0 / 0	0
asap-executor	209 / 62 / 1	0	PR 6: θ on the node (32), Hydra grid θ (12), retention_ms = $h_v$ (8), weighted-frequency θ (7 + 2), baseline MILP (1)
asap-planner	8 / 18 / 1	0	PR 6: baseline MILP (18)
asap-devtools	37 / 56 / 3	0	PR 6: baseline MILP (41); PR 9: group node from expression (9), group label (2), pruned candidates (2, #1205); output.status.success() (2)
asap-integration-tests	100 / 50 / 4	0	PR 6: baseline MILP (43), retention_ms (3), avg sum-and-count plan (3); old-wire fixture JSON (1)
asap-stage3-plan-selection	3 / 0 / 0	0
asap-stage0-memo	15 / 0 / 0	0
asap-stage2-physical-optimization	13 / 0 / 0	0	all new
asap-stage1-pass2-reuse-candidates	25 / 0 / 0	0
asap-stage1-pass1-per-computation-candidates	32 / 0 / 0	0
Total	1173 / 187 / 9	0

New tests (Stage 2, catalog::tests): offers_each_candidate_its_timings_and_lifetimes (query A's offered values); no_summary_build_is_offered_at_ingestion_time_without_a_lifetime (A4); without_an_ingestion_pipeline_nothing_runs_at_ingestion_time; without_raw_data_only_ingestion_time_builds_read_the_scan (raw data not retained, incl. the materialized ingestion-time scan); query_time_results_across_evaluations_need_the_deployment_to_retain_them (C1); an_at_t_subtree_is_offered_ingestion_time (C2); a_subtree_under_an_absolute_anchor_is_not_materialized_across_evaluations (A7); a_counter_state_runs_at_ingestion_time_over_ordered_rows (SQL vs PromQL, bound declared or not); a_count_min_build_needs_weights_proven_non_negative (C3); edges_carry_both_requirements (12 edges, α^log/α^phys); an_input_without_an_admissible_producer_is_not_buildable; candidates_pass_2_eliminated_are_not_expanded; a_scalar_roots_operand_is_a_query_output.

Self-review: no new abstraction (no Stage 2 input struct (F2), no new prune reason, no executor-support table); two admissible-producer indexes stay (before pruning by provisional index, after by ID; D6 allows both, both call is_logically_and_physically_admissible); duplication removed (reads_only_time_series, one set of memo fixtures, one weight-sign derivation); no dead code added. The concepts doc's D13.2 crate path is already stage2-physical-optimization. Screenshots and measurements: not applicable.

Follow-ups

• Stage 3 baseline selection and plan output: PR 6 (refactor(stage3): baseline selection MILP and its PhysicalASAPDAG; executor θ, native chains and a time-indexed store (#1207 PR 6) #1236); typed binding of rate-weighted heap updates listed there (C5).
• Disk storage alternatives: Executor: store Disk-medium materialized views and one-evaluation results on disk #1217.
• @ T producers deeper below: Stage 3 gives them no $h_v$ (PR 7, P4).