From a19dbfb5f89fb6f6e25b06c040afdb73a276c2fe Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Tue, 30 Jun 2026 22:45:38 -0400
Subject: [PATCH 01/78] eval: observe-only predicted-footprint hook on
 CacheManager (trace level >= 2)

Add a predict_hook to CacheManager, mirroring shaped_product_hook but
observe-only: consulted at each binary Product node before materialization
(self-gated on the eval trace level) to emit a "Predict" line naming the op
and its predicted result footprint. This names an intermediate that exhausts
memory even when it dies materializing (the post-hoc Eval line never prints
for such an op).

The hook is propagated into the batched scratch cache; batched products carry
no shaped-product hook, so they are reported as unshaped(batched). The TA
backend factory make_predict_hook() builds the hook from a TAEvalContext,
reusing the shaped hook's result-outer-trange computation and a ToT
average-inner-extent estimate to predict the footprint.
---
 .../eval/backends/tiledarray/eval_context.hpp | 118 ++++++++++++++++++
 SeQuant/core/eval/cache_manager.hpp           |  30 +++++
 SeQuant/core/eval/eval.hpp                    |  22 +++-
 3 files changed, 168 insertions(+), 2 deletions(-)

diff --git a/SeQuant/core/eval/backends/tiledarray/eval_context.hpp b/SeQuant/core/eval/backends/tiledarray/eval_context.hpp
index fd5310a978..975edb15b8 100644
--- a/SeQuant/core/eval/backends/tiledarray/eval_context.hpp
+++ b/SeQuant/core/eval/backends/tiledarray/eval_context.hpp
@@ -6,15 +6,57 @@
 #include <SeQuant/core/eval/backends/tiledarray/eval_expr.hpp>
 #include <SeQuant/core/eval/backends/tiledarray/result.hpp>
 #include <SeQuant/core/eval/cache_manager.hpp>
+#include <SeQuant/core/logger.hpp>
 
 #include <tiledarray.h>
 
+#include <algorithm>
 #include <any>
+#include <cstddef>
 #include <functional>
 #include <optional>
 
 namespace sequant {
 
+namespace detail {
+
+/// Average nested-scalar count per outer element of a ToT operand result
+/// (total scalar count / dense outer-element count); 1.0 for a flat or scalar
+/// operand. Used only on the gated predicted-footprint trace path, so the
+/// collective size reduction it performs (size_in_bytes sums over ranks) is
+/// paid only when tracing. For a ToT * T contraction the surviving inner
+/// (e.g. the PNO index) comes from the ToT operand, so this factor lifts the
+/// result's outer-element prediction to a full nested-size prediction.
+template <typename NumericT, typename PolicyT, typename InnerTileT>
+[[nodiscard]] double tot_avg_inner_factor(Result const& r) {
+  using ToTArray = TA::DistArray<TA::Tensor<InnerTileT>, PolicyT>;
+  using ToTResult = ResultTensorOfTensorTA<ToTArray>;
+  if (!r.is<ToTResult>()) return 1.0;
+  auto const& a = r.template get<ToTArray>();
+  std::size_t outer = 1;
+  for (std::size_t d = 0; d < a.trange().rank(); ++d)
+    outer *= a.trange().dim(d).extent();
+  if (outer == 0) return 1.0;
+  double const total_scalars = static_cast<double>(r.size_in_bytes()) /
+                               static_cast<double>(sizeof(NumericT));
+  return total_scalars / static_cast<double>(outer);
+}
+
+/// Nonzero outer-element count over a result TiledRange, honoring an optional
+/// SparseShape (sum of kept-tile element volumes); the full element volume when
+/// the shape is absent (dense / unconstrained). O(total tiles).
+[[nodiscard]] inline std::size_t pred_outer_elems(
+    TA::TiledRange const& tr,
+    std::optional<TA::SparseShape<float>> const& shape) {
+  if (!shape) return tr.elements_range().volume();
+  std::size_t n = 0;
+  for (auto const& idx : tr.tiles_range())
+    if (!shape->is_zero(idx)) n += tr.make_tile_range(idx).volume();
+  return n;
+}
+
+}  // namespace detail
+
 /// \brief Backend context for the TiledArray eval backend.
 ///
 /// Holds TiledArray-specific evaluation state that travels with the
@@ -131,6 +173,82 @@ struct TAEvalContext {
               left, right, annot, *shape, de_nest);
         };
   }
+
+  /// Build an observe-only predicted-footprint hook for
+  /// CacheManager::set_predict_hook() from a TAEvalContext.
+  ///
+  /// The hook, consulted at a binary-Product node *before* materialization
+  /// (only when tracing), computes the result's outer TiledRange from the
+  /// operands, mirrors the shaping decision WITHOUT materializing (consulting
+  /// the result_shape_provider only when \p shapeable -- i.e. when the same
+  /// cache actually carries a shaped-product hook; the batched scratch does
+  /// not, so its products are predicted dense), estimates the result footprint
+  /// (outer-element count from the trange/shape times the ToT operand's average
+  /// inner extent), and emits a "Predict" trace line.  It never alters the
+  /// result.  Template parameters match make_hook().
+  template <typename NumericT, typename PolicyT,
+            typename InnerTileT = TA::Tensor<NumericT>>
+  static CacheManager<FullBinaryNode<EvalExprTA>>::predict_hook_type
+  make_predict_hook(TAEvalContext const& ctx) {
+    auto provider = ctx.result_shape_provider;
+    return [provider = std::move(provider)](
+               std::any const& node_any, Result const& left,
+               Result const& right, std::array<std::any, 3> const& annot,
+               bool shapeable) -> void {
+      if (Logger::instance().eval.level < 2) return;
+
+      auto const& node =
+          std::any_cast<
+              std::reference_wrapper<FullBinaryNode<EvalExprTA> const>>(
+              node_any)
+              .get();
+
+      using FlatArray = TA::DistArray<TA::Tensor<NumericT>, PolicyT>;
+      using ToTArray = TA::DistArray<TA::Tensor<InnerTileT>, PolicyT>;
+      using FlatResult = ResultTensorTA<FlatArray>;
+      using ToTResult = ResultTensorOfTensorTA<ToTArray>;
+      auto is_tensor_like = [](Result const& r) {
+        return r.is<FlatResult>() || r.is<ToTResult>();
+      };
+      if (!is_tensor_like(left) || !is_tensor_like(right)) return;
+
+      auto const trange =
+          result_outer_trange_from_results<NumericT, PolicyT, InnerTileT>(
+              left, right, annot);
+
+      // Mirror the shaping decision without materializing: a shape is consulted
+      // (and reported) only when this cache will actually try to shape it.
+      std::optional<TA::SparseShape<float>> shape =
+          (shapeable && provider) ? provider(node, trange) : std::nullopt;
+
+      double const inner =
+          node->tot()
+              ? std::max(
+                    detail::tot_avg_inner_factor<NumericT, PolicyT, InnerTileT>(
+                        left),
+                    detail::tot_avg_inner_factor<NumericT, PolicyT, InnerTileT>(
+                        right))
+              : 1.0;
+      std::size_t const outer = detail::pred_outer_elems(trange, shape);
+      auto const& tiles = trange.tiles_range();
+      std::size_t total_tiles = tiles.volume(), nz_tiles = total_tiles;
+      if (shape) {
+        nz_tiles = 0;
+        for (auto const& idx : tiles)
+          if (!shape->is_zero(idx)) ++nz_tiles;
+      }
+      std::size_t const pred_bytes =
+          static_cast<std::size_t>(static_cast<double>(outer) * inner *
+                                   static_cast<double>(sizeof(NumericT)));
+
+      char const* const shape_str = !shapeable ? "unshaped(batched)"
+                                    : shape    ? "SHAPED"
+                                               : "plain";
+      write_log(Logger::instance(), "Predict", " | ", node->label(),
+                " | shape=", shape_str, " | nnz_tiles=", nz_tiles, "/",
+                total_tiles, " | pred_result=", pred_bytes, "B", '\n');
+    };
+  }
 };
 
 }  // namespace sequant
diff --git a/SeQuant/core/eval/cache_manager.hpp b/SeQuant/core/eval/cache_manager.hpp
index 92fcdb8052..08e321488f 100644
--- a/SeQuant/core/eval/cache_manager.hpp
+++ b/SeQuant/core/eval/cache_manager.hpp
@@ -70,6 +70,23 @@ class CacheManager {
       std::any const& node, Result const& left, Result const& right,
       std::array<std::any, 3> const& annot)>;
 
+  /// An observe-only predicted-footprint hook.  `evaluate()` consults it (if
+  /// set, and only when tracing) at each binary-Product node *before* the
+  /// product is computed.  Unlike shaped_product_hook it NEVER replaces the
+  /// result: it emits a pre-materialization "Predict" trace line giving the
+  /// predicted result footprint (and, when \p shapeable, the result-shape
+  /// decision), so an op that exhausts memory is still named in the log -- the
+  /// post-hoc Eval line never prints for an OOMing op.  \p shapeable tells the
+  /// hook whether this cache will actually try to shape the product (true iff a
+  /// shaped-product hook is set on the same cache): the batched scratch carries
+  /// the predict hook but no shaped hook, so its products materialize dense and
+  /// must be predicted as dense.  All backend-specific types (TA tranges,
+  /// shapes) stay inside the hook's closure; the generic CacheManager and eval
+  /// see only Result/std::any.
+  using predict_hook_type = std::function<void(
+      std::any const& node, Result const& left, Result const& right,
+      std::array<std::any, 3> const& annot, bool shapeable)>;
+
  private:
   using hasher_type = TreeNodeHasher<TreeNode, force_hash_collisions>;
   using comparator_type = TreeNodeEqualityComparator<TreeNode>;
@@ -169,6 +186,8 @@ class CacheManager {
 
   shaped_product_hook_type shaped_product_hook_{};
 
+  predict_hook_type predict_hook_{};
+
  public:
   /// Sets the custom evaluator (see custom_evaluator_type). Pass an empty
   /// std::function to clear it.
@@ -193,6 +212,17 @@ class CacheManager {
     return shaped_product_hook_;
   }
 
+  /// Sets the predicted-footprint hook (see predict_hook_type). Pass an empty
+  /// std::function to clear it.
+  void set_predict_hook(predict_hook_type fn) noexcept {
+    predict_hook_ = std::move(fn);
+  }
+
+  /// \return the predicted-footprint hook (empty if none is set).
+  [[nodiscard]] predict_hook_type const& predict_hook() const noexcept {
+    return predict_hook_;
+  }
+
   /// Default persistence classifier: every entry is non-persistent (NP).
   struct all_non_persistent {
     bool operator()(key_type const&) const noexcept { return false; }
diff --git a/SeQuant/core/eval/eval.hpp b/SeQuant/core/eval/eval.hpp
index 6b3a21bf75..c34387fa7a 100644
--- a/SeQuant/core/eval/eval.hpp
+++ b/SeQuant/core/eval/eval.hpp
@@ -612,6 +612,19 @@ ResultPtr evaluate(Node const& node,  //
           [&]() { result = left->sum(*right, ann); });
     } else {
       SEQUANT_ASSERT(node->op_type() == EvalOp::Product);
+      // Observe-only predicted-footprint trace: consulted BEFORE materializing
+      // the product, so an op that exhausts memory is still named in the log
+      // (the post-hoc Eval line below never prints for an OOMing op). Gated on
+      // trace + level so it is inert by default; the batched scratch carries
+      // this hook too (see make_batched_scratch), so batched products -- which
+      // do NOT consult the shaped-product hook -- are still predicted (as
+      // dense, via the shapeable=false argument).
+      if constexpr (detail::trace(EvalTrace)) {
+        if (auto const& ph = cache.predict_hook();
+            ph && log::printing() && Logger::instance().eval.level >= 2)
+          ph(std::any{std::cref(node)}, *left, *right, ann,
+             static_cast<bool>(cache.shaped_product_hook()));
+      }
       // Consult the shaped-product hook (if set) before evaluating the product.
       // The hook receives the node (wrapped in a std::any as a
       // std::reference_wrapper so the full IR node is inspectable) plus the
@@ -1127,8 +1140,13 @@ template <typename TreeNode, bool FHC, typename Members>
   auto is_persistent = [seed_keys = std::move(seed_keys)](TreeNode const& n) {
     return seed_keys.contains(n);
   };
-  return {CacheManager<TreeNode, FHC>{std::move(reg), std::move(is_persistent)},
-          std::move(seeds)};
+  CacheManager<TreeNode, FHC> scratch{std::move(reg), std::move(is_persistent)};
+  // Carry the observe-only predicted-footprint hook into the scratch so batched
+  // products are predicted too; deliberately NOT the shaped-product hook --
+  // batched products stay unshaped (existing behavior), which the predict hook
+  // reflects via shapeable=false (it has no shaped hook here).
+  scratch.set_predict_hook(real.predict_hook());
+  return {std::move(scratch), std::move(seeds)};
 }
 
 }  // namespace detail

From 691bb427d370b7b5711b945add08887305dbcff2 Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Wed, 1 Jul 2026 19:52:58 -0400
Subject: [PATCH 02/78] eval: optional backend heap-stats suffix on the eval
 trace line

Add Logger::eval.heap_stats (std::function<std::string()>); when set, its
(already rank-reduced) return is appended to each Eval line after rss=, and
omitted entirely when unset. Lets a backend report allocator-level memory
(e.g. glibc all-arena in-use vs system) right at an RSS jump, to separate
live heap from retained-free heap.
---
 SeQuant/core/eval/eval.hpp | 42 +++++++++++++++++++++++---------------
 SeQuant/core/logger.hpp    | 13 +++++++++++-
 2 files changed, 38 insertions(+), 17 deletions(-)

diff --git a/SeQuant/core/eval/eval.hpp b/SeQuant/core/eval/eval.hpp
index c34387fa7a..ecbd4fca53 100644
--- a/SeQuant/core/eval/eval.hpp
+++ b/SeQuant/core/eval/eval.hpp
@@ -198,7 +198,7 @@ enum struct TermMode { Begin, End };
 /// One log record per eval op. Line format:
 ///
 // clang-format off
-/// Eval | <mode> | <time> | [left=L | right=R |] result=X | alloc=A | hw=H | rss=R | <label>
+/// Eval | <mode> | <time> | [left=L | right=R |] result=X | alloc=A | hw=H | rss=R | [<heap suffix> |] <label>
 // clang-format on
 ///
 /// Which fields are set depends on the op's arity:
@@ -281,21 +281,31 @@ auto eval(EvalStat const& stat, Args const&... args) {
   auto const rss_s = std::format(
       "rss={}",
       to_string(Bytes{rss_reduce ? rss_reduce(rss_local) : rss_local}));
-  if (stat.mem_left) {
-    SEQUANT_ASSERT(stat.mem_right);
-    log("Eval",                                               //
-        to_string(stat.mode),                                 //
-        stat.time,                                            //
-        std::format("left={}", to_string(*stat.mem_left)),    //
-        std::format("right={}", to_string(*stat.mem_right)),  //
-        result_s, alloc_s, hw_s, rss_s,                       //
-        args...);
-  } else {
-    log("Eval",                //
-        to_string(stat.mode),  //
-        stat.time,             //
-        result_s, alloc_s, hw_s, rss_s, args...);
-  }
+  // Optional backend-supplied suffix (already reduced across ranks); omitted
+  // entirely when the hook is unset or returns empty.
+  auto const& heap_stats = Logger::instance().eval.heap_stats;
+  auto const heap_s = heap_stats ? heap_stats() : std::string{};
+  auto emit = [&](auto const&... trailer) {
+    if (stat.mem_left) {
+      SEQUANT_ASSERT(stat.mem_right);
+      log("Eval",                                               //
+          to_string(stat.mode),                                 //
+          stat.time,                                            //
+          std::format("left={}", to_string(*stat.mem_left)),    //
+          std::format("right={}", to_string(*stat.mem_right)),  //
+          result_s, alloc_s, hw_s, rss_s,                       //
+          trailer...);
+    } else {
+      log("Eval",                //
+          to_string(stat.mode),  //
+          stat.time,             //
+          result_s, alloc_s, hw_s, rss_s, trailer...);
+    }
+  };
+  if (heap_s.empty())
+    emit(args...);
+  else
+    emit(heap_s, args...);
 }
 
 template <typename... Args>
diff --git a/SeQuant/core/logger.hpp b/SeQuant/core/logger.hpp
index ed5fff3f80..bf441388a4 100644
--- a/SeQuant/core/logger.hpp
+++ b/SeQuant/core/logger.hpp
@@ -51,7 +51,18 @@ struct Logger : public Singleton<Logger> {
     /// (printing() is level>0, identical across ranks), so a collective reducer
     /// here is matched across ranks. Empty = report this rank's RSS unchanged.
     std::function<std::size_t(std::size_t)> rss_reduce = {};
-  } eval = {0, nullptr, {}};
+
+    /// Optional supplier of an extra, backend-defined suffix appended to each
+    /// eval-trace line (after the rss field). Injected by the tensor-algebra
+    /// backend to report allocator-level memory that RSS alone cannot
+    /// distinguish -- e.g. glibc all-arena in-use vs system bytes, so one can
+    /// tell live heap from retained-free heap right at an RSS jump. Runs on
+    /// EVERY rank on the eval log path (printing() is level>0, identical across
+    /// ranks), so an injected collective reduction here is matched across
+    /// ranks. Returns a preformatted, already-reduced string (e.g.
+    /// "heap_inuse=...B | heap_sys=...B"); empty function = omit the suffix.
+    std::function<std::string()> heap_stats = {};
+  } eval = {0, nullptr, {}, {}};
 
  private:
   friend class Singleton<Logger>;

From 8e239062e944c60ec054e18e622f64a8c9e5b4e5 Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Wed, 1 Jul 2026 23:08:13 -0400
Subject: [PATCH 03/78] eval: optional post-op memory-release hook (malloc_trim
 between ops)

Add Logger::eval.release_memory (std::function<void()>) and call it via
log::release_after_op() after each freshly evaluated op in evaluate(),
regardless of trace level. Lets a backend return retained-free heap to the
OS between ops -- e.g. the large per-batch transients freed while building a
batched DF leaf -- so they do not linger as allocator-retained free pages
and inflate RSS before the next big op allocates. Local/non-collective by
contract; empty hook = no-op (default).
---
 SeQuant/core/eval/eval.hpp | 11 +++++++++++
 SeQuant/core/logger.hpp    | 12 +++++++++++-
 2 files changed, 22 insertions(+), 1 deletion(-)

diff --git a/SeQuant/core/eval/eval.hpp b/SeQuant/core/eval/eval.hpp
index ecbd4fca53..d610025184 100644
--- a/SeQuant/core/eval/eval.hpp
+++ b/SeQuant/core/eval/eval.hpp
@@ -347,6 +347,15 @@ inline auto term(TermMode mode, std::string_view term) {
   log("Term", to_string(mode), term);
 }
 
+/// Invoke the optional post-op memory-release hook
+/// (Logger::eval.release_memory) if set. Called after each freshly evaluated op
+/// regardless of trace level, so a large transient's freed pages can be
+/// returned before the next op allocates. The injected hook self-throttles;
+/// empty hook = no-op.
+inline void release_after_op() {
+  if (auto const& rel = Logger::instance().eval.release_memory; rel) rel();
+}
+
 [[nodiscard]] auto label(meta::eval_node auto const& node) {
   return node->is_primary()
              ? node->label()
@@ -591,6 +600,7 @@ ResultPtr evaluate(Node const& node,  //
                                       log::bytes(cache, intercepted).value)}},
                     log::label(node));
         }
+        log::release_after_op();
         return intercepted;
       }
     }
@@ -695,6 +705,7 @@ ResultPtr evaluate(Node const& node,  //
     }
   }
 
+  log::release_after_op();
   return result;
 }
 
diff --git a/SeQuant/core/logger.hpp b/SeQuant/core/logger.hpp
index bf441388a4..2f93782cc5 100644
--- a/SeQuant/core/logger.hpp
+++ b/SeQuant/core/logger.hpp
@@ -62,7 +62,17 @@ struct Logger : public Singleton<Logger> {
     /// ranks. Returns a preformatted, already-reduced string (e.g.
     /// "heap_inuse=...B | heap_sys=...B"); empty function = omit the suffix.
     std::function<std::string()> heap_stats = {};
-  } eval = {0, nullptr, {}, {}};
+
+    /// Optional post-op memory-release hook, invoked after each freshly
+    /// evaluated op (leaf/product/sum) regardless of trace level -- so a large
+    /// transient's freed pages can be returned to the OS before the next op
+    /// allocates, rather than lingering as allocator-retained free heap. The
+    /// injected hook is expected to self-throttle (a cheap no-op when little is
+    /// reclaimable) since it runs per op. Local/non-collective by contract
+    /// (e.g. glibc malloc_trim), so it needs no cross-rank matching. Empty
+    /// function = no release (default).
+    std::function<void()> release_memory = {};
+  } eval = {0, nullptr, {}, {}, {}};
 
  private:
   friend class Singleton<Logger>;

From bc5bd6cb5cf679e8bf1204620b3808d63f90124c Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Fri, 3 Jul 2026 12:43:22 -0400
Subject: [PATCH 04/78] eval: remove the observe-only predicted-footprint
 (predict) hook

The eval-time footprint estimate lifted the result's dense outer volume by
an operand's average inner density (size_in_bytes / dense outer volume). That
borrows the operand's fill, so it underestimates any contraction whose result
is denser than its operands -- most severely the free-mu~ giant g(mu~,mu~,K).C,
where the free mu~ spreads from the per-pair domain to the full range (~3x low
in practice). It is also computed from materialized operand sizes, which are
not what the factorizer's analytic cost model uses, so it cannot reflect or
validate the tree it chose. Its one unique feature -- naming an op that OOMs
before its post-hoc Eval line prints -- does not survive the real failure mode
(async SIGBUS / OOM-kill), where the buffered Predict line never flushes.

Remove make_predict_hook and its tot_avg_inner_factor / pred_outer_elems
helpers, predict_hook_type, set_predict_hook / predict_hook(), the eval-time
consultation in evaluate(), and the make_batched_scratch propagation. The
post-hoc Eval line (actual sizes) and the shaped-product hook are unchanged.
---
 .../eval/backends/tiledarray/eval_context.hpp | 115 ------------------
 SeQuant/core/eval/cache_manager.hpp           |  30 -----
 SeQuant/core/eval/eval.hpp                    |  18 ---
 3 files changed, 163 deletions(-)

diff --git a/SeQuant/core/eval/backends/tiledarray/eval_context.hpp b/SeQuant/core/eval/backends/tiledarray/eval_context.hpp
index 975edb15b8..ef9b1440a9 100644
--- a/SeQuant/core/eval/backends/tiledarray/eval_context.hpp
+++ b/SeQuant/core/eval/backends/tiledarray/eval_context.hpp
@@ -18,45 +18,6 @@
 
 namespace sequant {
 
-namespace detail {
-
-/// Average nested-scalar count per outer element of a ToT operand result
-/// (total scalar count / dense outer-element count); 1.0 for a flat or scalar
-/// operand. Used only on the gated predicted-footprint trace path, so the
-/// collective size reduction it performs (size_in_bytes sums over ranks) is
-/// paid only when tracing. For a ToT * T contraction the surviving inner
-/// (e.g. the PNO index) comes from the ToT operand, so this factor lifts the
-/// result's outer-element prediction to a full nested-size prediction.
-template <typename NumericT, typename PolicyT, typename InnerTileT>
-[[nodiscard]] double tot_avg_inner_factor(Result const& r) {
-  using ToTArray = TA::DistArray<TA::Tensor<InnerTileT>, PolicyT>;
-  using ToTResult = ResultTensorOfTensorTA<ToTArray>;
-  if (!r.is<ToTResult>()) return 1.0;
-  auto const& a = r.template get<ToTArray>();
-  std::size_t outer = 1;
-  for (std::size_t d = 0; d < a.trange().rank(); ++d)
-    outer *= a.trange().dim(d).extent();
-  if (outer == 0) return 1.0;
-  double const total_scalars = static_cast<double>(r.size_in_bytes()) /
-                               static_cast<double>(sizeof(NumericT));
-  return total_scalars / static_cast<double>(outer);
-}
-
-/// Nonzero outer-element count over a result TiledRange, honoring an optional
-/// SparseShape (sum of kept-tile element volumes); the full element volume when
-/// the shape is absent (dense / unconstrained). O(total tiles).
-[[nodiscard]] inline std::size_t pred_outer_elems(
-    TA::TiledRange const& tr,
-    std::optional<TA::SparseShape<float>> const& shape) {
-  if (!shape) return tr.elements_range().volume();
-  std::size_t n = 0;
-  for (auto const& idx : tr.tiles_range())
-    if (!shape->is_zero(idx)) n += tr.make_tile_range(idx).volume();
-  return n;
-}
-
-}  // namespace detail
-
 /// \brief Backend context for the TiledArray eval backend.
 ///
 /// Holds TiledArray-specific evaluation state that travels with the
@@ -173,82 +134,6 @@ struct TAEvalContext {
               left, right, annot, *shape, de_nest);
         };
   }
-
-  /// Build an observe-only predicted-footprint hook for
-  /// CacheManager::set_predict_hook() from a TAEvalContext.
-  ///
-  /// The hook, consulted at a binary-Product node *before* materialization
-  /// (only when tracing), computes the result's outer TiledRange from the
-  /// operands, mirrors the shaping decision WITHOUT materializing (consulting
-  /// the result_shape_provider only when \p shapeable -- i.e. when the same
-  /// cache actually carries a shaped-product hook; the batched scratch does
-  /// not, so its products are predicted dense), estimates the result footprint
-  /// (outer-element count from the trange/shape times the ToT operand's average
-  /// inner extent), and emits a "Predict" trace line.  It never alters the
-  /// result.  Template parameters match make_hook().
-  template <typename NumericT, typename PolicyT,
-            typename InnerTileT = TA::Tensor<NumericT>>
-  static CacheManager<FullBinaryNode<EvalExprTA>>::predict_hook_type
-  make_predict_hook(TAEvalContext const& ctx) {
-    auto provider = ctx.result_shape_provider;
-    return [provider = std::move(provider)](
-               std::any const& node_any, Result const& left,
-               Result const& right, std::array<std::any, 3> const& annot,
-               bool shapeable) -> void {
-      if (Logger::instance().eval.level < 2) return;
-
-      auto const& node =
-          std::any_cast<
-              std::reference_wrapper<FullBinaryNode<EvalExprTA> const>>(
-              node_any)
-              .get();
-
-      using FlatArray = TA::DistArray<TA::Tensor<NumericT>, PolicyT>;
-      using ToTArray = TA::DistArray<TA::Tensor<InnerTileT>, PolicyT>;
-      using FlatResult = ResultTensorTA<FlatArray>;
-      using ToTResult = ResultTensorOfTensorTA<ToTArray>;
-      auto is_tensor_like = [](Result const& r) {
-        return r.is<FlatResult>() || r.is<ToTResult>();
-      };
-      if (!is_tensor_like(left) || !is_tensor_like(right)) return;
-
-      auto const trange =
-          result_outer_trange_from_results<NumericT, PolicyT, InnerTileT>(
-              left, right, annot);
-
-      // Mirror the shaping decision without materializing: a shape is consulted
-      // (and reported) only when this cache will actually try to shape it.
-      std::optional<TA::SparseShape<float>> shape =
-          (shapeable && provider) ? provider(node, trange) : std::nullopt;
-
-      double const inner =
-          node->tot()
-              ? std::max(
-                    detail::tot_avg_inner_factor<NumericT, PolicyT, InnerTileT>(
-                        left),
-                    detail::tot_avg_inner_factor<NumericT, PolicyT, InnerTileT>(
-                        right))
-              : 1.0;
-      std::size_t const outer = detail::pred_outer_elems(trange, shape);
-      auto const& tiles = trange.tiles_range();
-      std::size_t total_tiles = tiles.volume(), nz_tiles = total_tiles;
-      if (shape) {
-        nz_tiles = 0;
-        for (auto const& idx : tiles)
-          if (!shape->is_zero(idx)) ++nz_tiles;
-      }
-      std::size_t const pred_bytes =
-          static_cast<std::size_t>(static_cast<double>(outer) * inner *
-                                   static_cast<double>(sizeof(NumericT)));
-
-      char const* const shape_str = !shapeable ? "unshaped(batched)"
-                                    : shape    ? "SHAPED"
-                                               : "plain";
-      write_log(Logger::instance(), "Predict", " | ", node->label(),
-                " | shape=", shape_str, " | nnz_tiles=", nz_tiles, "/",
-                total_tiles, " | pred_result=", pred_bytes, "B", '\n');
-    };
-  }
 };
 
 }  // namespace sequant
diff --git a/SeQuant/core/eval/cache_manager.hpp b/SeQuant/core/eval/cache_manager.hpp
index 08e321488f..92fcdb8052 100644
--- a/SeQuant/core/eval/cache_manager.hpp
+++ b/SeQuant/core/eval/cache_manager.hpp
@@ -70,23 +70,6 @@ class CacheManager {
       std::any const& node, Result const& left, Result const& right,
       std::array<std::any, 3> const& annot)>;
 
-  /// An observe-only predicted-footprint hook.  `evaluate()` consults it (if
-  /// set, and only when tracing) at each binary-Product node *before* the
-  /// product is computed.  Unlike shaped_product_hook it NEVER replaces the
-  /// result: it emits a pre-materialization "Predict" trace line giving the
-  /// predicted result footprint (and, when \p shapeable, the result-shape
-  /// decision), so an op that exhausts memory is still named in the log -- the
-  /// post-hoc Eval line never prints for an OOMing op.  \p shapeable tells the
-  /// hook whether this cache will actually try to shape the product (true iff a
-  /// shaped-product hook is set on the same cache): the batched scratch carries
-  /// the predict hook but no shaped hook, so its products materialize dense and
-  /// must be predicted as dense.  All backend-specific types (TA tranges,
-  /// shapes) stay inside the hook's closure; the generic CacheManager and eval
-  /// see only Result/std::any.
-  using predict_hook_type = std::function<void(
-      std::any const& node, Result const& left, Result const& right,
-      std::array<std::any, 3> const& annot, bool shapeable)>;
-
  private:
   using hasher_type = TreeNodeHasher<TreeNode, force_hash_collisions>;
   using comparator_type = TreeNodeEqualityComparator<TreeNode>;
@@ -186,8 +169,6 @@ class CacheManager {
 
   shaped_product_hook_type shaped_product_hook_{};
 
-  predict_hook_type predict_hook_{};
-
  public:
   /// Sets the custom evaluator (see custom_evaluator_type). Pass an empty
   /// std::function to clear it.
@@ -212,17 +193,6 @@ class CacheManager {
     return shaped_product_hook_;
   }
 
-  /// Sets the predicted-footprint hook (see predict_hook_type). Pass an empty
-  /// std::function to clear it.
-  void set_predict_hook(predict_hook_type fn) noexcept {
-    predict_hook_ = std::move(fn);
-  }
-
-  /// \return the predicted-footprint hook (empty if none is set).
-  [[nodiscard]] predict_hook_type const& predict_hook() const noexcept {
-    return predict_hook_;
-  }
-
   /// Default persistence classifier: every entry is non-persistent (NP).
   struct all_non_persistent {
     bool operator()(key_type const&) const noexcept { return false; }
diff --git a/SeQuant/core/eval/eval.hpp b/SeQuant/core/eval/eval.hpp
index d610025184..c6d1d2e36b 100644
--- a/SeQuant/core/eval/eval.hpp
+++ b/SeQuant/core/eval/eval.hpp
@@ -632,19 +632,6 @@ ResultPtr evaluate(Node const& node,  //
           [&]() { result = left->sum(*right, ann); });
     } else {
       SEQUANT_ASSERT(node->op_type() == EvalOp::Product);
-      // Observe-only predicted-footprint trace: consulted BEFORE materializing
-      // the product, so an op that exhausts memory is still named in the log
-      // (the post-hoc Eval line below never prints for an OOMing op). Gated on
-      // trace + level so it is inert by default; the batched scratch carries
-      // this hook too (see make_batched_scratch), so batched products -- which
-      // do NOT consult the shaped-product hook -- are still predicted (as
-      // dense, via the shapeable=false argument).
-      if constexpr (detail::trace(EvalTrace)) {
-        if (auto const& ph = cache.predict_hook();
-            ph && log::printing() && Logger::instance().eval.level >= 2)
-          ph(std::any{std::cref(node)}, *left, *right, ann,
-             static_cast<bool>(cache.shaped_product_hook()));
-      }
       // Consult the shaped-product hook (if set) before evaluating the product.
       // The hook receives the node (wrapped in a std::any as a
       // std::reference_wrapper so the full IR node is inspectable) plus the
@@ -1162,11 +1149,6 @@ template <typename TreeNode, bool FHC, typename Members>
     return seed_keys.contains(n);
   };
   CacheManager<TreeNode, FHC> scratch{std::move(reg), std::move(is_persistent)};
-  // Carry the observe-only predicted-footprint hook into the scratch so batched
-  // products are predicted too; deliberately NOT the shaped-product hook --
-  // batched products stay unshaped (existing behavior), which the predict hook
-  // reflects via shapeable=false (it has no shaped hook here).
-  scratch.set_predict_hook(real.predict_hook());
   return {std::move(scratch), std::move(seeds)};
 }
 

From 17c00b9a882c8fd2bb80a401b085cc9a6a55e084 Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Fri, 3 Jul 2026 13:10:56 -0400
Subject: [PATCH 05/78] tests/optimize: C60 member-2 double-proto batching
 probe

Regression guard for the C60 PNO-CCSD OOM. The batched CSV-CCk residual
term

  g{i_3;i_1;K} C{a_1<i_1,i_2>;mu} g{mu;mu;K} C{mu;a_3<i_2,i_3>}

factorizes, under aux(K)-only batchability, into the double-proto
intermediate I(i_1,i_2,i_3,K; a_3<i_2,i_3>, a_1<i_1,i_2>) -- two 2-occ
PNO composites sharing i_2, ~185 GB materialized -- which is what OOMs on
C60 (1800 AOs, 8 ranks, 768 GB node).

The probe pins the mechanism:
  - DenseFLOPs / DensePeakSize pick a g.g-first tree that never forms the
    double-proto (max_imed 1.3e11 elems);
  - DensePeakSizeBatched with only K sliceable picks the double-proto
    (max_imed 1.8e13) -- correctly, since with K the sole batch axis the
    double-proto's K-sliced peak beats the avoiders' unsliceable mu-tilde
    intermediate;
  - making mu-tilde (PAO) batchable TOO flips STO back to the g.g-first
    tree (max_imed 1.3e11) -- the double-proto becomes avoidable.

So the OOM root cause is the too-small batchable-index set (aux only),
not a suboptimal STO or a batching-eval bug. Guards any future change to
the batched peak objective or the batchable-index policy.
---
 tests/unit/test_optimize.cpp | 132 +++++++++++++++++++++++++++++++++++
 1 file changed, 132 insertions(+)

diff --git a/tests/unit/test_optimize.cpp b/tests/unit/test_optimize.cpp
index e963dcddc8..439099a6a5 100644
--- a/tests/unit/test_optimize.cpp
+++ b/tests/unit/test_optimize.cpp
@@ -1671,6 +1671,138 @@ TEST_CASE("OSV deferral reproducer (tetramer term 3)", "[optimize][osv]") {
   CHECK(pbat_po >= osv_outer_product);  // gate restored -> OSV deferred again
 }
 
+// C60 PNO-CCSD residual "member 2": the batched intermediate that OOMs (~185 GB
+// materialized) is the double-proto I(i_1,i_2,i_3,Κ; a_3<i_2,i_3>,
+// a_1<i_1,i_2>).
+//   flat product:  g{i_3;i_1;Κ} · C{a_1<i_1,i_2>;μ̃} · g{μ̃;μ̃;Κ} ·
+//   C{μ̃;a_3<i_2,i_3>}
+// Two 2-occ PNO composites sharing i_2, no t amplitude. This probe answers:
+//  (1) does STO form the double-proto intermediate, and under which objective;
+//  (2) how does the (block-sparse) cost model size it (max_imed);
+//  (3) do the rejected brackets avoid it, i.e. does a cheaper schedule exist?
+TEST_CASE("C60 member-2 double-proto probe", "[optimize][osv][c60]") {
+  using namespace sequant;
+  auto ctx_resetter = set_scoped_default_context(get_default_context().clone());
+  auto reg = get_default_context().mutable_index_space_registry();
+  mbpt::add_df_spaces(reg);
+  mbpt::add_pao_spaces(reg);
+  mbpt::add_ao_spaces(reg);
+  // C60 cc-pVDZ-F12-ish extents: active occ 120, PNO domain 42, PAO 1800,
+  // DF aux 6000 (sliced to batch 30 by the batched objective).
+  for (auto&& [k, v] :
+       std::initializer_list<std::pair<std::wstring_view, size_t>>{
+           {L"i", 120}, {L"a", 42}, {L"μ̃", 1800}, {L"Κ", 6000}}) {
+    reg->retrieve_ptr(k)->approximate_size(v);
+  }
+  auto aux_space = reg->retrieve(L"Κ");
+  auto idxsz = [](Index const& ix) -> std::size_t {
+    return ix.nonnull() ? ix.space().approximate_size() : std::size_t{1};
+  };
+  // constant PNO domain 42 => all power means equal, neutralizing the
+  // RMS-vs-mean magnitude question; here we test STRUCTURE (which tree, is the
+  // double-proto avoidable), not the heavy-tail correction.
+  auto ip = [](Index const&, std::size_t) -> double { return 42.0; };
+  auto is_batch = [aux_space](Index const& ix) {
+    return ix.space() == aux_space;
+  };
+  std::function<std::size_t(Index const&)> bts = [](Index const&) {
+    return std::size_t{30};
+  };
+
+  auto prod = deserialize(
+                  L"g{i_3;i_1;Κ_1} C{a_1<i_1,i_2>;μ̃_1} "
+                  L"g{μ̃_1;μ̃_2;Κ_1} C{μ̃_2;a_3<i_2,i_3>}")
+                  ->as<Product>();
+
+  auto fp = opt::detail::footprint_counter(
+      idxsz, std::function<double(Index const&, std::size_t)>(ip));
+
+  std::function<std::vector<Index>(ExprPtr const&, double&)> freeix =
+      [&](ExprPtr const& e, double& mx) -> std::vector<Index> {
+    if (e->is<Tensor>()) {
+      std::vector<Index> v;
+      for (auto const& ix : e->as<Tensor>().const_braketaux_indices())
+        v.push_back(ix);
+      return v;
+    }
+    std::map<std::wstring, std::pair<int, Index>> cnt;
+    for (auto const& fct : e->as<Product>().factors())
+      for (auto const& ix : freeix(fct, mx)) {
+        auto k = std::wstring(ix.full_label());
+        cnt[k].first++;
+        cnt[k].second = ix;
+      }
+    std::vector<Index> result;
+    for (auto const& [k, v] : cnt)
+      if (v.first == 1) result.push_back(v.second);
+    double here = fp(result);
+    if (here > mx) mx = here;
+    return result;
+  };
+  struct TP {
+    double peak, leafsum, S;
+  };
+  std::function<TP(ExprPtr const&)> tree_peak = [&](ExprPtr const& e) -> TP {
+    if (e->is<Tensor>()) {
+      std::vector<Index> v;
+      for (auto const& ix : e->as<Tensor>().const_braketaux_indices())
+        v.push_back(ix);
+      double s = fp(v);
+      return TP{s, s, s};
+    }
+    auto const& facs = e->as<Product>().factors();
+    TP L = tree_peak(facs[0]);
+    TP R = tree_peak(facs[1]);
+    double dummy = 0.0;
+    double Snode = fp(freeix(e, dummy));
+    double both = L.S + R.S + Snode;
+    double lfirst = std::max({R.leafsum + L.peak, L.S + R.peak, both});
+    double rfirst = std::max({L.leafsum + R.peak, R.S + L.peak, both});
+    return TP{std::min(lfirst, rfirst), L.leafsum + R.leafsum, Snode};
+  };
+  auto report = [&](std::wstring name, ExprPtr res) {
+    double mx = 0.0;
+    freeix(res, mx);
+    double tpk = tree_peak(res).peak;
+    std::wcout << name << L"  max_imed(elems)=" << (long long)mx
+               << L"  recurrence_PEAK(elems)=" << (long long)tpk << L"\n      "
+               << render_tree(res) << L"\n";
+  };
+
+  std::wcout
+      << L"\n=== C60 MEMBER-2 (i=120, a=42, μ̃=1800, Κ=6000, batch=30) ===\n";
+  report(L"FLOPs:       ",
+         opt::single_term_opt<ObjectiveFunction::DenseFLOPs>(
+             prod, idxsz, false, CostParams{{}, 1.0, 0.0}, {}, {}, ip));
+  report(L"PeakSize:    ",
+         opt::single_term_opt<ObjectiveFunction::DensePeakSize>(
+             prod, idxsz, false, CostParams{{}, 1.0, 0.0}, {}, {}, ip));
+  report(L"PeakBatched: ",
+         opt::single_term_opt<ObjectiveFunction::DensePeakSizeBatched>(
+             prod, idxsz, false, CostParams{{}, 1.0, 0.0}, is_batch, bts, ip));
+  // Experiment: make PAO (μ̃) batchable TOO (batch 100). Prediction: STO
+  // switches away from the double-proto to a g·g-first tree whose worst
+  // intermediate carries μ̃ and is now sliceable.
+  auto mu_space = reg->retrieve(L"μ̃");
+  auto is_batch2 = [aux_space, mu_space](Index const& ix) {
+    return ix.space() == aux_space || ix.space() == mu_space;
+  };
+  std::function<std::size_t(Index const&)> bts2 = [aux_space](Index const& ix) {
+    return ix.space() == aux_space ? std::size_t{30} : std::size_t{100};
+  };
+  report(
+      L"PeakBatched(+μ̃):",
+      opt::single_term_opt<ObjectiveFunction::DensePeakSizeBatched>(
+          prod, idxsz, false, CostParams{{}, 1.0, 0.0}, is_batch2, bts2, ip));
+  // Reference: the double-proto intermediate as the model sizes it, dense at
+  // d=42 (== the block-sparse upper bound), with Κ at one batch of 30:
+  //   i^3 * Κ_batch * a * a  elements.
+  std::wcout << L"double-proto imed (i^3*Κbatch*a^2) elems = "
+             << (long long)(120.0 * 120 * 120 * 30 * 42 * 42) << L"  (="
+             << (long long)(120.0 * 120 * 120 * 30 * 42 * 42 * 8)
+             << L" B dense)\n\n";
+}
+
 TEST_CASE("PPL: form 4-PNO W vs fold-t (peak-neutral, flop tie-break)",
           "[optimize][osv]") {
   using namespace sequant;

From 7d6abf1a9e731e13eeef2c97632d77755d98f065 Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Fri, 3 Jul 2026 16:17:39 -0400
Subject: [PATCH 06/78] optimize: plumb peak_threshold (bytes) through
 BatchPolicy/CostParams to PeakBatchedModel

---
 SeQuant/core/batch_policy.hpp         | 8 ++++++++
 SeQuant/core/optimize/cost_model.hpp  | 7 +++++++
 SeQuant/core/optimize/optimize.cpp    | 3 ++-
 SeQuant/core/optimize/options.hpp     | 4 ++++
 SeQuant/core/optimize/single_term.hpp | 2 +-
 5 files changed, 22 insertions(+), 2 deletions(-)

diff --git a/SeQuant/core/batch_policy.hpp b/SeQuant/core/batch_policy.hpp
index 48c3c5cd45..def23cd992 100644
--- a/SeQuant/core/batch_policy.hpp
+++ b/SeQuant/core/batch_policy.hpp
@@ -3,6 +3,7 @@
 
 #include <cstddef>
 #include <functional>
+#include <limits>
 
 namespace sequant {
 
@@ -40,6 +41,13 @@ struct BatchPolicy {
   /// accumulator + contribution co-residency of a node that contracts a
   /// batchable index.
   double accumulation_factor = 0.0;
+
+  /// Peak-memory budget in BYTES for the batched objective. The single-term
+  /// optimizer minimizes flops among schedules whose modeled peak is <=
+  /// peak_threshold, falling back to min-peak (best effort) when none fit.
+  /// Default +infinity => every schedule feasible => min flops => no batching.
+  /// This is the *enable* trigger for batching (a finite value turns it on).
+  double peak_threshold = std::numeric_limits<double>::infinity();
 };
 
 }  // namespace sequant
diff --git a/SeQuant/core/optimize/cost_model.hpp b/SeQuant/core/optimize/cost_model.hpp
index 2b26a06e5e..a88ec7a02f 100644
--- a/SeQuant/core/optimize/cost_model.hpp
+++ b/SeQuant/core/optimize/cost_model.hpp
@@ -484,6 +484,13 @@ struct PeakBatchedModel {
   /// batchable index (Ap != 0), into the all-co-resident peak term, to price
   /// the accumulator + contribution co-residency of K += contribution.
   double accumulation_factor = 0.0;
+  /// Peak-memory budget (BYTES) for threshold-gated selection; see
+  /// BatchPolicy::peak_threshold. +infinity (default) => min-flops (no
+  /// batching).
+  double peak_threshold = std::numeric_limits<double>::infinity();
+  /// Bytes per stored element, to compare the model's element-count peak to
+  /// peak_threshold (bytes). Default 8 (double / TensorD).
+  double numeric_size = 8.0;
 
   /// One non-dominated (peak, flops) trade-off for a (subset, sliced-set \c B)
   /// cell. \c aprime is the sliced-set chosen at this node; the children are
diff --git a/SeQuant/core/optimize/optimize.cpp b/SeQuant/core/optimize/optimize.cpp
index 548768acb2..fd945c2e59 100644
--- a/SeQuant/core/optimize/optimize.cpp
+++ b/SeQuant/core/optimize/optimize.cpp
@@ -92,7 +92,8 @@ ExprPtr opt_pure_product(Product const& prod, OptimizeOptions const& opts) {
                         opts.footprint_weight,
                         opts.peak_flops_tolerance,
                         opts.roofline,
-                        opts.batch_policy.accumulation_factor};
+                        opts.batch_policy.accumulation_factor,
+                        opts.batch_policy.peak_threshold};
   auto run = [&]() -> ExprPtr {
     if (opts.objective_function == ObjectiveFunction::DenseFLOPs)
       return opt::single_term_opt<ObjectiveFunction::DenseFLOPs>(
diff --git a/SeQuant/core/optimize/options.hpp b/SeQuant/core/optimize/options.hpp
index bd3e82acdf..d320208f27 100644
--- a/SeQuant/core/optimize/options.hpp
+++ b/SeQuant/core/optimize/options.hpp
@@ -5,6 +5,7 @@
 
 #include <cstddef>
 #include <functional>
+#include <limits>
 
 namespace sequant {
 
@@ -105,6 +106,9 @@ struct CostParams {
   /// DensePeakSizeBatched; see BatchPolicy::accumulation_factor. 0 (default) =
   /// no penalty.
   double accumulation_factor = 0.0;
+  /// Peak-memory budget in BYTES for DensePeakSizeBatched; see
+  /// BatchPolicy::peak_threshold. +infinity (default) => no batching.
+  double peak_threshold = std::numeric_limits<double>::infinity();
 };
 
 /// A type-erased provider mapping an Index to its extent. Used by the public
diff --git a/SeQuant/core/optimize/single_term.hpp b/SeQuant/core/optimize/single_term.hpp
index f5699e3680..fb46a6f9cd 100644
--- a/SeQuant/core/optimize/single_term.hpp
+++ b/SeQuant/core/optimize/single_term.hpp
@@ -113,7 +113,7 @@ EvalSequence single_term_opt(
                          roofline.machine_balance, roofline.fast_mem_elems,
                          roofline.block_tiles, roofline.block_prefactor,
                          batch_persistent_only, peak_flops_tolerance,
-                         accumulation_factor},
+                         accumulation_factor, cost.peak_threshold},
         network, tidxs);
   } else if constexpr (Metric == ObjectiveFunction::DenseFLOPs) {
     if (is_volatile_leaf && volatile_weight > 1.0) {

From cd9f43f22bdcd792cc0fc29e94521bae7c9f2aef Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Fri, 3 Jul 2026 17:12:33 -0400
Subject: [PATCH 07/78] optimize: threshold-gated batched selection (min flops
 s.t. peak<=P_max, min-peak fallback)

PeakBatchedModel::reconstruct now selects the root-frontier point by
peak_threshold (bytes) instead of the unconditional peak_flops_tolerance
band: among points whose peak*numeric_size fits peak_threshold, pick min
flops (ties by lower peak); if none fit, fall back to min peak. Default
peak_threshold = +infinity makes every point feasible, so min-flops wins,
matching the non-batched schedule unless a finite threshold is set.

peak_flops_tolerance is kept on PeakBatchedModel for source compatibility
but is no longer consulted there; it still gates the unbatched DensePeakSize
model. Doc comments in options.hpp/single_term.hpp updated to reflect the
split.

Adjusted three existing batched tests whose assertions were inherently
peak-driven (not flop-driven) demonstrations, so the default +inf threshold
no longer masks what they exercise:
- "OSV deferral reproducer (tetramer term 3)": the persistent_only-gate
  probe now sets peak_threshold=1.0 to force the min-peak fallback.
- "quadratic bubble: early-K integral vs late-K t.(gC)": choose() and
  real_config_integral() now set peak_threshold=1.0 for the same reason
  (this test is gated behind __OPTIMIZE__ and was verified via a separate
  -O1 recompile of test_optimize.cpp relinked against the Debug libraries).

New test: "threshold gates batching: default (+inf) picks min-flops
regardless of K_b; near-zero threshold falls back to min-peak", reusing the
quadratic-bubble motif to show the divergence directly.
---
 SeQuant/core/optimize/cost_model.hpp  |  41 ++++---
 SeQuant/core/optimize/options.hpp     |  10 +-
 SeQuant/core/optimize/single_term.hpp |   4 +-
 tests/unit/test_optimize.cpp          | 159 +++++++++++++++++++++++---
 4 files changed, 179 insertions(+), 35 deletions(-)

diff --git a/SeQuant/core/optimize/cost_model.hpp b/SeQuant/core/optimize/cost_model.hpp
index a88ec7a02f..c8aaabbe6b 100644
--- a/SeQuant/core/optimize/cost_model.hpp
+++ b/SeQuant/core/optimize/cost_model.hpp
@@ -476,8 +476,10 @@ struct PeakBatchedModel {
   /// volatile leaf). Default false = batch across the board. See
   /// BatchPolicy::persistent_only.
   bool batch_persistent_only = false;
-  /// Relative peak tolerance for the final (root) selection; see
-  /// PeakModel::peak_flops_tolerance. 0 (default) = strict peak-min.
+  /// Unused by \ref reconstruct (superseded by the threshold-gated selection
+  /// below, driven by \ref peak_threshold / \ref numeric_size); retained for
+  /// source compatibility. See PeakModel::peak_flops_tolerance, which is
+  /// still consulted by the (unbatched) DensePeakSize model.
   double peak_flops_tolerance = 0.0;
   /// In-flight batch-contribution footprint multiplier; see
   /// BatchPolicy::accumulation_factor. Charged only on nodes that contract a
@@ -659,20 +661,33 @@ struct PeakBatchedModel {
   EvalSequence reconstruct(Context const& ctx,
                            container::vector<State> const& st) const {
     std::size_t const root = (std::size_t{1} << ctx.nt) - 1;
-    // ε-tolerant selection on the root's B=0 frontier: among points within
-    // (1 + peak_flops_tolerance) of the minimum peak, fewest flops (ties broken
-    // by lower peak). tolerance == 0 recovers strict peak-min.
     auto const& rootf = st[root][0];
-    double minpeak = std::numeric_limits<double>::max();
-    for (auto const& fp : rootf) minpeak = std::min(minpeak, fp.peak);
-    double const thresh = minpeak * (1.0 + peak_flops_tolerance);
+    // Threshold-gated selection: among points whose peak (bytes) fits
+    // peak_threshold, pick fewest flops (ties by lower peak). If none fit, pick
+    // min peak (best effort). peak_threshold == +inf => all feasible => min
+    // flops => the non-batched schedule.
+    auto peak_bytes = [this](double peak_elems) {
+      return peak_elems * numeric_size;
+    };
     int best = -1;
+    bool any_feasible = false;
     for (int i = 0; i < static_cast<int>(rootf.size()); ++i)
-      if (rootf[i].peak <= thresh &&
-          (best < 0 || rootf[i].flops < rootf[best].flops ||
-           (rootf[i].flops == rootf[best].flops &&
-            rootf[i].peak < rootf[best].peak)))
-        best = i;
+      if (peak_bytes(rootf[i].peak) <= peak_threshold) {
+        any_feasible = true;
+        if (best < 0 || rootf[i].flops < rootf[best].flops ||
+            (rootf[i].flops == rootf[best].flops &&
+             rootf[i].peak < rootf[best].peak))
+          best = i;
+      }
+    if (!any_feasible) {
+      // Infeasible: no schedule fits the budget. Fall back to min peak.
+      double minpeak = std::numeric_limits<double>::max();
+      for (int i = 0; i < static_cast<int>(rootf.size()); ++i)
+        if (rootf[i].peak < minpeak) {
+          minpeak = rootf[i].peak;
+          best = i;
+        }
+    }
     // Recursive back-pointer walk: at (n, B, idx) read the chosen front point,
     // form child context C = B | aprime, recurse in lp_first order.
     std::function<EvalSequence(std::size_t, std::size_t, int)> build =
diff --git a/SeQuant/core/optimize/options.hpp b/SeQuant/core/optimize/options.hpp
index d320208f27..5cd7e55f73 100644
--- a/SeQuant/core/optimize/options.hpp
+++ b/SeQuant/core/optimize/options.hpp
@@ -96,8 +96,9 @@ struct CostParams {
   /// Per-intermediate storage-footprint penalty (DenseFLOPs/DenseSize only; see
   /// OptimizeOptions::footprint_weight). Not used by the peak objectives.
   double footprint_weight = 0.0;
-  /// Relative peak tolerance for the peak objectives' final selection; see
-  /// OptimizeOptions::peak_flops_tolerance.
+  /// Relative peak tolerance for DensePeakSize's final selection; see
+  /// OptimizeOptions::peak_flops_tolerance. Unused by DensePeakSizeBatched,
+  /// whose final selection is instead threshold-gated by \c peak_threshold.
   double peak_flops_tolerance = 0.10;
   /// Roofline parameters for the peak objectives' secondary cost; see
   /// \ref RooflineParams. machine_balance == 0 => pure-flop tie-break.
@@ -176,8 +177,9 @@ struct OptimizeOptions {
   /// 0 = strict peak-min (flop tie-break only on exact peak ties). The default
   /// 0.10 trades up to a 10% peak increase for a (often much larger) flop
   /// reduction -- e.g. forming a persistent 4-PNO integral instead of
-  /// recomputing a particle-ladder. Only consulted by DensePeakSize /
-  /// DensePeakSizeBatched.
+  /// recomputing a particle-ladder. Only consulted by DensePeakSize.
+  /// DensePeakSizeBatched's final selection is instead threshold-gated by
+  /// \ref BatchPolicy::peak_threshold.
   double peak_flops_tolerance = 0.10;
 
   /// Per-intermediate memory-footprint penalty added to the single-term
diff --git a/SeQuant/core/optimize/single_term.hpp b/SeQuant/core/optimize/single_term.hpp
index fb46a6f9cd..bb510b7d91 100644
--- a/SeQuant/core/optimize/single_term.hpp
+++ b/SeQuant/core/optimize/single_term.hpp
@@ -38,7 +38,9 @@ namespace detail {
 ///        deemed equivalent by the subnet-CSE canonicalization also agree on
 ///        volatility (the CSE path stores one cost per canonical subnet).
 ///        volatile_weight/footprint_weight apply to DenseFLOPs only;
-///        peak_flops_tolerance/roofline apply to the peak objectives only.
+///        roofline applies to the peak objectives only; peak_flops_tolerance
+///        applies to DensePeakSize only (DensePeakSizeBatched's final
+///        selection is instead threshold-gated by peak_threshold).
 /// \param is_batchable_index Predicate marking an index as batchable (sliced);
 ///        ObjectiveFunction::DensePeakSizeBatched only.
 /// \param batch_target_size Per-index per-batch slice size (an upper bound) for
diff --git a/tests/unit/test_optimize.cpp b/tests/unit/test_optimize.cpp
index 439099a6a5..62b5b9d2e3 100644
--- a/tests/unit/test_optimize.cpp
+++ b/tests/unit/test_optimize.cpp
@@ -1662,12 +1662,18 @@ TEST_CASE("OSV deferral reproducer (tetramer term 3)", "[optimize][osv]") {
   // (3) The persistent-only gate is still available as an opt-in: setting
   //     batch_persistent_only restores the old behavior (volatile subtrees not
   //     sliced -> the batched model reverts to deferring the OSV outer
-  //     product).
-  double pbat_po = report(
-      L"PeakBatch/persistent_only:",
-      opt::single_term_opt<ObjectiveFunction::DensePeakSizeBatched>(
-          prod, idxsz, false, CostParams{is_t, 100.0, 0.0}, is_batch, bts, ip,
-          /*batch_persistent_only=*/true));
+  //     product). This specifically probes peak-driven (memory-constrained)
+  //     selection under the gate, so it needs a finite (near-zero)
+  //     peak_threshold: the default +inf would pick the min-flops schedule
+  //     regardless of the gate (flops do not depend on which nodes may be
+  //     sliced), masking the effect the gate is meant to demonstrate.
+  CostParams po_cost{is_t, 100.0, 0.0};
+  po_cost.peak_threshold = 1.0;  // near-zero => infeasible => min-peak fallback
+  double pbat_po =
+      report(L"PeakBatch/persistent_only:",
+             opt::single_term_opt<ObjectiveFunction::DensePeakSizeBatched>(
+                 prod, idxsz, false, po_cost, is_batch, bts, ip,
+                 /*batch_persistent_only=*/true));
   CHECK(pbat_po >= osv_outer_product);  // gate restored -> OSV deferred again
 }
 
@@ -2092,10 +2098,16 @@ TEST_CASE("quadratic bubble: early-K integral vs late-K t·(gC)",
     };
     // CostParams: {is_volatile_leaf, volatile_weight, footprint_weight,
     //              peak_flops_tolerance, roofline, accumulation_factor}.
-    // peak_flops_tolerance = 0 => strict peak-min (no tolerance band).
+    // peak_flops_tolerance is no longer consulted by DensePeakSizeBatched's
+    // final selection (Task 1.2: threshold-gated). This probe is inherently
+    // about PEAK (which factorization is smaller in memory, not flops), so it
+    // needs a near-zero peak_threshold to force the min-peak fallback path
+    // (the default +inf would instead pick purely by flops, masking the
+    // crossover this test demonstrates).
+    CostParams cost{{}, 1.0, 0.0, 0.0, {}, lambda};
+    cost.peak_threshold = 1.0;
     auto res = opt::single_term_opt<ObjectiveFunction::DensePeakSizeBatched>(
-        prod, idxsz, false, CostParams{{}, 1.0, 0.0, 0.0, {}, lambda}, is_batch,
-        bts, ip);
+        prod, idxsz, false, cost, is_batch, bts, ip);
     bool integral = forms_integral(res);
     double gb = batched_peak(res, Kb) * 8.0 / 1e9;
     std::wcout << L"  K_b=" << Kb << L"\tlambda=" << lambda
@@ -2115,23 +2127,136 @@ TEST_CASE("quadratic bubble: early-K integral vs late-K t·(gC)",
   CHECK_FALSE(choose(/*K_b=*/6, /*lambda=*/1.0));  // at crossover   -> late-K
   CHECK(choose(/*K_b=*/72, /*lambda=*/10.0));      // above crossover -> early-K
 
-  // Real MPQC config: t is volatile (replayed), default peak tolerance 0.10
-  // lets the (replay-weighted) flop tie-break trade peak for building the
-  // persistent, t-free, Kappa-free integral ONCE. This is the suspected real
-  // driver of the held-whole 4-occ/2-PNO object (the C60 OOM), independent of
-  // accumulation. Below the crossover it stays late-K; above it flips to
-  // early-K.
+  // Real MPQC config: t is volatile (replayed). This probes the same PEAK
+  // crossover under replay-weighted flops (is_t, volatile_weight=100), so it
+  // needs the same near-zero peak_threshold as choose() above: the default
+  // +inf would instead pick purely by (replay-weighted) flops, which favor
+  // forming the persistent, t-free, Kappa-free integral ONCE REGARDLESS of
+  // K_b (flops do not depend on the aux batch size) -- exactly the behavior
+  // exercised by the "threshold gates batching" test (Task 1.2, below), which
+  // reuses this same motif. With peak_threshold forced near-zero (min-peak
+  // fallback), this instead reproduces the peak-driven crossover: below the
+  // crossover it stays late-K; above it flips to early-K -- the suspected
+  // real driver of the held-whole 4-occ/2-PNO object (the C60 OOM),
+  // independent of accumulation.
   auto is_t = [](Tensor const& t) { return t.label() == L"t"; };
   auto real_config_integral = [&](std::size_t Kb) -> bool {
     std::function<std::size_t(Index const&)> bts = [Kb](Index const&) {
       return Kb;
     };
+    CostParams cost{is_t, 100.0, 0.0, 0.10, {}, 0.0};
+    cost.peak_threshold = 1.0;
     auto res = opt::single_term_opt<ObjectiveFunction::DensePeakSizeBatched>(
-        prod, idxsz, false, CostParams{is_t, 100.0, 0.0, 0.10, {}, 0.0},
-        is_batch, bts, ip);
+        prod, idxsz, false, cost, is_batch, bts, ip);
     return forms_integral(res);
   };
   CHECK_FALSE(real_config_integral(/*K_b=*/2));  // below crossover -> late-K
   CHECK(real_config_integral(/*K_b=*/236));      // above crossover -> early-K
 }
 #endif  // __OPTIMIZE__
+
+// Task 1.2: threshold-gated root selection in PeakBatchedModel::reconstruct.
+// Reuses the "quadratic bubble" motif (early-K integral vs late-K t.(gC),
+// above) since it is a proven, already-tuned case where the OLD
+// (peak-first, epsilon-tolerant) root selection and the flop-optimal choice
+// diverge: at K_b=2 (below the peak crossover), the replay-weighted flops
+// (is_t volatile, volatile_weight=100) still favor forming the persistent
+// Kappa-free integral ONCE (early-K) -- flops do not depend on K_b at all,
+// only peak does -- but the old peak_flops_tolerance=0.10 band rejects it
+// there because its peak exceeds the tolerance band around the (much
+// smaller) late-K peak (see CHECK_FALSE(real_config_integral(2)) above).
+// The new threshold-gated selection no longer consults peak_flops_tolerance:
+// with the default peak_threshold = +inf every root-frontier point is
+// feasible, so pure min-flops wins, forming the integral even at this small
+// K_b. A near-zero peak_threshold instead makes every point infeasible,
+// triggering the min-peak fallback, which reproduces the old (peak-driven)
+// answer.
+TEST_CASE(
+    "threshold gates batching: default (+inf) picks min-flops regardless of "
+    "K_b; near-zero threshold falls back to min-peak",
+    "[optimize][threshold]") {
+  using namespace sequant;
+  auto ctx_resetter = set_scoped_default_context(get_default_context().clone());
+  auto reg = get_default_context().mutable_index_space_registry();
+  mbpt::add_df_spaces(reg);
+  mbpt::add_pao_spaces(reg);
+  mbpt::add_ao_spaces(reg);
+  // water-20-scale extents (matches the "quadratic bubble" test above).
+  for (auto&& [k, v] :
+       std::initializer_list<std::pair<std::wstring_view, size_t>>{
+           {L"i", 80}, {L"a", 12}, {L"μ̃", 860}, {L"Κ", 2360}}) {
+    reg->retrieve_ptr(k)->approximate_size(v);
+  }
+  auto aux_space = reg->retrieve(L"Κ");
+  auto idxsz = [](Index const& ix) -> std::size_t {
+    return ix.nonnull() ? ix.space().approximate_size() : std::size_t{1};
+  };
+  double const p = 12.0;
+  auto ip = [p](Index const&, std::size_t) -> double { return p; };
+  auto is_batch = [aux_space](Index const& ix) {
+    return ix.space() == aux_space;
+  };
+
+  auto nested = deserialize(
+      L"( g{i_4;μ̃_1;Κ_1} * C{μ̃_1;a_3<i_1,i_3>}"
+      L"  * t{a_1<i_1,i_3>,a_3<i_1,i_3>;i_1,i_3}"
+      L"  * C{a_1<i_1,i_3>;μ̃_2} * s{μ̃_2;μ̃_3} * C{μ̃_3;a_1<i_1,i_2>} )"
+      L"* ( g{i_3;μ̃_4;Κ_1} * C{μ̃_4;a_4<i_2,i_4>}"
+      L"  * t{a_2<i_2,i_4>,a_4<i_2,i_4>;i_2,i_4}"
+      L"  * C{a_2<i_2,i_4>;μ̃_5} * s{μ̃_5;μ̃_6} * C{μ̃_6;a_2<i_1,i_2>} )",
+      {.def_perm_symm = Symmetry::Nonsymm});
+  Product flatp{};
+  for (auto const& half : nested->as<Product>().factors())
+    flatp.append(1, half, Product::Flatten::Yes);
+  REQUIRE(flatp.factors().size() == 12);
+  Product const& prod = flatp;
+
+  std::function<bool(ExprPtr const&)> has_g = [&](ExprPtr const& e) -> bool {
+    if (e->is<Tensor>()) return e->as<Tensor>().label() == L"g";
+    if (e->is<Product>())
+      for (auto const& f : e->as<Product>().factors())
+        if (has_g(f)) return true;
+    return false;
+  };
+  std::function<bool(ExprPtr const&)> has_t = [&](ExprPtr const& e) -> bool {
+    if (e->is<Tensor>()) return e->as<Tensor>().label() == L"t";
+    if (e->is<Product>())
+      for (auto const& f : e->as<Product>().factors())
+        if (has_t(f)) return true;
+    return false;
+  };
+  std::function<bool(ExprPtr const&)> forms_integral =
+      [&](ExprPtr const& e) -> bool {
+    if (!e->is<Product>()) return false;
+    auto const& facs = e->as<Product>().factors();
+    int gcount = 0;
+    for (auto const& f : facs)
+      if (has_g(f)) ++gcount;
+    if (gcount == 2 && !has_t(e)) return true;
+    for (auto const& f : facs)
+      if (forms_integral(f)) return true;
+    return false;
+  };
+
+  auto is_t = [](Tensor const& t) { return t.label() == L"t"; };
+  auto integral_at = [&](std::size_t Kb, double peak_threshold) -> bool {
+    std::function<std::size_t(Index const&)> bts = [Kb](Index const&) {
+      return Kb;
+    };
+    CostParams cost{is_t, 100.0, 0.0};
+    cost.peak_threshold = peak_threshold;
+    auto res = opt::single_term_opt<ObjectiveFunction::DensePeakSizeBatched>(
+        prod, idxsz, false, cost, is_batch, bts, ip);
+    return forms_integral(res);
+  };
+
+  double const inf = std::numeric_limits<double>::infinity();
+  // Below the peak crossover (K_b=2): default peak_threshold (+inf) => every
+  // root point is feasible => pure min-(replay-weighted)-flops selection =>
+  // forms the persistent integral (early-K), unlike the old peak-tolerance-
+  // band selection (CHECK_FALSE(real_config_integral(2)) in the test above).
+  CHECK(integral_at(/*Kb=*/2, inf));
+  // A near-zero peak_threshold makes every point infeasible => min-peak
+  // fallback => reproduces the old (peak-driven) answer: late-K.
+  CHECK_FALSE(integral_at(/*Kb=*/2, /*peak_threshold(bytes)=*/1.0));
+}

From 6223bd7da72750455008b7ca7385a871ee935d59 Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Fri, 3 Jul 2026 18:02:55 -0400
Subject: [PATCH 08/78] optimize: price the batch contribution buffer in
 reconstructed_batched_peak oracle

---
 SeQuant/core/optimize/cost_model.hpp | 29 +++++++++++++++++++++++-----
 1 file changed, 24 insertions(+), 5 deletions(-)

diff --git a/SeQuant/core/optimize/cost_model.hpp b/SeQuant/core/optimize/cost_model.hpp
index c8aaabbe6b..adc400ab60 100644
--- a/SeQuant/core/optimize/cost_model.hpp
+++ b/SeQuant/core/optimize/cost_model.hpp
@@ -757,10 +757,22 @@ double reconstructed_batched_peak(
     TensorNetwork const& network, TIdxs const& tidxs, IdxToSz&& idxsz,
     std::function<bool(Index const&)> const& is_batchable,
     std::function<std::size_t(Index const&)> const& batch_target_size,
-    std::function<bool(Tensor const&)> const& is_volatile_leaf) {
-  PeakBatchedModel<std::decay_t<IdxToSz>> model{std::forward<IdxToSz>(idxsz),
-                                                is_batchable, batch_target_size,
-                                                is_volatile_leaf};
+    std::function<bool(Tensor const&)> const& is_volatile_leaf,
+    double accumulation_factor = 0.0) {
+  PeakBatchedModel<std::decay_t<IdxToSz>> model{
+      std::forward<IdxToSz>(idxsz),
+      is_batchable,
+      batch_target_size,
+      is_volatile_leaf,
+      /* inner_pow */ {},
+      /* volatile_weight */ 1.0,
+      /* machine_balance */ 0.0,
+      /* fast_mem_elems */ 0.0,
+      /* block_tiles */ 3.0,
+      /* block_prefactor */ 1.0,
+      /* batch_persistent_only */ false,
+      /* peak_flops_tolerance */ 0.0,
+      accumulation_factor};
   auto ctx = model.build_context(network, tidxs);
   auto st = solve_single_term(model, network, tidxs, ctx);
   auto const nt = network.tensors().size();
@@ -795,7 +807,14 @@ double reconstructed_batched_peak(
     // parent result (sz(n, B)) is materialized alongside them.
     double const stage_first = ctx.Lof(s, C) + peak_f;
     double const stage_second = ctx.sz(f, C) + peak_s;
-    double const stage_form = ctx.sz(f, C) + ctx.sz(s, C) + ctx.sz(n, B);
+    // Mirror the DP's relax() contribution charge: a node that contracts a
+    // batchable index (aprime != 0) is accumulated over the aux batches, so
+    // the in-flight contribution (sized like the result, ctx.sz(n, B))
+    // co-resides with the accumulator at the all-co-resident moment.
+    double const contrib =
+        (r.aprime != 0) ? model.accumulation_factor * ctx.sz(n, B) : 0.0;
+    double const stage_form =
+        ctx.sz(f, C) + ctx.sz(s, C) + ctx.sz(n, B) + contrib;
     return std::max({stage_first, stage_second, stage_form});
   };
 

From 24f8fdbca33b30d1d9351c91ea5f219bf36ab0a6 Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Fri, 3 Jul 2026 18:20:12 -0400
Subject: [PATCH 09/78] optimize: allow accumulation_factor for m>=2 (nested),
 gated by DP==oracle identity

---
 SeQuant/core/optimize/cost_model.hpp | 32 ++++++++-----
 tests/unit/test_optimize.cpp         | 68 ++++++++++++++++++++++++++++
 2 files changed, 88 insertions(+), 12 deletions(-)

diff --git a/SeQuant/core/optimize/cost_model.hpp b/SeQuant/core/optimize/cost_model.hpp
index adc400ab60..a7bb84212b 100644
--- a/SeQuant/core/optimize/cost_model.hpp
+++ b/SeQuant/core/optimize/cost_model.hpp
@@ -559,14 +559,10 @@ struct PeakBatchedModel {
     ctx.nt = network.tensors().size();
     ctx.aux = batchable_index_list(network, is_batchable);
     ctx.m = ctx.aux.size();
-    // The accumulation_factor charge is per accumulation node (charged on each
-    // node that contracts a batchable index). Its semantics are only
-    // well-defined for a single batch axis; with multiple batchable indices the
-    // per-node, once-per-node charge would conflate independent accumulations.
-    SEQUANT_ASSERT(
-        (accumulation_factor == 0.0 || ctx.m <= 1) &&
-        "DensePeakSizeBatched: accumulation_factor != 0 requires at most one "
-        "batchable index");
+    // accumulation_factor is charged per accumulation node (Ap != 0) and is
+    // valid for any number of batchable indices: with nested accumulation the
+    // per-node charges co-exist at the peak. Validated by the identity
+    // peak_cost_batched == reconstructed_batched_peak (test [batched-accum]).
     ctx.nB = std::size_t{1} << ctx.m;
     ctx.tables = sliced_footprints(network, tidxs, idxsz, is_batchable, batch,
                                    ctx.aux, inner_pow);
@@ -735,10 +731,22 @@ double peak_cost_batched(
     TensorNetwork const& network, TIdxs const& tidxs, IdxToSz&& idxsz,
     std::function<bool(Index const&)> const& is_batchable,
     std::function<std::size_t(Index const&)> const& batch_target_size,
-    std::function<bool(Tensor const&)> const& is_volatile_leaf) {
-  PeakBatchedModel<std::decay_t<IdxToSz>> model{std::forward<IdxToSz>(idxsz),
-                                                is_batchable, batch_target_size,
-                                                is_volatile_leaf};
+    std::function<bool(Tensor const&)> const& is_volatile_leaf,
+    double accumulation_factor = 0.0) {
+  PeakBatchedModel<std::decay_t<IdxToSz>> model{
+      std::forward<IdxToSz>(idxsz),
+      is_batchable,
+      batch_target_size,
+      is_volatile_leaf,
+      /* inner_pow */ {},
+      /* volatile_weight */ 1.0,
+      /* machine_balance */ 0.0,
+      /* fast_mem_elems */ 0.0,
+      /* block_tiles */ 3.0,
+      /* block_prefactor */ 1.0,
+      /* batch_persistent_only */ false,
+      /* peak_flops_tolerance */ 0.0,
+      accumulation_factor};
   auto ctx = model.build_context(network, tidxs);
   auto st = solve_single_term(model, network, tidxs, ctx);
   // root subset's B=0 frontier; its smallest peak is the achieved minimum.
diff --git a/tests/unit/test_optimize.cpp b/tests/unit/test_optimize.cpp
index 62b5b9d2e3..1aa1086b7d 100644
--- a/tests/unit/test_optimize.cpp
+++ b/tests/unit/test_optimize.cpp
@@ -1,3 +1,4 @@
+#include <catch2/catch_approx.hpp>
 #include <catch2/catch_test_macros.hpp>
 
 #include "catch2_sequant.hpp"
@@ -2260,3 +2261,70 @@ TEST_CASE(
   // fallback => reproduces the old (peak-driven) answer: late-K.
   CHECK_FALSE(integral_at(/*Kb=*/2, /*peak_threshold(bytes)=*/1.0));
 }
+
+// Task 2.2: validate that the batched DP's accumulation_factor charge is
+// priced correctly under NESTED accumulation -- i.e. more than one batchable
+// index, contracted at *different* nodes of the binarized tree -- and that
+// the ctx.m <= 1 restriction that used to guard accumulation_factor != 0 can
+// be lifted. Network: T0=g{i;a;K}, T1=g{mu1;mu2;K}, T2=f{mu1;a2},
+// T3=f{mu2;a3}. T1 is a hub carrying K, mu1 AND mu2 simultaneously; K is
+// contracted between T0/T1, mu1 between T1/T2, mu2 between T1/T3 -- three
+// distinct batchable Index instances (K, mu1, mu2) spanning the aux (Κ) and
+// PAO (μ̃) spaces, forcing the DP to slice more than one axis, at more than
+// one node, to reach its minimum-peak schedule.
+TEST_CASE("batched DP peak matches oracle with two axes and accumulation",
+          "[optimize][batched-accum]") {
+  using namespace sequant;
+  auto ctx_resetter = set_scoped_default_context(get_default_context().clone());
+  auto reg = get_default_context().mutable_index_space_registry();
+  mbpt::add_df_spaces(reg);
+  mbpt::add_pao_spaces(reg);
+  mbpt::add_ao_spaces(reg);
+  for (auto&& [k, v] :
+       std::initializer_list<std::pair<std::wstring_view, size_t>>{
+           {L"i", 20}, {L"a", 20}, {L"μ̃", 200}, {L"Κ", 300}}) {
+    reg->retrieve_ptr(k)->approximate_size(v);
+  }
+  auto aux = reg->retrieve(L"Κ");
+  auto pao = reg->retrieve(L"μ̃");
+  auto idxsz = [](Index const& ix) -> std::size_t {
+    return ix.nonnull() ? ix.space().approximate_size() : std::size_t{1};
+  };
+  auto is_batch = [aux, pao](Index const& ix) {
+    return ix.space() == aux || ix.space() == pao;
+  };
+  auto is_batch_K = [aux](Index const& ix) { return ix.space() == aux; };
+  auto is_batch_mu = [pao](Index const& ix) { return ix.space() == pao; };
+  std::function<std::size_t(Index const&)> bts = [](Index const&) {
+    return std::size_t{10};
+  };
+  std::function<bool(Tensor const&)> novol = {};
+  // Two batchable contracted indices K and mu-tilde, contracted at different
+  // nodes (nested accumulation).
+  auto prod = deserialize(
+                  L"g{i_1;a_1;Κ_1} g{μ̃_1;μ̃_2;Κ_1} f{μ̃_1;a_2} "
+                  L"f{μ̃_2;a_3}")
+                  ->as<Product>();
+  TensorNetwork net(prod.factors());
+  container::svector<Index> tidxs{};
+  double const acc = 1.0;
+  double const dp = opt::detail::peak_cost_batched(net, tidxs, idxsz, is_batch,
+                                                   bts, novol, acc);
+  double const oracle = opt::detail::reconstructed_batched_peak(
+      net, tidxs, idxsz, is_batch, bts, novol, acc);
+  // The correctness gate: the DP's max/+ recurrence for the accumulation
+  // charge must agree with the independent memory-simulation oracle even
+  // when more than one batchable index is sliced along the chosen tree.
+  CHECK(dp == Catch::Approx(oracle));
+
+  // Confirm the identity is not vacuous: the chosen 2-axis schedule must
+  // actually be lower-peak than slicing either axis alone, proving the DP
+  // engaged (and nested) both K and mu-tilde rather than degenerating to a
+  // single-axis schedule.
+  double const dp_K_only = opt::detail::peak_cost_batched(
+      net, tidxs, idxsz, is_batch_K, bts, novol, acc);
+  double const dp_mu_only = opt::detail::peak_cost_batched(
+      net, tidxs, idxsz, is_batch_mu, bts, novol, acc);
+  CHECK(dp < dp_K_only);
+  CHECK(dp < dp_mu_only);
+}

From b1e42d5d33542dd51c7112ee56150f760da394d1 Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Fri, 3 Jul 2026 18:35:55 -0400
Subject: [PATCH 10/78] optimize: reconstruct_axes emits per-node sliced-sets
 in RPN order

---
 SeQuant/core/optimize/cost_model.hpp | 57 +++++++++++++++++++++++++---
 1 file changed, 51 insertions(+), 6 deletions(-)

diff --git a/SeQuant/core/optimize/cost_model.hpp b/SeQuant/core/optimize/cost_model.hpp
index a7bb84212b..25cfa730cf 100644
--- a/SeQuant/core/optimize/cost_model.hpp
+++ b/SeQuant/core/optimize/cost_model.hpp
@@ -654,14 +654,16 @@ struct PeakBatchedModel {
   void finalize(Context& /*ctx*/, size_t /*n*/,
                 container::vector<State>& /*st*/) const {}
 
-  EvalSequence reconstruct(Context const& ctx,
-                           container::vector<State> const& st) const {
+  /// Threshold-gated root-frontier selection shared by \ref reconstruct and
+  /// \ref reconstruct_axes: among points whose peak (bytes) fits
+  /// peak_threshold, pick fewest flops (ties by lower peak). If none fit, pick
+  /// min peak (best effort). peak_threshold == +inf => all feasible => min
+  /// flops => the non-batched schedule. Returns the chosen index into
+  /// \c st[root][0].
+  int select_root(Context const& ctx,
+                  container::vector<State> const& st) const {
     std::size_t const root = (std::size_t{1} << ctx.nt) - 1;
     auto const& rootf = st[root][0];
-    // Threshold-gated selection: among points whose peak (bytes) fits
-    // peak_threshold, pick fewest flops (ties by lower peak). If none fit, pick
-    // min peak (best effort). peak_threshold == +inf => all feasible => min
-    // flops => the non-batched schedule.
     auto peak_bytes = [this](double peak_elems) {
       return peak_elems * numeric_size;
     };
@@ -684,6 +686,13 @@ struct PeakBatchedModel {
           best = i;
         }
     }
+    return best;
+  }
+
+  EvalSequence reconstruct(Context const& ctx,
+                           container::vector<State> const& st) const {
+    std::size_t const root = (std::size_t{1} << ctx.nt) - 1;
+    int const best = select_root(ctx, st);
     // Recursive back-pointer walk: at (n, B, idx) read the chosen front point,
     // form child context C = B | aprime, recurse in lp_first order.
     std::function<EvalSequence(std::size_t, std::size_t, int)> build =
@@ -704,6 +713,42 @@ struct PeakBatchedModel {
     };
     return build(root, 0, best);
   }
+
+  /// Companion to \ref reconstruct that additionally reports, for each \c -1
+  /// (contraction) entry emitted in the returned \c EvalSequence in emission
+  /// order, the vector of \c Index sliced at that node (\c ctx.aux[bit] for
+  /// each set bit of that node's \c aprime). Leaf entries contribute nothing.
+  /// Does not change \ref reconstruct's own output; the two walks are kept in
+  /// lock-step so the RPN order and the per-node axes line up.
+  std::pair<EvalSequence, container::vector<container::svector<Index>>>
+  reconstruct_axes(Context const& ctx,
+                   container::vector<State> const& st) const {
+    std::size_t const root = (std::size_t{1} << ctx.nt) - 1;
+    int const best = select_root(ctx, st);  // shared helper (see below)
+    container::vector<container::svector<Index>> node_axes;
+    std::function<EvalSequence(std::size_t, std::size_t, int)> build =
+        [&](std::size_t n, std::size_t B, int idx) -> EvalSequence {
+      if (std::popcount(n) == 1)
+        return EvalSequence{static_cast<int>(std::countr_zero(n))};
+      BFrontPoint const& r = st[n][B][idx];
+      std::size_t const C = B | r.aprime;
+      std::size_t const fs = r.lp_first ? r.lp : r.rp;
+      int const fi = r.lp_first ? r.lp_idx : r.rp_idx;
+      std::size_t const ss = r.lp_first ? r.rp : r.lp;
+      int const si = r.lp_first ? r.rp_idx : r.lp_idx;
+      EvalSequence s = build(fs, C, fi);
+      EvalSequence b = build(ss, C, si);
+      s.insert(s.end(), b.begin(), b.end());
+      container::svector<Index> axes;
+      for (std::size_t k = 0; k < ctx.m; ++k)
+        if (r.aprime & (std::size_t{1} << k)) axes.push_back(ctx.aux[k]);
+      node_axes.push_back(std::move(axes));  // one entry per -1, in RPN order
+      s.push_back(-1);
+      return s;
+    };
+    auto seq = build(root, 0, best);
+    return {std::move(seq), std::move(node_axes)};
+  }
 };
 
 /// \brief Achieved minimum peak memory (the DensePeakSize objective value) for

From 8d6b89dfbfbb99dab30afd0e2323123b2df0220c Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Fri, 3 Jul 2026 18:47:30 -0400
Subject: [PATCH 11/78] optimize: surface per-node sliced-sets per summand via
 OptimizeOptions.term_batch_axes

Task 3.2 of the PNO-CCSD aux+PAO batching feature: thread the per-node
sliced-Index-sets that PeakBatchedModel::reconstruct_axes (Task 3.1)
computes out of the optimizer, so each optimized residual summand
carries which axes to slice at each of its contraction nodes.

- cost_model.hpp: add run_single_term_opt_axes, a companion to
  run_single_term_opt that calls Model::reconstruct_axes instead of
  reconstruct, returning {EvalSequence, node_axes} with the same nt==1/
  nt==2 shortcuts (empty axes / one empty entry respectively).
- single_term.hpp: thread an optional
  container::vector<container::svector<Index>>* out_axes = nullptr
  through both the detail and public single_term_opt overloads. The
  DensePeakSizeBatched arm calls run_single_term_opt_axes when out_axes
  is set; every other objective asserts out_axes is null. Both
  overloads clear *out_axes on entry so an early return (e.g. prod
  with < 3 factors) never leaves it holding a previous call's data.
- optimize.cpp (opt_pure_product): declare node_axes, pass it through
  only on the DensePeakSizeBatched call path, and after building the
  result record (*opts.term_batch_axes)[result.get()] = node_axes when
  the out-channel is set. optimize_impl/optimize() need no changes:
  OptimizeOptions is threaded by reference/value-copy already, so the
  shared_ptr out-channel survives unchanged.
- options.hpp: add OptimizeOptions::term_batch_axes (a
  shared_ptr<unordered_map<Expr const*, per-node axes>>), default null
  (no behavior change). Added the includes/forward-decl (container.hpp,
  <unordered_map>, <memory>, class Expr) it needs.

Verified the RPN-to-Product alignment: single_term_opt's Product-
building loop (single_term.hpp) iterates the EvalSequence left to
right and, on each -1, pops rexpr (top of stack, most recently pushed)
then lexpr (pushed before it) to form Product{lexpr, rexpr}. Since the
sequence is emitted in the same left-first post-order in both
reconstruct and reconstruct_axes (identical build() recursion:
recurse into the lp_first-selected "first" operand, then the
"second", then append -1), the j-th -1 encountered by the loop is
exactly the j-th entry pushed into reconstruct_axes's node_axes. No
behavior change for existing callers (term_batch_axes defaults to
null); build + [optimize] unit tests pass (339 assertions, 12 cases).
---
 SeQuant/core/optimize/cost_model.hpp  | 29 +++++++++++++
 SeQuant/core/optimize/optimize.cpp    | 10 ++++-
 SeQuant/core/optimize/options.hpp     | 16 ++++++++
 SeQuant/core/optimize/single_term.hpp | 59 ++++++++++++++++++++++-----
 4 files changed, 102 insertions(+), 12 deletions(-)

diff --git a/SeQuant/core/optimize/cost_model.hpp b/SeQuant/core/optimize/cost_model.hpp
index 25cfa730cf..5eabf64b79 100644
--- a/SeQuant/core/optimize/cost_model.hpp
+++ b/SeQuant/core/optimize/cost_model.hpp
@@ -60,6 +60,35 @@ EvalSequence run_single_term_opt(Model const& m, TensorNetwork const& network,
   return m.reconstruct(ctx, st);
 }
 
+/// \brief Companion to \ref run_single_term_opt that also reports, for each
+/// contraction (\c -1) node of the returned \c EvalSequence in emission order,
+/// the sliced-set of batchable \c Index values realized at that node. Requires
+/// \p Model to additionally expose \c reconstruct_axes (currently only \ref
+/// PeakBatchedModel does); see its doc comment for the precise per-node
+/// convention (RPN / post-order, left-first, matching the shared \c build
+/// recursion used by \ref reconstruct).
+///
+/// \return The optimal EvalSequence, paired with one \c container::svector
+///         of sliced \c Index per \c -1 token of that sequence, in the same
+///         left-first post-order the sequence itself was emitted in. For the
+///         nt==1 shortcut (no contractions) the axes vector is empty; for the
+///         nt==2 shortcut (single contraction, no DP context is built) the
+///         axes vector holds one empty entry (no batching info available).
+template <class Model, typename TIdxs>
+std::pair<EvalSequence, container::vector<container::svector<Index>>>
+run_single_term_opt_axes(Model const& m, TensorNetwork const& network,
+                         TIdxs const& tidxs) {
+  auto const nt = network.tensors().size();
+  if (nt == 1) return {EvalSequence{0}, {}};
+  if (nt == 2)
+    return {EvalSequence{0, 1, -1},
+            container::vector<container::svector<Index>>{
+                container::svector<Index>{}}};
+  typename Model::Context ctx = m.build_context(network, tidxs);
+  auto st = solve_single_term(m, network, tidxs, ctx);
+  return m.reconstruct_axes(ctx, st);
+}
+
 /// \brief Additive single-term cost model (FLOPs or operand storage size).
 ///
 /// Implements the additive single-term DP, factored into the CostModel hooks
diff --git a/SeQuant/core/optimize/optimize.cpp b/SeQuant/core/optimize/optimize.cpp
index fd945c2e59..38389c3734 100644
--- a/SeQuant/core/optimize/optimize.cpp
+++ b/SeQuant/core/optimize/optimize.cpp
@@ -94,6 +94,11 @@ ExprPtr opt_pure_product(Product const& prod, OptimizeOptions const& opts) {
                         opts.roofline,
                         opts.batch_policy.accumulation_factor,
                         opts.batch_policy.peak_threshold};
+  // Filled only by the DensePeakSizeBatched arm below (via out_axes); every
+  // other objective leaves it empty, so the term_batch_axes insertion at the
+  // end is then a no-op-shaped empty-vector entry (harmless: Task 3.3 only
+  // consumes entries for summands the batched objective actually annotated).
+  container::vector<container::svector<Index>> node_axes;
   auto run = [&]() -> ExprPtr {
     if (opts.objective_function == ObjectiveFunction::DenseFLOPs)
       return opt::single_term_opt<ObjectiveFunction::DenseFLOPs>(
@@ -116,9 +121,12 @@ ExprPtr opt_pure_product(Product const& prod, OptimizeOptions const& opts) {
         prod, opts.idx_to_extent, subnet_cse, cost,
         opts.batch_policy.is_batchable_index,
         opts.batch_policy.batch_target_size, opts.inner_pow,
-        opts.batch_policy.persistent_only);
+        opts.batch_policy.persistent_only,
+        opts.term_batch_axes ? &node_axes : nullptr);
   };
   ExprPtr result = run();
+  if (opts.term_batch_axes)
+    (*opts.term_batch_axes)[result.get()] = std::move(node_axes);
   if (std::getenv("SEQUANT_FACTORIZER_DEBUG"))
     log_chosen_factorization(result, opts);
   return result;
diff --git a/SeQuant/core/optimize/options.hpp b/SeQuant/core/optimize/options.hpp
index 5cd7e55f73..82d8564d0d 100644
--- a/SeQuant/core/optimize/options.hpp
+++ b/SeQuant/core/optimize/options.hpp
@@ -2,15 +2,19 @@
 #define SEQUANT_CORE_OPTIMIZE_OPTIONS_HPP
 
 #include <SeQuant/core/batch_policy.hpp>
+#include <SeQuant/core/container.hpp>
 
 #include <cstddef>
 #include <functional>
 #include <limits>
+#include <memory>
+#include <unordered_map>
 
 namespace sequant {
 
 class Index;
 class Tensor;
+class Expr;
 
 /// Objective function to minimize in single-term and top-level optimize
 /// routines. The `Dense*` models assume dense tensors:
@@ -212,6 +216,18 @@ struct OptimizeOptions {
   /// tie-break (no behavior change). Consulted only by DensePeakSize /
   /// DensePeakSizeBatched.
   RooflineParams roofline = {};
+
+  /// Optional out-channel: when non-null, optimize() records for each
+  /// top-level summand's optimized ExprPtr its per-contraction-node
+  /// sliced-sets (RPN / post-order, left-first, matching single_term_opt's
+  /// Product construction). Consumed by binarize via BinarizationOptions to
+  /// annotate eval nodes. Default null => no behavior change. Only populated
+  /// when objective_function == ObjectiveFunction::DensePeakSizeBatched;
+  /// every other objective leaves any pre-existing map entry for that
+  /// summand untouched (it is simply never written).
+  std::shared_ptr<std::unordered_map<
+      sequant::Expr const*, container::vector<container::svector<Index>>>>
+      term_batch_axes = {};
 };
 
 }  // namespace sequant
diff --git a/SeQuant/core/optimize/single_term.hpp b/SeQuant/core/optimize/single_term.hpp
index bb510b7d91..0f0f0e634e 100644
--- a/SeQuant/core/optimize/single_term.hpp
+++ b/SeQuant/core/optimize/single_term.hpp
@@ -52,6 +52,12 @@ namespace detail {
 /// \param batch_persistent_only When true, only persistent (volatile-leaf-free)
 ///        subnetworks are batched; ObjectiveFunction::DensePeakSizeBatched
 ///        only.
+/// \param out_axes When non-null AND \p Metric ==
+///        ObjectiveFunction::DensePeakSizeBatched, filled with the per-node
+///        sliced-sets of the returned sequence's contraction (\c -1) nodes, in
+///        the same left-first post-order the sequence itself was built in
+///        (see \ref opt::detail::run_single_term_opt_axes). Cleared (left
+///        empty) otherwise. Ignored (must stay null) for every other metric.
 /// \return Optimal evaluation sequence under the chosen cost metric. If there
 ///         are equivalent optimal sequences then the result is the one that
 ///         keeps the order of tensors in the network as original as possible.
@@ -63,7 +69,9 @@ EvalSequence single_term_opt(
     std::function<bool(Index const&)> const& is_batchable_index = {},
     std::function<std::size_t(Index const&)> batch_target_size = {},
     std::function<double(Index const&, std::size_t)> const& inner_pow = {},
-    bool batch_persistent_only = false) {
+    bool batch_persistent_only = false,
+    container::vector<container::svector<Index>>* out_axes = nullptr) {
+  if (out_axes) out_axes->clear();
   decltype(OptRes::indices) tidxs{};
   // Unpack the cost knobs into the names the recurrence arms below use, so the
   // arms are unchanged. (void)-cast all, since each if-constexpr arm uses only
@@ -90,6 +98,8 @@ EvalSequence single_term_opt(
   if constexpr (Metric == ObjectiveFunction::DensePeakSize) {
     SEQUANT_ASSERT(!subnet_cse &&
                    "subnet_cse not supported with DensePeakSize (Phase 1)");
+    SEQUANT_ASSERT(!out_axes &&
+                   "out_axes only supported with DensePeakSizeBatched");
     (void)is_batchable_index;
     (void)batch_target_size;
     (void)batch_persistent_only;
@@ -109,15 +119,29 @@ EvalSequence single_term_opt(
     (void)footprint_weight;  // peak objectives use the roofline tie-break
     // is_volatile_leaf gates batching; volatile_weight / roofline feed the
     // secondary tie-break among equal-peak schedules.
-    return run_single_term_opt(
-        PeakBatchedModel{idxsz, is_batchable_index, batch_target_size,
-                         is_volatile_leaf, inner_pow, volatile_weight,
-                         roofline.machine_balance, roofline.fast_mem_elems,
-                         roofline.block_tiles, roofline.block_prefactor,
-                         batch_persistent_only, peak_flops_tolerance,
-                         accumulation_factor, cost.peak_threshold},
-        network, tidxs);
+    PeakBatchedModel model{idxsz,
+                           is_batchable_index,
+                           batch_target_size,
+                           is_volatile_leaf,
+                           inner_pow,
+                           volatile_weight,
+                           roofline.machine_balance,
+                           roofline.fast_mem_elems,
+                           roofline.block_tiles,
+                           roofline.block_prefactor,
+                           batch_persistent_only,
+                           peak_flops_tolerance,
+                           accumulation_factor,
+                           cost.peak_threshold};
+    if (out_axes) {
+      auto [seq, axes] = run_single_term_opt_axes(model, network, tidxs);
+      *out_axes = std::move(axes);
+      return seq;
+    }
+    return run_single_term_opt(model, network, tidxs);
   } else if constexpr (Metric == ObjectiveFunction::DenseFLOPs) {
+    SEQUANT_ASSERT(!out_axes &&
+                   "out_axes only supported with DensePeakSizeBatched");
     if (is_volatile_leaf && volatile_weight > 1.0) {
       size_t i = 0;
       for (auto&& t : network.tensors()) {
@@ -142,6 +166,8 @@ EvalSequence single_term_opt(
     static_assert(Metric == ObjectiveFunction::DenseSize,
                   "Only DenseFLOPs, DenseSize, DensePeakSize, and "
                   "DensePeakSizeBatched ObjectiveFunction supported.");
+    SEQUANT_ASSERT(!out_axes &&
+                   "out_axes only supported with DensePeakSizeBatched");
     (void)is_batchable_index;
     (void)batch_target_size;
     (void)batch_persistent_only;
@@ -172,6 +198,14 @@ EvalSequence single_term_opt(
 ///       \c is_batchable_index, \c batch_target_size, \c inner_pow,
 ///       \c batch_persistent_only) are forwarded verbatim to the detail
 ///       \ref single_term_opt overload; see it for their semantics.
+/// \param out_axes When non-null AND \p Metric ==
+///        ObjectiveFunction::DensePeakSizeBatched, filled with the per-node
+///        sliced-sets of the returned Product tree's contraction nodes, in
+///        the same left-first post-order the nested Product below is built
+///        in (so \c (*out_axes)[j] annotates the j-th Product node formed by
+///        the \c -1-handling arm of the loop below). Left empty if \p prod
+///        has fewer than 3 factors (no factorization is performed) or if
+///        \p Metric != DensePeakSizeBatched.
 ///
 template <ObjectiveFunction Metric = ObjectiveFunction::DenseFLOPs,
           has_index_extent IdxToSz>
@@ -181,10 +215,12 @@ ExprPtr single_term_opt(
     std::function<bool(Index const&)> const& is_batchable_index = {},
     std::function<std::size_t(Index const&)> batch_target_size = {},
     std::function<double(Index const&, std::size_t)> const& inner_pow = {},
-    bool batch_persistent_only = false) {
+    bool batch_persistent_only = false,
+    container::vector<container::svector<Index>>* out_axes = nullptr) {
   using ranges::views::filter;
   using ranges::views::reverse;
 
+  if (out_axes) out_axes->clear();
   if (prod.factors().size() < 3)
     return ex<Product>(Product{prod.scalar(), prod.factors().begin(),
                                prod.factors().end(), Product::Flatten::No});
@@ -192,7 +228,8 @@ ExprPtr single_term_opt(
       prod | filter(&ExprPtr::template is<Tensor>) | ranges::to_vector;
   auto seq = detail::single_term_opt<Metric>(
       TensorNetwork{tensors}, std::forward<IdxToSz>(idxsz), subnet_cse, cost,
-      is_batchable_index, batch_target_size, inner_pow, batch_persistent_only);
+      is_batchable_index, batch_target_size, inner_pow, batch_persistent_only,
+      out_axes);
   auto result = container::svector<ExprPtr>{};
   for (auto i : seq)
     if (i == -1) {

From 53937a6534b38e5fac7f54ff329d500d2c17012d Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Fri, 3 Jul 2026 19:11:48 -0400
Subject: [PATCH 12/78] eval: EvalExpr.batch_axes_ + binarize stamps per-node
 sliced-sets
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Task 3.3 of the PNO-CCSD aux+PAO batching feature: consume Task 3.2's
OptimizeOptions::term_batch_axes at binarize time.

- eval_expr.hpp: add a private container::svector<Index> batch_axes_{}
  member to EvalExpr with batch_axes()/set_batch_axes() accessors, and
  BinarizationOptions::node_batch_axes (per-contraction-node sliced-sets,
  RPN/post-order, left-first). Default-empty in both cases, so existing
  callers see no behavior change.
- eval_expr.cpp: thread a std::size_t& node_counter through
  impl::binarize / binarize(Sum, ...) / binarize(Product, ...). In
  binarize(Product, ...)'s make_prod lambda, the tensor*tensor branch is
  the genuine DP contraction node (scalar*scalar and scalar*tensor
  branches are scaffolding from bare scalar factors or the trailing
  scalar wrap, never counted by the optimizer): stamp
  opts.node_batch_axes[node_counter] onto it when in range, then always
  advance node_counter. The top-level binarize(ExprPtr, ...) entry point
  owns the counter and, when opts.node_batch_axes is non-empty, asserts
  the final count matches its size -- a mismatch means the optimizer's
  and binarize's post-orders diverged.

Verified the alignment: single_term_opt builds every contraction as a
Flatten::No 2-factor Product, so binarize's fold_left_to_node visits
exactly one tensor*tensor node per level, in the same left-first
post-order reconstruct_axes emitted node_axes in.

- test_optimize.cpp: new [optimize][annotate] test round-trips
  optimize() (DensePeakSizeBatched, forced batching via a tiny
  peak_threshold, an aux Κ index shared between two factors) through
  binarize(), and checks a node got annotated with the aux index that
  was force-batched.

[annotate] (new test) / [optimize] (13 cases, 344 assertions) /
[EvalExpr] (81 assertions) / [EvalNode] (84 assertions) / [export]
(1955 assertions) all pass.
---
 SeQuant/core/eval/eval_expr.cpp | 89 ++++++++++++++++++++-------------
 SeQuant/core/eval/eval_expr.hpp | 49 +++++++++++++++++-
 tests/unit/test_optimize.cpp    | 81 ++++++++++++++++++++++++++++++
 3 files changed, 181 insertions(+), 38 deletions(-)

diff --git a/SeQuant/core/eval/eval_expr.cpp b/SeQuant/core/eval/eval_expr.cpp
index 16b8c70797..36edcda918 100644
--- a/SeQuant/core/eval/eval_expr.cpp
+++ b/SeQuant/core/eval/eval_expr.cpp
@@ -430,14 +430,16 @@ EvalExprNode binarize(Tensor const& t) {
 }
 
 EvalExprNode binarize(Sum const& sum, IndexSet const& uncontract,
-                      const BinarizationOptions& opts) {
+                      const BinarizationOptions& opts,
+                      std::size_t& node_counter) {
   using ranges::views::move;
   using ranges::views::transform;
-  auto summands = sum.summands()  //
-                  | transform([&uncontract, &opts](ExprPtr const& x) {
-                      return impl::binarize(x, uncontract, opts);
-                    })  //
-                  | ranges::to_vector;
+  auto summands =
+      sum.summands()  //
+      | transform([&uncontract, &opts, &node_counter](ExprPtr const& x) {
+          return impl::binarize(x, uncontract, opts, node_counter);
+        })  //
+      | ranges::to_vector;
 
   bool const all_tensors =
       ranges::all_of(summands, [](auto&& n) { return n->is_tensor(); });
@@ -480,7 +482,8 @@ EvalExprNode binarize(Sum const& sum, IndexSet const& uncontract,
 }
 
 EvalExprNode binarize(Product const& prod, IndexSet const& uncontract,
-                      const BinarizationOptions& opts) {
+                      const BinarizationOptions& opts,
+                      std::size_t& node_counter) {
   using ranges::views::filter;
   using ranges::views::move;
   using ranges::views::transform;
@@ -497,17 +500,18 @@ EvalExprNode binarize(Product const& prod, IndexSet const& uncontract,
                                                                uncontract);
   }();
 
-  auto factors =
-      prod.factors()  //
-      | transform([i = 0, &ltr_uncontr_idxs, &opts](ExprPtr const& x) mutable {
-          return impl::binarize(x, ltr_uncontr_idxs.children[i++], opts);
-        })  //
-      | ranges::to_vector;
+  auto factors = prod.factors()  //
+                 | transform([i = 0, &ltr_uncontr_idxs, &opts,
+                              &node_counter](ExprPtr const& x) mutable {
+                     return impl::binarize(x, ltr_uncontr_idxs.children[i++],
+                                           opts, node_counter);
+                   })  //
+                 | ranges::to_vector;
 
   auto hvals = factors | transform([](auto&& n) { return n->hash_value(); });
   auto const hs = imed_hashes(hvals) | ranges::to_vector;
 
-  auto make_prod = [i = 0, &hs, &ltr_uncontr_idxs, &opts](
+  auto make_prod = [i = 0, &hs, &ltr_uncontr_idxs, &opts, &node_counter](
                        EvalExprNode const& left,
                        EvalExprNode const& right) mutable -> EvalExpr {
     auto h = ranges::at(hs, ++i);
@@ -567,25 +571,37 @@ EvalExprNode binarize(Product const& prod, IndexSet const& uncontract,
           TensorCanonicalizer::cardinal_tensor_labels(), &named_indices);
       hash::combine(h, canon.hash_value());
       bool const scalar_result = canon.named_indices_canonical.empty();
-      if (scalar_result) {
-        return {EvalOp::Product,          //
-                ResultType::Scalar,       //
-                detail::make_variable(),  //
-                {},                       //
-                canon.phase,              //
-                h,
-                std::move(canon.graph)};
-      } else {
-        return {EvalOp::Product,     //
-                ResultType::Tensor,  //
-                detail::make_tensor_wo_symmetries(opts, bra(target_indices.bra),
-                                                  ket(target_indices.ket),
-                                                  aux(target_indices.aux)),
-                canon.get_indices<Index::index_vector>(),  //
-                canon.phase,                               //
-                h,
-                std::move(canon.graph)};
-      }
+      EvalExpr result =
+          scalar_result
+              ? EvalExpr{EvalOp::Product,          //
+                         ResultType::Scalar,       //
+                         detail::make_variable(),  //
+                         {},                       //
+                         canon.phase,              //
+                         h,
+                         std::move(canon.graph)}
+              : EvalExpr{EvalOp::Product,     //
+                         ResultType::Tensor,  //
+                         detail::make_tensor_wo_symmetries(
+                             opts, bra(target_indices.bra),
+                             ket(target_indices.ket), aux(target_indices.aux)),
+                         canon.get_indices<Index::index_vector>(),  //
+                         canon.phase,                               //
+                         h,
+                         std::move(canon.graph)};
+      // This is a genuine contraction (DP) node: the optimizer's
+      // node_batch_axes carries one entry per such node, in the same
+      // left-first post-order (children -- built by the recursive
+      // impl::binarize calls above, which all run before this lambda is
+      // invoked -- fully processed before this node). Stamp it if the caller
+      // supplied per-node axes; always advance node_counter regardless, so
+      // the top-level SEQUANT_ASSERT(node_counter ==
+      // opts.node_batch_axes.size()) in binarize(ExprPtr, ...) can catch a
+      // misaligned optimizer/binarize post-order.
+      if (node_counter < opts.node_batch_axes.size())
+        result.set_batch_axes(opts.node_batch_axes[node_counter]);
+      ++node_counter;
+      return result;
     }
   };
 
@@ -618,7 +634,8 @@ EvalExprNode binarize(Product const& prod, IndexSet const& uncontract,
 namespace impl {
 
 EvalExprNode binarize(ExprPtr const& expr, IndexSet const& uncontract,
-                      const BinarizationOptions& opts) {
+                      const BinarizationOptions& opts,
+                      std::size_t& node_counter) {
   if (expr->is<Constant>())  //
     return binarize(expr->as<Constant>());
 
@@ -629,10 +646,10 @@ EvalExprNode binarize(ExprPtr const& expr, IndexSet const& uncontract,
     return binarize(expr->as<Tensor>());
 
   if (expr->is<Sum>())  //
-    return binarize(expr->as<Sum>(), uncontract, opts);
+    return binarize(expr->as<Sum>(), uncontract, opts, node_counter);
 
   if (expr->is<Product>())  //
-    return binarize(expr->as<Product>(), uncontract, opts);
+    return binarize(expr->as<Product>(), uncontract, opts, node_counter);
 
   if (expr->is<Power>())  //
     return binarize(expr->as<Power>());
diff --git a/SeQuant/core/eval/eval_expr.hpp b/SeQuant/core/eval/eval_expr.hpp
index 7063980195..628458a41d 100644
--- a/SeQuant/core/eval/eval_expr.hpp
+++ b/SeQuant/core/eval/eval_expr.hpp
@@ -270,6 +270,24 @@ class EvalExpr {
   [[nodiscard]] std::shared_ptr<bliss::Graph> copy_connectivity_graph()
       const noexcept;
 
+  ///
+  /// \brief Batchable indices the single-term optimizer chose to slice AT
+  /// this node (its DP `aprime`). Empty unless set by \c binarize from
+  /// \c BinarizationOptions::node_batch_axes (itself populated from
+  /// \c OptimizeOptions::term_batch_axes by the optimizer). The runtime
+  /// batched evaluator slices exactly these indices at this node.
+  ///
+  [[nodiscard]] container::svector<Index> const& batch_axes() const noexcept {
+    return batch_axes_;
+  }
+
+  ///
+  /// \brief Sets the batch axes for this node; see \c batch_axes.
+  ///
+  void set_batch_axes(container::svector<Index> axes) noexcept {
+    batch_axes_ = std::move(axes);
+  }
+
  protected:
   std::optional<EvalOp> op_type_ = std::nullopt;
 
@@ -284,6 +302,9 @@ class EvalExpr {
   size_t hash_value_;
 
   std::shared_ptr<bliss::Graph> connectivity_;
+
+  /// See \c batch_axes.
+  container::svector<Index> batch_axes_{};
 };
 
 struct EvalOpSetter {
@@ -296,6 +317,13 @@ struct BinarizationOptions {
   /// (stored as aux indices) instead of retaining the bra, ket and aux
   /// separation
   bool merge_indices = false;
+
+  /// Per-contraction-node sliced-sets (RPN / post-order, left-first) to stamp
+  /// onto the produced tree's Product (contraction) nodes; typically set from
+  /// the corresponding entry of \c OptimizeOptions::term_batch_axes for the
+  /// summand being binarized. Empty (default) => no stamping, no behavior
+  /// change. See \c EvalExpr::batch_axes.
+  container::vector<container::svector<Index>> node_batch_axes = {};
 };
 
 namespace meta {
@@ -384,8 +412,15 @@ concept leaf_node_evaluator =
 
 namespace impl {
 
+/// \param node_counter Running left-first-post-order count of contraction
+///        (Product) nodes constructed so far, threaded by reference through
+///        the whole recursive descent for ONE top-level \c binarize call, so
+///        it can be checked against \c opts.node_batch_axes.size() by the
+///        caller. Must be the SAME counter object across the entire call
+///        tree of a single top-level invocation; do not reset per subtree.
 FullBinaryNode<EvalExpr> binarize(ExprPtr const&, IndexSet const& uncontract,
-                                  const BinarizationOptions& opts);
+                                  const BinarizationOptions& opts,
+                                  std::size_t& node_counter);
 }  // namespace impl
 
 ///
@@ -427,7 +462,17 @@ binarize(ExprPtr const& expr, IndexSet const& external = {},
          const BinarizationOptions& opts = {}) {
   SEQUANT_ASSERT(
       ranges::all_of(external, [](const auto& idx) { return idx.nonnull(); }));
-  auto tree = impl::binarize(expr, external, opts);
+  std::size_t node_counter = 0;
+  auto tree = impl::binarize(expr, external, opts, node_counter);
+  // A non-empty opts.node_batch_axes means the caller expects every entry to
+  // be consumed by exactly one contraction node, in the same left-first
+  // post-order the optimizer emitted them in (see PeakBatchedModel::
+  // reconstruct_axes and single_term_opt's Product-building loop). A count
+  // mismatch means the optimizer's and binarize's post-orders diverged --
+  // fail loudly rather than silently stamp the wrong nodes.
+  if (!opts.node_batch_axes.empty()) {
+    SEQUANT_ASSERT(node_counter == opts.node_batch_axes.size());
+  }
   if constexpr (std::is_same_v<ExprT, EvalExpr>)
     return tree;
   else
diff --git a/tests/unit/test_optimize.cpp b/tests/unit/test_optimize.cpp
index 1aa1086b7d..43842edf36 100644
--- a/tests/unit/test_optimize.cpp
+++ b/tests/unit/test_optimize.cpp
@@ -24,6 +24,7 @@
 #include <initializer_list>
 #include <limits>
 #include <memory>
+#include <unordered_map>
 #include <vector>
 
 sequant::ExprPtr extract(sequant::ExprPtr expr,
@@ -2328,3 +2329,83 @@ TEST_CASE("batched DP peak matches oracle with two axes and accumulation",
   CHECK(dp < dp_K_only);
   CHECK(dp < dp_mu_only);
 }
+
+// Task 3.3: binarize() must stamp EvalExpr::batch_axes() from the optimizer's
+// per-node sliced-sets (OptimizeOptions::term_batch_axes ->
+// BinarizationOptions::node_batch_axes), and the two post-orders (the
+// optimizer's DP reconstruction and binarize's Product recursion) must line
+// up exactly -- this round-trips a real optimize() -> binarize() call and
+// checks that (a) some node actually got annotated and (b) the annotated
+// axis is the aux index the batch policy was forced to slice.
+TEST_CASE("binarize stamps per-node batch axes from optimize()",
+          "[optimize][annotate]") {
+  using namespace sequant;
+  auto ctx_resetter = set_scoped_default_context(get_default_context().clone());
+  auto reg = get_default_context().mutable_index_space_registry();
+  mbpt::add_df_spaces(reg);
+  for (auto&& [k, v] :
+       std::initializer_list<std::pair<std::wstring_view, size_t>>{
+           {L"i", 30}, {L"a", 30}, {L"Κ", 500}}) {
+    reg->retrieve_ptr(k)->approximate_size(v);
+  }
+  auto aux = reg->retrieve(L"Κ");
+  auto idxsz = [](Index const& ix) -> std::size_t {
+    return ix.nonnull() ? ix.space().approximate_size() : std::size_t{1};
+  };
+  auto is_batch = [aux](Index const& ix) { return ix.space() == aux; };
+  std::function<std::size_t(Index const&)> bts = [](Index const&) {
+    return std::size_t{20};
+  };
+
+  // 4-tensor network with Κ_1 shared between the two g's (the only batchable
+  // contraction) so a forced-batching run must slice Κ at that node.
+  auto expr =
+      deserialize(L"g{a_1;i_1;Κ_1} g{a_2;i_2;Κ_1} f{i_1;i_3} f{i_2;i_4}");
+
+  auto axes_map = std::make_shared<std::unordered_map<
+      Expr const*, container::vector<container::svector<Index>>>>();
+
+  OptimizeOptions opts;
+  opts.objective_function = ObjectiveFunction::DensePeakSizeBatched;
+  opts.idx_to_extent = idxsz;
+  opts.batch_policy.is_batchable_index = is_batch;
+  opts.batch_policy.batch_target_size = bts;
+  opts.batch_policy.peak_threshold = 1.0;  // tiny budget => force batching
+  opts.term_batch_axes = axes_map;
+
+  auto optimized = optimize(expr, opts);
+  REQUIRE(optimized);
+
+  // optimize() on a bare Product returns opt_pure_product's result directly
+  // (no enclosing Sum), so `optimized` itself is the key term_batch_axes was
+  // recorded under.
+  auto it = axes_map->find(optimized.get());
+  REQUIRE(it != axes_map->end());
+  auto const& node_axes = it->second;
+  REQUIRE(!node_axes.empty());
+
+  BinarizationOptions bopts;
+  bopts.node_batch_axes = node_axes;
+
+  SEQUANT_PRAGMA_IGNORE_DEPRECATED_BEGIN
+  // binarize(ExprPtr) is deprecated in favor of binarize(ResultExpr); using it
+  // here for ordering only -- the positional head layout it warns about does
+  // not matter for this internal-node annotation check.
+  auto node = binarize(optimized, {}, bopts);
+  SEQUANT_PRAGMA_IGNORE_DEPRECATED_END
+
+  bool any_annotated = false;
+  bool aux_found = false;
+  node.visit([&](auto const& n) {
+    if (n->batch_axes().empty()) return;
+    any_annotated = true;
+    for (auto const& ix : n->batch_axes())
+      if (ix.space() == aux) aux_found = true;
+  });
+  // The essential assertion: the round-trip actually annotated a node. If the
+  // optimizer's and binarize's post-orders had diverged, either this would be
+  // false (silently under-annotated) or the SEQUANT_ASSERT inside binarize()
+  // would have already fired above.
+  CHECK(any_annotated);
+  CHECK(aux_found);
+}

From 77b4c8f584b43cf00ddb01fb4cfe6e55c7f9f509 Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Sat, 4 Jul 2026 04:35:29 -0400
Subject: [PATCH 13/78] eval: batched evaluator prefers the per-node annotated
 batch axis

---
 SeQuant/core/eval/eval.hpp | 13 +++++++++++--
 1 file changed, 11 insertions(+), 2 deletions(-)

diff --git a/SeQuant/core/eval/eval.hpp b/SeQuant/core/eval/eval.hpp
index c6d1d2e36b..ca29fa8ea0 100644
--- a/SeQuant/core/eval/eval.hpp
+++ b/SeQuant/core/eval/eval.hpp
@@ -1164,7 +1164,16 @@ template <typename F, typename IndexPredicate = accept_any_index,
   return [le = std::move(le), target_batch_size = std::move(target_batch_size),
           accept, is_volatile, persistent_only,
           make_scope_guard](auto const& node, auto& cache) -> ResultPtr {
-    auto const K = batch_axis(node, accept);
+    // Prefer the axis the optimizer annotated at this node (see
+    // EvalExpr::batch_axes); fall back to today's largest-accepted-contracted-
+    // index heuristic when the node carries no (accepted) annotation.
+    auto pick_axis = [&accept](auto const& n) -> std::optional<Index> {
+      for (Index const& ix : n->batch_axes())
+        if (accept(ix)) return ix;
+      return batch_axis(n, accept);
+    };
+
+    auto const K = pick_axis(node);
     if (!K) {
       return nullptr;
     }
@@ -1210,7 +1219,7 @@ template <typename F, typename IndexPredicate = accept_any_index,
     cache.for_each_key([&](node_t const& k) {
       if (!cache.persistent(k) || cache.alive(k)) return;
       if (eq(k, node)) return;  // the trigger occupies its own slot
-      auto const Kk = batch_axis(k, accept);
+      auto const Kk = pick_axis(k);
       if (!Kk) return;
       if (subtree_any(k, is_volatile)) return;  // defensive: P implies NV
       auto const lk = find_leaf_carrying(k, *Kk);

From 4204ad043983dd01e9081630753de1a0650e5daa Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Sat, 4 Jul 2026 05:39:50 -0400
Subject: [PATCH 14/78] eval: recursive re-entry on the batched scratch
 realizes nested multi-axis batching

---
 SeQuant/core/eval/eval.hpp  |  59 +++++++++++++++++----
 tests/unit/test_eval_ta.cpp | 100 ++++++++++++++++++++++++++++++++++++
 2 files changed, 149 insertions(+), 10 deletions(-)

diff --git a/SeQuant/core/eval/eval.hpp b/SeQuant/core/eval/eval.hpp
index ca29fa8ea0..ecda175f80 100644
--- a/SeQuant/core/eval/eval.hpp
+++ b/SeQuant/core/eval/eval.hpp
@@ -943,11 +943,24 @@ ResultPtr evaluate_antisymm(Args&&... args) {
 /// peak memory of intermediates that carry that index.
 ///
 /// For each node it is consulted on, the returned evaluator chooses a batch
-/// axis \c K via `batch_axis(node, accept)` (declining if none). It asks the
-/// backend to partition \c K into contiguous, whole-tile element-range batches
-/// of at most \p target_batch_size(K) elements each -- the target is an upper
-/// bound, not a goal (Result::mode_batches); if that yields at most one batch
-/// it declines (so small / unselected indices are left to the standard scheme).
+/// axis \c K, preferring an axis the optimizer annotated at that node
+/// (\c EvalExpr::batch_axes; see the \c pick_axis lambda) and falling back to
+/// the largest accepted contracted index (`batch_axis(node, accept)`); it
+/// declines if neither yields an accepted axis. It asks the backend to
+/// partition \c K into contiguous, whole-tile element-range batches of at most
+/// \p target_batch_size(K) elements each -- the target is an upper bound, not a
+/// goal (Result::mode_batches); if that yields at most one batch it declines
+/// (so small / unselected indices are left to the standard scheme).
+///
+/// Because annotated axes may sit at *different* nodes of one tree, the
+/// batching nests: the per-batch scratch cache carries a reinstalled copy of
+/// this evaluator, so when the standard-scheme replay of an outer batch reaches
+/// an inner annotated node the evaluator fires again and slices that node's
+/// axis WITHIN the outer batch -- `for outer-batch: for inner-batch: replay`.
+/// The reinstalled evaluator closes over the outer-sliced leaf evaluator, so
+/// inner slicing composes on top of the outer slice; nesting is exact by the
+/// same `sum_K = sum_{batches} sum_{K in batch}` identity applied per axis, and
+/// a captured depth counter backstops runaway re-entry.
 ///
 /// Otherwise it *replays the build of every compatible persistent final* in
 /// the same batch passes: the group is the trigger node plus every key of
@@ -1160,16 +1173,28 @@ template <typename F, typename IndexPredicate = accept_any_index,
 [[nodiscard]] auto make_batched_custom_evaluator(
     F le, std::function<std::size_t(Index const&)> target_batch_size,
     IndexPredicate accept = {}, ScopeGuardFactory make_scope_guard = {},
-    IsVolatile is_volatile = {}, bool persistent_only = false) {
+    IsVolatile is_volatile = {}, bool persistent_only = false,
+    std::size_t depth = 0) {
   return [le = std::move(le), target_batch_size = std::move(target_batch_size),
-          accept, is_volatile, persistent_only,
+          accept, is_volatile, persistent_only, depth,
           make_scope_guard](auto const& node, auto& cache) -> ResultPtr {
+    // Runaway backstop: nesting re-enters this evaluator on the per-batch
+    // scratch (see the reinstall below), incrementing depth once per nested
+    // axis. Real trees nest a handful of axes deep; a large depth signals a
+    // non-terminating re-entry (e.g. a mis-annotated axis that never shrinks).
+    SEQUANT_ASSERT(depth < 8);
     // Prefer the axis the optimizer annotated at this node (see
-    // EvalExpr::batch_axes); fall back to today's largest-accepted-contracted-
-    // index heuristic when the node carries no (accepted) annotation.
-    auto pick_axis = [&accept](auto const& n) -> std::optional<Index> {
+    // EvalExpr::batch_axes); at the top level (depth 0) fall back to today's
+    // largest-accepted-contracted-index heuristic when the node carries no
+    // (accepted) annotation. NESTED re-entries (depth > 0) batch strictly on
+    // annotations: the heuristic fallback is a single-axis legacy convenience,
+    // and applying it again on the per-batch scratch would re-batch inner nodes
+    // of an unannotated subtree (extra, unintended work) rather than realizing
+    // the optimizer's chosen multi-axis nesting.
+    auto pick_axis = [&accept, depth](auto const& n) -> std::optional<Index> {
       for (Index const& ix : n->batch_axes())
         if (accept(ix)) return ix;
+      if (depth > 0) return std::nullopt;
       return batch_axis(n, accept);
     };
 
@@ -1318,6 +1343,20 @@ template <typename F, typename IndexPredicate = accept_any_index,
               return r->slice_mode(*p, e_lo, e_hi);
             return r;
           };
+          // Nest: reinstall a batched evaluator on the scratch so an inner
+          // annotated node slices its own axis WITHIN this outer batch,
+          // realizing `for outer-batch: for inner-batch: replay`. It must close
+          // over le_g -- the leaf evaluator already sliced to this outer batch
+          // -- so the inner slice composes on top of the outer one (dropping
+          // the outer slice by reusing the original `le` would be a silent
+          // correctness bug). le_g is type-erased into a std::function so this
+          // template's self-instantiation is finite: the leaf-evaluator type is
+          // std::function at every deeper level, so the reinstalled evaluator
+          // is the same specialization as the one that reinstalls it.
+          bs.cache.set_custom_evaluator(make_batched_custom_evaluator(
+              std::function<ResultPtr(node_t const&)>{le_g}, target_batch_size,
+              accept, make_scope_guard, is_volatile, persistent_only,
+              depth + 1));
           ResultPtr part = evaluate(*mem, le_g, bs.cache);
           if (!acc[m])
             acc[m] = std::move(part);
diff --git a/tests/unit/test_eval_ta.cpp b/tests/unit/test_eval_ta.cpp
index 7e878bd141..296d23b331 100644
--- a/tests/unit/test_eval_ta.cpp
+++ b/tests/unit/test_eval_ta.cpp
@@ -2172,6 +2172,106 @@ TEST_CASE("eval_batched_custom_evaluator group replay layers nested finals",
   CHECK(n_yield[L"t"] == 2);
 }
 
+TEST_CASE("eval_batched_custom_evaluator nests inner axis", "[eval]") {
+  // Task 4.2 exactness gate: two batchable axes annotated at DIFFERENT nodes of
+  // one tree must batch by nesting -- the outer node slices axis A at the top
+  // and, WITHIN each A batch, the evaluator re-enters on the per-batch scratch
+  // to slice axis B at an inner node (`for A-batch: for B-batch: replay`). The
+  // inner slice must compose on top of the outer one; the nested sum equals the
+  // unbatched contraction because `sum_K = sum_b sum_{K in b}` applies per
+  // axis.
+  using sequant::evaluate;
+  using sequant::make_batched_custom_evaluator;
+  using TA::TArrayD;
+  using node_t = sequant::FullBinaryNode<sequant::EvalExprTA>;
+  using cache_t = sequant::CacheManager<node_t>;
+
+  auto& world = TA::get_default_world();
+  // occ single-tiled (4); aux multi-tiled (12 in tiles of 4 -> 3 tiles) so both
+  // batch axes slice into 3 batches each and depth-2 nesting genuinely engages.
+  rand_tensor_yield<double, TA::DensePolicy> yield_{world, 4, 4, 12};
+  yield_.set_max_tile(4);
+
+  // Root (outer) contracts the aux axis x_1; the inner product (u*v) contracts
+  // a DIFFERENT aux axis x_2. Crucially, the inner leaf u carries BOTH x_1 and
+  // x_2, so the inner re-derivation MUST slice x_1 to the outer batch (compose
+  // le_g) -- reusing the original leaf evaluator would leave u at the full x_1
+  // extent and the x_1 contraction above would then mismatch. Every product is
+  // written fully binary so binarize preserves the nesting.
+  auto const expr = sequant::deserialize<sequant::ExprPtr>(
+      L"(((u{i_1;i_2;x_1,x_2} * v{i_1;i_3;x_2}) * w{i_2;i_5;x_1})"
+      L" * p{i_3;i_6;x_1})");
+  std::string const target = "i_5,i_6";
+  auto node = eval_node(expr);  // mutable: batch axes are annotated below
+
+  auto const aux_space =
+      sequant::get_default_context().index_space_registry()->retrieve(L"x");
+  auto accept_aux = [aux_space](sequant::Index const& ix) {
+    return ix.space() == aux_space;
+  };
+
+  // Annotate the root with its aux axis (x_1) and the unique descendant that
+  // contracts an aux axis (the inner u*v, x_2). Locating the inner node by its
+  // contracted aux axis keeps this robust to binarize's operand ordering.
+  auto const root_axis = sequant::batch_axis(node, accept_aux);
+  REQUIRE(root_axis.has_value());
+  node->set_batch_axes({*root_axis});
+
+  node_t* inner = nullptr;
+  std::optional<sequant::Index> inner_axis;
+  auto find_inner = [&](auto&& self, node_t& n) -> void {
+    if (n.leaf()) return;
+    if (&n != &node) {
+      if (auto ax = sequant::batch_axis(n, accept_aux)) {
+        inner = &n;
+        inner_axis = *ax;
+      }
+    }
+    self(self, n.left());
+    self(self, n.right());
+  };
+  find_inner(find_inner, node);
+  REQUIRE(inner != nullptr);
+  REQUIRE(inner_axis.has_value());
+  REQUIRE(*inner_axis != *root_axis);  // the two nested axes differ
+  (*inner)->set_batch_axes({*inner_axis});
+
+  // Reference: plain (unbatched) evaluation. Computed first so yield_'s random
+  // leaf arrays are generated and cached; the batched evaluator reuses them.
+  auto const ref = evaluate(node, target, yield_)->get<TArrayD>();
+
+  // Spy scope-guard: records the batch count each time an evaluator FIRES (i.e.
+  // picks an axis partitioning into >1 batch). Without the re-entrant scratch
+  // only the root fires (one record); with nesting the inner evaluator fires
+  // once per outer batch -- this vector is what proves depth-2 nesting engaged.
+  std::vector<std::size_t> guard_calls;
+  auto spy = [&guard_calls](std::size_t n) {
+    guard_calls.push_back(n);
+    return sequant::no_scope_guard{};
+  };
+
+  auto cache = cache_t::empty();
+  cache.set_custom_evaluator(make_batched_custom_evaluator(
+      yield_,
+      [](sequant::Index const&) -> std::size_t { return std::size_t{4}; },
+      accept_aux, spy, sequant::never_volatile{}));
+  auto const res = evaluate(node, target, yield_, cache)->get<TArrayD>();
+
+  // Exactness gate: the nested batched result equals the unbatched one.
+  TArrayD diff;
+  diff("i,j") = ref("i,j") - res("i,j");
+  auto const err = TA::norm2(diff);
+  REQUIRE(err < 1e-10);
+
+  // Depth-2 nesting engaged: the root fires once over x_1 (3 batches) and, per
+  // x_1 batch, the inner evaluator fires over x_2 (3 batches) -- 1 + 3 = 4
+  // firings, each partitioning into 3 batches. Before the re-entrant scratch,
+  // only the root fired (guard_calls == {3}); size > 1 is the RED/GREEN gate.
+  REQUIRE(guard_calls.size() > 1);
+  CHECK(guard_calls.size() == 4);
+  for (auto n : guard_calls) CHECK(n == 3);
+}
+
 TEST_CASE("make_evaluator BatchPolicy adapter", "[eval]") {
   // Strong equivalence: make_evaluator(policy, yielder) must produce the same
   // numerical result as a hand-built make_batched_custom_evaluator with the

From 8e0dcfd9be0c27c2f8e973dfe7a82c2d4e3de794 Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Sat, 4 Jul 2026 05:53:58 -0400
Subject: [PATCH 15/78] eval: nested batch screening relaxation scales by the
 product of batch counts

Confirms Task 4.2's re-entrant nesting already threads make_scope_guard
unchanged into the reinstalled inner evaluator, and the outer scope_guard
RAII object stays alive across the per-batch evaluate() calls that trigger
that re-entry. So a backend guard that relaxes block-sparse screening scaled
by its own level's batch count composes multiplicatively across nesting
depth for free: net relaxation = product of batch counts over all alive
levels, matching the invariant that a contribution significant over the
full product of batch axes must not be screened away in any individual
per-level batch cell.

Documents this nesting semantics at the make_scope_guard parameter, the
no_scope_guard/make_no_scope_guard default-factory doc, and the scope_guard
RAII site in make_batched_custom_evaluator.

Adds a structural composition test (dense TensorD has no real block-sparse
screening to relax, so numeric validation is deferred to the Phase 6
end-to-end MPQC run): a custom ScopeGuardFactory whose RAII guard records
construction/destruction against a shared "currently alive" stack, driven
over the existing depth-2 nested batching tree. Both guards are alive
simultaneously (stack depth 2) once per outer batch, and every such instance
records outer_batches * inner_batches == 9, proving the multiplicative
composition invariant.
---
 SeQuant/core/eval/eval.hpp  |  40 ++++++++++-
 tests/unit/test_eval_ta.cpp | 132 ++++++++++++++++++++++++++++++++++++
 2 files changed, 171 insertions(+), 1 deletion(-)

diff --git a/SeQuant/core/eval/eval.hpp b/SeQuant/core/eval/eval.hpp
index ecda175f80..a6f3f2ab7f 100644
--- a/SeQuant/core/eval/eval.hpp
+++ b/SeQuant/core/eval/eval.hpp
@@ -1012,6 +1012,28 @@ ResultPtr evaluate_antisymm(Args&&... args) {
 ///        (scaled by the batch count) so per-batch screening does not drop
 ///        small contributions that are significant once summed over the full
 ///        batch axis. Defaults to a no-op (make_no_scope_guard).
+///        NESTED levels: when annotated axes sit at different nodes of one
+///        tree (see the nesting note above the class), the re-entrant inner
+///        evaluator is built with this SAME factory (unchanged, along with
+///        \p accept, \p is_volatile, \p persistent_only and \p
+///        target_batch_size -- see the reinstall below), so the inner level
+///        constructs its own guard from `make_scope_guard(inner_batches)`.
+///        The outer guard is held for the outer level's entire batch loop,
+///        which includes the per-batch evaluate() calls that re-enter and
+///        construct the inner guard -- so both guards are alive
+///        simultaneously while the innermost contractions run. A backend
+///        factory that relaxes screening scaled by ITS OWN level's batch
+///        count therefore composes multiplicatively across nesting depth:
+///        net relaxation = product of batch counts over all nesting levels
+///        (outer_batches * inner_batches * ...), matching the invariant that
+///        a contribution significant over the full product of batch axes
+///        must not be screened away in any individual (outer-cell,
+///        inner-cell, ...) combination. No extra bookkeeping is needed to
+///        achieve this -- it falls out of RAII scoping plus unchanged
+///        threading of the factory through re-entry; see
+///        "nested scope guards compose multiplicatively" in test_eval_ta.cpp
+///        for a structural proof (dense TensorD has no real screening to
+///        relax, so it spies on guard construction/destruction instead).
 /// \param is_volatile predicate flagging a volatile leaf node (e.g. an
 ///        amplitude tensor); the evaluator declines to batch any node whose
 ///        subtree contains such a leaf, so only persistent (build-once)
@@ -1033,6 +1055,16 @@ struct accept_any_index {
 /// (e.g. divide a Cauchy-Schwarz norm-product screening threshold by n_batches:
 /// the bound for a sub-sum over 1/n of the batch axis is ~1/n of the full
 /// bound). See make_batched_custom_evaluator's \p make_scope_guard parameter.
+///
+/// Nesting: the factory is reused unchanged at every re-entrant (nested) level
+/// (see \p make_scope_guard's doc on make_batched_custom_evaluator), so nested
+/// levels each construct their own guard, scaled by their own level's batch
+/// count, and the outer guard(s) remain alive while the inner one is
+/// constructed and used. A per-level relaxation therefore composes
+/// MULTIPLICATIVELY: net relaxation = product of batch counts over all alive
+/// nesting levels, which is exactly the factor needed for a contribution
+/// significant over the full product of batch axes to survive per-cell
+/// screening at every nesting depth.
 struct no_scope_guard {};
 struct make_no_scope_guard {
   no_scope_guard operator()(std::size_t /*n_batches*/) const noexcept {
@@ -1311,7 +1343,13 @@ template <typename F, typename IndexPredicate = accept_any_index,
     // RAII scope for the batched partial contractions; a backend-supplied
     // factory may relax block-sparse screening here (scaled by the batch count)
     // so per-batch screening does not drop contributions that survive over the
-    // full batch axis.
+    // full batch axis. Held for the ENTIRE loop below, including the per-batch
+    // evaluate() calls that may re-enter this evaluator on an inner annotated
+    // node (see the reinstall's `make_scope_guard` argument): the inner
+    // level's own guard is then constructed and destroyed while this (outer)
+    // guard is still alive, so a backend that relaxes screening scaled by its
+    // own level's batch count composes multiplicatively across nesting depth
+    // (net relaxation = product of batch counts over all alive levels).
     auto const scope_guard = make_scope_guard(batches.size());
     (void)scope_guard;
 
diff --git a/tests/unit/test_eval_ta.cpp b/tests/unit/test_eval_ta.cpp
index 296d23b331..846ee84cda 100644
--- a/tests/unit/test_eval_ta.cpp
+++ b/tests/unit/test_eval_ta.cpp
@@ -2272,6 +2272,138 @@ TEST_CASE("eval_batched_custom_evaluator nests inner axis", "[eval]") {
   for (auto n : guard_calls) CHECK(n == 3);
 }
 
+TEST_CASE(
+    "eval_batched_custom_evaluator nested scope guards compose "
+    "multiplicatively",
+    "[eval]") {
+  // Task 4.3: prove that screening relaxation composes over nested batch
+  // levels. The re-entrant inner evaluator (Task 4.2) is built by threading
+  // make_scope_guard (along with accept/is_volatile/persistent_only/
+  // target_batch_size) INTO the nested make_batched_custom_evaluator call
+  // unchanged -- so the inner level constructs its own guard via
+  // make_scope_guard(inner_batches), not a no-op. The outer scope_guard is a
+  // local RAII variable held for the outer level's entire batch loop, which
+  // includes the per-batch evaluate() calls that trigger the inner re-entry;
+  // so when the inner guard is constructed, the outer guard is STILL ALIVE.
+  // A backend guard that relaxes block-sparse screening scaled by its own
+  // level's batch count therefore composes MULTIPLICATIVELY across nesting:
+  // net relaxation = outer_batches * inner_batches, matching "a contribution
+  // significant over the full product of batch axes must not be screened
+  // away in an individual (outer-cell, inner-cell) cell."
+  //
+  // This test cannot exercise REAL block-sparse screening -- the TA eval
+  // tests here use dense TensorD, which has no SparseShape to relax. Instead
+  // it proves the STRUCTURAL composition: a custom ScopeGuardFactory whose
+  // RAII guard records, on construction/destruction, the batch count it was
+  // built with against a shared "currently alive" stack. If both guards are
+  // ever alive at once with the stack holding {outer_n, inner_n}, that is
+  // exactly the multiplicative-composition invariant a real backend guard
+  // would exploit. Numeric validation against an actual screening threshold
+  // is deferred to the Phase 6 end-to-end MPQC run, where a real
+  // TiledArray-SparseShape-backed guard exists to relax.
+  using sequant::evaluate;
+  using sequant::make_batched_custom_evaluator;
+  using TA::TArrayD;
+  using node_t = sequant::FullBinaryNode<sequant::EvalExprTA>;
+  using cache_t = sequant::CacheManager<node_t>;
+
+  auto& world = TA::get_default_world();
+  // Same depth-2 nesting shape as the "nests inner axis" test above: occ
+  // single-tiled (4), aux multi-tiled (12 in tiles of 4 -> 3 tiles) so both
+  // batch axes realize 3 batches each.
+  rand_tensor_yield<double, TA::DensePolicy> yield_{world, 4, 4, 12};
+  yield_.set_max_tile(4);
+
+  auto const expr = sequant::deserialize<sequant::ExprPtr>(
+      L"(((u{i_1;i_2;x_1,x_2} * v{i_1;i_3;x_2}) * w{i_2;i_5;x_1})"
+      L" * p{i_3;i_6;x_1})");
+  std::string const target = "i_5,i_6";
+  auto node = eval_node(expr);
+
+  auto const aux_space =
+      sequant::get_default_context().index_space_registry()->retrieve(L"x");
+  auto accept_aux = [aux_space](sequant::Index const& ix) {
+    return ix.space() == aux_space;
+  };
+
+  auto const root_axis = sequant::batch_axis(node, accept_aux);
+  REQUIRE(root_axis.has_value());
+  node->set_batch_axes({*root_axis});
+
+  node_t* inner = nullptr;
+  std::optional<sequant::Index> inner_axis;
+  auto find_inner = [&](auto&& self, node_t& n) -> void {
+    if (n.leaf()) return;
+    if (&n != &node) {
+      if (auto ax = sequant::batch_axis(n, accept_aux)) {
+        inner = &n;
+        inner_axis = *ax;
+      }
+    }
+    self(self, n.left());
+    self(self, n.right());
+  };
+  find_inner(find_inner, node);
+  REQUIRE(inner != nullptr);
+  REQUIRE(inner_axis.has_value());
+  REQUIRE(*inner_axis != *root_axis);
+  (*inner)->set_batch_axes({*inner_axis});
+
+  auto const ref = evaluate(node, target, yield_)->get<TArrayD>();
+
+  // Shared recording state: a stack of currently-alive guards' batch counts
+  // (pushed on construction, popped on destruction). Whenever a guard is
+  // constructed while another is already alive (stack depth becomes 2), the
+  // product of the two counts is recorded -- that product is the net
+  // relaxation factor a composing backend guard would apply at that instant.
+  struct GuardState {
+    std::vector<std::size_t> live;
+    std::size_t max_depth = 0;
+    std::vector<std::size_t> products_at_depth2;
+  } state;
+
+  struct TrackingGuard {
+    GuardState* st;
+    TrackingGuard(GuardState* s, std::size_t n) : st(s) {
+      st->live.push_back(n);
+      st->max_depth = std::max(st->max_depth, st->live.size());
+      if (st->live.size() == 2)
+        st->products_at_depth2.push_back(st->live[0] * st->live[1]);
+    }
+    TrackingGuard(TrackingGuard const&) = delete;
+    TrackingGuard& operator=(TrackingGuard const&) = delete;
+    ~TrackingGuard() { st->live.pop_back(); }
+  };
+  auto make_tracking_guard = [&state](std::size_t n) {
+    return TrackingGuard(&state, n);
+  };
+
+  auto cache = cache_t::empty();
+  cache.set_custom_evaluator(make_batched_custom_evaluator(
+      yield_,
+      [](sequant::Index const&) -> std::size_t { return std::size_t{4}; },
+      accept_aux, make_tracking_guard, sequant::never_volatile{}));
+  auto const res = evaluate(node, target, yield_, cache)->get<TArrayD>();
+
+  // Exactness: nesting the guard-instrumented evaluator changes no numerics.
+  TArrayD diff;
+  diff("i,j") = ref("i,j") - res("i,j");
+  auto const err = TA::norm2(diff);
+  REQUIRE(err < 1e-10);
+
+  // The real deliverable: both guards were alive simultaneously (depth 2
+  // reached) at least once, and every such simultaneity records the product
+  // of outer_batches (3, over x_1) and inner_batches (3, over x_2) -- 9, the
+  // net relaxation a composing backend would apply. This happens once per
+  // outer batch (3 outer batches), matching the "nests inner axis" test's
+  // guard_calls count of 4 total firings (1 outer + 3 inner).
+  REQUIRE(state.max_depth == 2);
+  REQUIRE(state.products_at_depth2.size() == 3);
+  for (auto const p : state.products_at_depth2) CHECK(p == 9);
+  // All guards are popped by the end: no leaked / mismatched RAII scope.
+  CHECK(state.live.empty());
+}
+
 TEST_CASE("make_evaluator BatchPolicy adapter", "[eval]") {
   // Strong equivalence: make_evaluator(policy, yielder) must produce the same
   // numerical result as a hand-built make_batched_custom_evaluator with the

From 38b47210a55f3fb9a54cecbfde64c2d5dfa44dde Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Sat, 4 Jul 2026 07:54:19 -0400
Subject: [PATCH 16/78] eval: nest one batch loop per annotated axis at a
 multi-axis node

---
 SeQuant/core/eval/eval.hpp  | 108 +++++++++++++++++++--------------
 tests/unit/test_eval_ta.cpp | 116 ++++++++++++++++++++++++++++++++++++
 2 files changed, 180 insertions(+), 44 deletions(-)

diff --git a/SeQuant/core/eval/eval.hpp b/SeQuant/core/eval/eval.hpp
index a6f3f2ab7f..a9672d0cb4 100644
--- a/SeQuant/core/eval/eval.hpp
+++ b/SeQuant/core/eval/eval.hpp
@@ -944,19 +944,25 @@ ResultPtr evaluate_antisymm(Args&&... args) {
 ///
 /// For each node it is consulted on, the returned evaluator chooses a batch
 /// axis \c K, preferring an axis the optimizer annotated at that node
-/// (\c EvalExpr::batch_axes; see the \c pick_axis lambda) and falling back to
-/// the largest accepted contracted index (`batch_axis(node, accept)`); it
+/// (\c EvalExpr::batch_axes; see the \c pick_sliceable lambda) and falling back
+/// to the largest accepted contracted index (`batch_axis(node, accept)`); it
 /// declines if neither yields an accepted axis. It asks the backend to
 /// partition \c K into contiguous, whole-tile element-range batches of at most
 /// \p target_batch_size(K) elements each -- the target is an upper bound, not a
-/// goal (Result::mode_batches); if that yields at most one batch it declines
-/// (so small / unselected indices are left to the standard scheme).
+/// goal (Result::mode_batches). Axis selection is sliceability-aware: it takes
+/// the first accepted axis that actually partitions into more than one batch in
+/// the current (possibly already-outer-sliced) context, so an axis already
+/// sliced by an outer re-entry is skipped and the node advances to its next
+/// annotated axis; if no candidate is sliceable it declines (leaving small /
+/// unselected / already-fully-sliced indices to the standard scheme).
 ///
-/// Because annotated axes may sit at *different* nodes of one tree, the
-/// batching nests: the per-batch scratch cache carries a reinstalled copy of
-/// this evaluator, so when the standard-scheme replay of an outer batch reaches
-/// an inner annotated node the evaluator fires again and slices that node's
-/// axis WITHIN the outer batch -- `for outer-batch: for inner-batch: replay`.
+/// A node the optimizer priced with *several* annotated axes is sliced on each
+/// of them, and annotated axes may also sit at *different* nodes of one tree;
+/// either way the batching nests. The per-batch scratch cache carries a
+/// reinstalled copy of this evaluator, so when the standard-scheme replay of an
+/// outer batch reaches an annotated node -- an inner one, or the SAME node with
+/// a still-unsliced axis -- the evaluator fires again and slices the next axis
+/// WITHIN the outer batch -- `for outer-batch: for inner-batch: replay`.
 /// The reinstalled evaluator closes over the outer-sliced leaf evaluator, so
 /// inner slicing composes on top of the outer slice; nesting is exact by the
 /// same `sum_K = sum_{batches} sum_{K in batch}` identity applied per axis, and
@@ -1215,25 +1221,45 @@ template <typename F, typename IndexPredicate = accept_any_index,
     // axis. Real trees nest a handful of axes deep; a large depth signals a
     // non-terminating re-entry (e.g. a mis-annotated axis that never shrinks).
     SEQUANT_ASSERT(depth < 8);
-    // Prefer the axis the optimizer annotated at this node (see
-    // EvalExpr::batch_axes); at the top level (depth 0) fall back to today's
-    // largest-accepted-contracted-index heuristic when the node carries no
-    // (accepted) annotation. NESTED re-entries (depth > 0) batch strictly on
-    // annotations: the heuristic fallback is a single-axis legacy convenience,
-    // and applying it again on the per-batch scratch would re-batch inner nodes
-    // of an unannotated subtree (extra, unintended work) rather than realizing
-    // the optimizer's chosen multi-axis nesting.
-    auto pick_axis = [&accept, depth](auto const& n) -> std::optional<Index> {
+    // Axis selection is SLICEABILITY-AWARE and realizes the optimizer's
+    // multi-axis nesting one axis per depth level. candidate_axes lists this
+    // node's batch axes in the optimizer's annotated order (see
+    // EvalExpr::batch_axes), keeping the accepted annotations; at the top level
+    // (depth 0) it falls back to today's largest-accepted-contracted-index
+    // heuristic when the node carries no accepted annotation. NESTED re-entries
+    // (depth > 0) batch strictly on annotations: the heuristic fallback is a
+    // single-axis legacy convenience, and applying it again on the per-batch
+    // scratch would re-batch inner nodes of an unannotated subtree (extra,
+    // unintended work) rather than realizing the optimizer's chosen multi-axis
+    // nesting.
+    auto candidate_axes = [&accept,
+                           depth](auto const& n) -> container::svector<Index> {
+      container::svector<Index> out;
       for (Index const& ix : n->batch_axes())
-        if (accept(ix)) return ix;
-      if (depth > 0) return std::nullopt;
-      return batch_axis(n, accept);
+        if (accept(ix)) out.push_back(ix);
+      if (out.empty() && depth == 0)
+        if (auto const h = batch_axis(n, accept)) out.push_back(*h);
+      return out;
+    };
+    // Pick the FIRST candidate axis that is actually sliceable (partitions into
+    // > 1 batch) in THIS (possibly already-outer-sliced) context, returning it
+    // together with its realized partition. An axis already sliced by an outer
+    // re-entry yields a single batch on the sliced leaf and is skipped, so a
+    // nested re-entry on the SAME node advances to the node's next annotated
+    // axis -- realizing `for K-batch: for mu1-batch: replay` at one multi-axis
+    // node. The recursive reinstall below walks one axis per depth level (the
+    // depth < 8 backstop bounds the re-entry).
+    auto pick_sliceable = [&](auto const& n)
+        -> std::optional<std::pair<
+            Index, container::svector<std::pair<std::size_t, std::size_t>>>> {
+      for (Index const& ix : candidate_axes(n)) {
+        auto const lf = find_leaf_carrying(n, ix);
+        if (!lf) continue;
+        auto b = le(lf->first)->mode_batches(lf->second, target_batch_size(ix));
+        if (b.size() > 1) return std::make_pair(ix, std::move(b));
+      }
+      return std::nullopt;
     };
-
-    auto const K = pick_axis(node);
-    if (!K) {
-      return nullptr;
-    }
 
     // Persistence gate (opt-in via persistent_only): when set, decline to batch
     // any subtree containing a volatile leaf -- such a subtree is rebuilt every
@@ -1247,16 +1273,12 @@ template <typename F, typename IndexPredicate = accept_any_index,
       return nullptr;
     }
 
-    auto const leaf = find_leaf_carrying(node, *K);
-    if (!leaf) {
-      return nullptr;
-    }
-    auto const batches =
-        le(leaf->first)->mode_batches(leaf->second, target_batch_size(*K));
-
-    if (batches.size() <= 1) {
-      return nullptr;  // nothing to gain (or unbatchable)
+    auto picked = pick_sliceable(node);
+    if (!picked) {
+      return nullptr;  // no accepted, sliceable axis (nothing to gain)
     }
+    Index const K = std::move(picked->first);
+    auto const batches = std::move(picked->second);
 
     using node_t = std::remove_cvref_t<decltype(node)>;
     using member_t = std::pair<node_t const*, Index>;
@@ -1272,19 +1294,17 @@ template <typename F, typename IndexPredicate = accept_any_index,
     // The cost of considering a candidate is one leaf evaluation (the
     // mode_batches probe). With an unregistered (empty) real cache the group
     // is just the trigger.
-    std::vector<member_t> group{{&node, *K}};
+    std::vector<member_t> group{{&node, K}};
     cache.for_each_key([&](node_t const& k) {
       if (!cache.persistent(k) || cache.alive(k)) return;
       if (eq(k, node)) return;  // the trigger occupies its own slot
-      auto const Kk = pick_axis(k);
-      if (!Kk) return;
       if (subtree_any(k, is_volatile)) return;  // defensive: P implies NV
-      auto const lk = find_leaf_carrying(k, *Kk);
-      if (!lk) return;
-      if (le(lk->first)->mode_batches(lk->second, target_batch_size(*Kk)) !=
-          batches)
-        return;
-      group.emplace_back(&k, *Kk);
+      auto const pk = pick_sliceable(k);
+      if (!pk) return;
+      // Join iff this member's first sliceable axis realizes the identical
+      // partition as the trigger (so all members stream over the same batches).
+      if (pk->second != batches) return;
+      group.emplace_back(&k, pk->first);
     });
 
     // Layer by nesting: a member whose subtree contains another member
diff --git a/tests/unit/test_eval_ta.cpp b/tests/unit/test_eval_ta.cpp
index 846ee84cda..f931d0bad5 100644
--- a/tests/unit/test_eval_ta.cpp
+++ b/tests/unit/test_eval_ta.cpp
@@ -25,6 +25,7 @@
 #include <range/v3/view/single.hpp>
 #include <range/v3/view/transform.hpp>
 
+#include <algorithm>
 #include <cmath>
 #include <complex>
 #include <cstdlib>
@@ -2272,6 +2273,121 @@ TEST_CASE("eval_batched_custom_evaluator nests inner axis", "[eval]") {
   for (auto n : guard_calls) CHECK(n == 3);
 }
 
+TEST_CASE("eval_batched_custom_evaluator nests two axes on one node",
+          "[eval]") {
+  // Finding N2 regression gate: the single-term-opt DP can stamp MORE THAN ONE
+  // batch axis on a SINGLE eval node (aprime is a bitmask; reconstruct_axes
+  // pushes one Index per set bit into that node's batch_axes()). The runtime
+  // must slice ALL of them by nesting -- `for K-batch: for mu1-batch: replay`
+  // at the SAME node -- otherwise the modeled peak (which priced BOTH axes
+  // sliced) is a lie. Here ONE product node carries two aux batch axes x_1 and
+  // x_2, both present on both leaves; the evaluator must slice x_1 at depth 0
+  // and, WITHIN each x_1 batch, re-enter on the SAME node to slice x_2 at
+  // depth 1. Before the sliceability-aware pick the runtime re-picked x_1 (the
+  // first annotated axis) on the re-entry, found it already fully sliced
+  // (one batch), and DECLINED -- x_2 was never sliced (max_depth stayed 1).
+  using sequant::evaluate;
+  using sequant::make_batched_custom_evaluator;
+  using TA::TArrayD;
+  using node_t = sequant::FullBinaryNode<sequant::EvalExprTA>;
+  using cache_t = sequant::CacheManager<node_t>;
+
+  auto& world = TA::get_default_world();
+  // occ single-tiled (4); aux multi-tiled (12 in tiles of 4 -> 3 tiles).
+  rand_tensor_yield<double, TA::DensePolicy> yield_{world, 4, 4, 12};
+  yield_.set_max_tile(4);
+
+  // ONE product contracting i_1 (occ) plus BOTH aux axes x_1 and x_2; each
+  // leaf carries x_1 and x_2, so slicing either aux axis slices both leaves.
+  // Result free indices are i_5, i_6.
+  auto const expr = sequant::deserialize<sequant::ExprPtr>(
+      L"(g{i_1;i_5;x_1,x_2} * h{i_1;i_6;x_1,x_2})");
+  std::string const target = "i_5,i_6";
+  auto node = eval_node(expr);  // mutable: both batch axes annotated below
+
+  auto const aux_space =
+      sequant::get_default_context().index_space_registry()->retrieve(L"x");
+  auto accept_aux = [aux_space](sequant::Index const& ix) {
+    return ix.space() == aux_space;
+  };
+
+  // Stamp BOTH aux contracted indices on the single node (the two-set-bit
+  // aprime case). contracted_indices lists them; keep the aux ones.
+  sequant::container::svector<sequant::Index> two_axes;
+  for (sequant::Index const& ix : sequant::contracted_indices(node))
+    if (accept_aux(ix)) two_axes.push_back(ix);
+  REQUIRE(two_axes.size() == 2);
+  REQUIRE(two_axes[0] != two_axes[1]);
+  node->set_batch_axes(two_axes);
+
+  // Reference: plain (unbatched) evaluation; also generates yield_'s random
+  // leaf arrays that the batched evaluator reuses.
+  auto const ref = evaluate(node, target, yield_)->get<TArrayD>();
+
+  // Distinct per-axis target sizes so the two nested levels realize DIFFERENT
+  // batch counts. Batches snap to whole tiles of 4 and the target is an upper
+  // bound: x_1 -> target 4 over extent 12 = 3 single-tile batches; x_2 ->
+  // target 8 = 2 batches (two 4-tiles fit, then the last). A depth-2 product of
+  // 3*2 = 6 (rather than 3*3 or 2*2) proves the outer and inner levels sliced
+  // DISTINCT axes with distinct partitions.
+  auto const& x1 = two_axes[0];
+  auto target_batch_size = [x1](sequant::Index const& ix) -> std::size_t {
+    return ix == x1 ? std::size_t{4} : std::size_t{8};
+  };
+
+  // Tracking guard (as in the compose test): records the live-guard stack so
+  // depth-2 simultaneity and the per-instant product are observable.
+  struct GuardState {
+    std::vector<std::size_t> live;
+    std::size_t max_depth = 0;
+    std::vector<std::size_t> counts;
+    std::vector<std::size_t> products_at_depth2;
+  } state;
+  struct TrackingGuard {
+    GuardState* st;
+    TrackingGuard(GuardState* s, std::size_t n) : st(s) {
+      st->counts.push_back(n);
+      st->live.push_back(n);
+      st->max_depth = std::max(st->max_depth, st->live.size());
+      if (st->live.size() == 2)
+        st->products_at_depth2.push_back(st->live[0] * st->live[1]);
+    }
+    TrackingGuard(TrackingGuard const&) = delete;
+    TrackingGuard& operator=(TrackingGuard const&) = delete;
+    ~TrackingGuard() { st->live.pop_back(); }
+  };
+  auto make_tracking_guard = [&state](std::size_t n) {
+    return TrackingGuard(&state, n);
+  };
+
+  auto cache = cache_t::empty();
+  cache.set_custom_evaluator(make_batched_custom_evaluator(
+      yield_, target_batch_size, accept_aux, make_tracking_guard,
+      sequant::never_volatile{}));
+  auto const res = evaluate(node, target, yield_, cache)->get<TArrayD>();
+
+  // Exactness: nesting two axes on one node changes no numerics.
+  TArrayD diff;
+  diff("i,j") = ref("i,j") - res("i,j");
+  auto const err = TA::norm2(diff);
+  REQUIRE(err < 1e-10);
+
+  // Depth 2 reached on ONE node: x_1 sliced at depth 0, x_2 at depth 1. Before
+  // the fix the node re-picked x_1 and declined -> max_depth would stay 1.
+  REQUIRE(state.max_depth == 2);
+  // The outer level fires once over x_1 (3 batches); per outer batch the inner
+  // level fires once over x_2 (2 batches) -> 1 + 3 = 4 firings, counts a
+  // permutation of {3, 2, 2, 2}.
+  REQUIRE(state.counts.size() == 4);
+  CHECK(std::count(state.counts.begin(), state.counts.end(), 3u) == 1);
+  CHECK(std::count(state.counts.begin(), state.counts.end(), 2u) == 3);
+  // Every depth-2 instant multiplies 3 (outer x_1) by 2 (inner x_2) = 6, i.e.
+  // two DISTINCT axes with DISTINCT partitions were live together.
+  REQUIRE(state.products_at_depth2.size() == 3);
+  for (auto const p : state.products_at_depth2) CHECK(p == 6);
+  CHECK(state.live.empty());
+}
+
 TEST_CASE(
     "eval_batched_custom_evaluator nested scope guards compose "
     "multiplicatively",

From f74e5f95423d532df7a27a0e5ffcfe98201069d4 Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Sat, 4 Jul 2026 08:08:35 -0400
Subject: [PATCH 17/78] optimize: floor the sliced-axis model target to >=1 to
 match the runtime

sliced_footprints priced a sliced axis at min(e, batch_target_size(ix))
with no floor, while the TiledArray backend's result materialization
floors the realized slice to max(target,1) (result.hpp:374). A target
of 0 (a common default, e.g. MPQC's aux_target_size) made the DP model
see a zero-byte footprint for that axis and never force a second axis
to also slice, even though the runtime slices to a whole tile anyway.
Floor the model target to >=1 so it matches the runtime in the
degenerate zero-target case.
---
 SeQuant/core/optimize/single_term_detail.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/SeQuant/core/optimize/single_term_detail.hpp b/SeQuant/core/optimize/single_term_detail.hpp
index aa23a515d2..3fe0335d60 100644
--- a/SeQuant/core/optimize/single_term_detail.hpp
+++ b/SeQuant/core/optimize/single_term_detail.hpp
@@ -305,7 +305,7 @@ container::vector<container::vector<double>> sliced_footprints(
           std::size_t k =
               static_cast<std::size_t>(it - ranges::begin(aux_list));
           if (B & (std::size_t{1} << k))
-            return std::min(e, batch_target_size(ix));
+            return std::min(e, std::max<std::size_t>(batch_target_size(ix), 1));
         }
       }
       return e;

From 449f766d1f6efd9ffd84e8f191b48b4508c587ef Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Sat, 4 Jul 2026 12:18:44 -0400
Subject: [PATCH 18/78] doc: design spec for size-only eval backend + PNO-CCSD
 size harness

---
 ...2026-07-04-sizeonly-eval-backend-design.md | 242 ++++++++++++++++++
 1 file changed, 242 insertions(+)
 create mode 100644 doc/dev/specs/2026-07-04-sizeonly-eval-backend-design.md

diff --git a/doc/dev/specs/2026-07-04-sizeonly-eval-backend-design.md b/doc/dev/specs/2026-07-04-sizeonly-eval-backend-design.md
new file mode 100644
index 0000000000..bbc4079237
--- /dev/null
+++ b/doc/dev/specs/2026-07-04-sizeonly-eval-backend-design.md
@@ -0,0 +1,242 @@
+# Size-only ("Debug") eval backend and PNO-CCSD size harness
+
+_Design spec. Repo: SeQuant. Related: the aux+PAO nested batching feature on
+`feature/eval-predicted-peak-trace` (SeQuant) / mpqc4 CSV-CCk._
+
+## Goal
+
+A size-only SeQuant eval backend plus a Catch2 harness that factorizes and
+"runs" the PNO-CCSD (CSV-CCk) residual schedule against extent-tracking
+tensors (no numeric data, no TiledArray, no MPQC), so we can reproduce
+arbitrary size regimes -- including the C60 out-of-memory -- in seconds as a
+unit test instead of a multi-hour cluster build-run-debug loop.
+
+## Motivation
+
+The C60 PNO-CCSD run (job 614336) was OUT_OF_MEMORY: aggregate MaxRSS 770 GB
+vs a 743 GB node limit. It died building the intermediate
+
+    I(i_3, i_2, mu-tilde_1241, Kappa_2; a_3) = C(...;mu-tilde_1242) * g(mu-tilde_1241, mu-tilde_1242, Kappa_2)
+
+which the trace predicted at ~186 GB. This intermediate carries BOTH a free
+PAO index (mu-tilde_1241) and a free aux index (Kappa_2). The batched
+evaluator sliced only aux ("over 60 aux batches") and never sliced mu-tilde,
+so the intermediate materialized full. This is the exact free-mu-tilde leak
+the aux+PAO nested batching feature was meant to close, yet at
+`peak_threshold = 40 GB` it did single-mode aux batching only.
+
+Diagnosing this on the cluster is intractable: one build + queue + run to the
+CCSD residual is hours. We need a local reproducer that exercises the SAME
+factorizer and batched-evaluator code with configurable index sizes.
+
+## Non-goals (YAGNI)
+
+- No numeric correctness (the backend holds no data; exactness is already
+  covered by the TiledArray-backed `[eval]` tests).
+- No per-pair proto-index instantiation and no real size tables exported from
+  MPQC (defeats the arbitrary-regime goal; a moment model suffices).
+- No standalone CLI driver in the first cut (a Catch2 case with an editable
+  regime is a seconds-long loop). The harness core is a reusable function, so
+  a CLI wrapper is a trivial later add if wanted.
+
+## Architecture
+
+Reuse the entire existing pipeline unchanged:
+
+    deserialize -> single_term_opt (peak model + threshold) -> binarize
+                -> make_batched_custom_evaluator -> evaluate
+
+Swap in a size-only backend as a fourth backend alongside
+`tiledarray`/`btas`/`tapp`. Two facts make this cheap and faithful:
+
+1. The eval trace and the peak high-water mark are already driven by
+   `Result::size_in_bytes()`: `CacheManager::note_working_set()` maintains
+   `working_set_hwmark_`, printed as `hw=` and documented as the running
+   maximum peak. So running the size backend with tracing on reproduces the
+   C60 log's `Eval | ... | result=...B | hw=...B` and `BatchGroup` lines
+   exactly, instantly, and the realized peak is the final hwmark -- for free.
+2. The optimizer's cost model already consumes an `inner_pow(composite, k)`
+   moment callback (k-th power mean of a CSV composite sharing its proto set
+   with k composites), and a plain index-extent callback. The harness feeds
+   both from one config, so the DP-modeled peak and the runtime-realized peak
+   are computed from the same size model.
+
+Because the leak is a mismatch in EXTENTS (did slicing happen), not in the
+size FORMULA (both moment-aware), the harness faithfully reports whatever the
+batched evaluator actually produced -- leak included.
+
+## Components
+
+### Component 1: size-only `Result` backend
+
+Location: `SeQuant/core/eval/backends/sizeonly/{result.hpp, eval_expr.hpp}`
+(mirroring the existing `backends/tiledarray` layout).
+
+Two Result types implementing the abstract `Result` interface:
+
+- `ResultSize` (flat / Tensor-of-scalars): carries an ordered list of
+  `Index` objects (with proto-index info) and their per-mode extents. No
+  buffer.
+- `ResultSizeOfSize` (nested / Tensor-of-Tensor, for CSV amplitudes and
+  coefficients): carries the outer index list (occ proto indices) and the
+  inner index list (PNO/OSV composites).
+
+Virtuals implemented (pure virtuals from `result.hpp`):
+
+- `size_in_bytes()`: moment-aware. Partitions the Result's proto-indexed
+  modes by shared proto-index set and sizes each k-group with
+  `csv_moment(rank, k)`; non-proto modes contribute their scalar extent;
+  multiply by `numeric_size`. Reuses the cost model's `inner_aware_volume` /
+  `memsize_counter` helper so the byte formula is IDENTICAL to the DP's, not
+  a re-derivation.
+- `prod(other, target, DeNest)`: computes the result index set (union minus
+  contracted) and its extents; honors `DeNest` for ToT -> T. Returns a new
+  `ResultSize`/`ResultSizeOfSize`.
+- `sum(other, ...)`: same index set, size-preserving.
+- `slice_mode(mode, lo, hi)`: returns a copy with that mode's extent reduced
+  to `hi - lo` (this is how a batch slice shrinks a Result).
+- `mode_batches(mode, target)`: returns tile-aligned `[lo,hi)` batch ranges
+  covering the mode's extent with each batch <= target elements (mirrors
+  `mode_batches_of_trange1`, including the `max(target,1)` floor).
+- `add_inplace`, `permute`, `symmetrize`, `antisymmetrize`, `mult_by_phase`,
+  `adjoint`: size-preserving (no-op on extents, return self-equivalent).
+- `type_id()`: a new backend id.
+
+`eval_expr.hpp`: a thin adapter (like the other backends) so the leaf
+evaluator can build these Results from an `EvalExpr`, carrying its indices
+(including proto structure) and `batch_axes_`.
+
+### Component 2: `SizeRegime` config and leaf yielder
+
+Location: alongside the harness (test-side or a small `sizeonly/regime.hpp`).
+
+`SizeRegime` holds:
+
+- Scalar extents for non-proto spaces: `occ`, `aux` (Kappa), `pao`
+  (mu-tilde), and any others that appear (e.g. obs virtual if present).
+- A moment table `csv_moment(rank, k)` = mean over pairs of
+  (domain(rank))^k, indexed by rank (OSV = 1 proto index, PNO-pair = 2,
+  triple = 3) and power k in 1..4. These are INDEPENDENT numbers, not derived
+  from a single mean, so both requirements hold:
+  - rank-dependent: `<#OSV>` (rank 1, k 1) != `<#PNO>` (rank 2, k 1);
+  - moment-dependent: `<#PNO^2>` (rank 2, k 2) != `<#PNO>^2`.
+  This is the `average_csv_extent_pow(rank, k)` shape MPQC feeds the
+  optimizer. k up to 4 covers the 4-occ PHL terms (CC with a 2-body
+  Hamiltonian tops out at 4 co-proto PNO modes).
+
+The same `SizeRegime` is used to build:
+- the cost-model callbacks (index extent + `inner_pow`) for `single_term_opt`;
+- the leaf yielder `(EvalNode) -> ResultPtr` that materializes each leaf as a
+  `ResultSize`/`ResultSizeOfSize`.
+
+so the DP and the runtime see one identical size model.
+
+### Component 3: Catch2 harness/driver
+
+Location: `SeQuant/tests/unit/test_eval_sizeonly.cpp`, with a committed
+readable residual fixture under `SeQuant/tests/unit/data/`.
+
+Fixture: the CSV-CCk residual in the human-readable `deserialize` format
+(same text form as mpqc4 `csv_eqn_Rs.serialized`), committed as a test data
+file. The harness also accepts any inline deserialized expression, so a
+single offending term pasted from a trace works.
+
+Driver flow, given a `SizeRegime` + batch config (`peak_threshold`,
+`aux_target_size`, `pao_target_size`):
+
+1. deserialize the residual (or a single term);
+2. `single_term_opt` with the peak objective + threshold and the regime's
+   cost callbacks -> factorized tree with per-node `batch_axes`;
+3. `binarize` -> `EvalNode`;
+4. `make_batched_custom_evaluator` + `evaluate` against the size backend,
+   tracing on;
+5. report: DP-modeled peak vs realized hwmark; per-op result sizes; and flag
+   any op whose realized result exceeds `peak_threshold` (a leak);
+6. assert an invariant: realized peak <= tolerance * peak_threshold, where
+   tolerance is a small factor (the plan pins it, e.g. 2x, to absorb batch
+   co-residency and tile granularity without admitting a real leak). On the
+   C60 regime this assertion FAILS today (reproducing the 186 GB leak) and
+   PASSES once the fix lands -- so the same test is both the reproducer and
+   the regression lock.
+
+## Data flow
+
+    SizeRegime --+--> cost callbacks (extent, inner_pow) --> single_term_opt --> batch_axes
+                 |                                                                    |
+                 +--> leaf yielder --> ResultSize/ResultSizeOfSize                    v
+                                                     \--> make_batched_custom_evaluator + evaluate
+                                                                    |
+                                              trace (Eval/BatchGroup/hw)  +  realized peak (hwmark)
+                                                                    |
+                                              report modeled vs realized + leak flags + assert
+
+## Phasing (drives the implementation plan)
+
+Task 1 is the go/no-go that localizes the C60 bug to factorizer vs runtime;
+it is also the smallest useful slice and de-risks the sizing model.
+
+- **Phase 1 (probe / audit): DP-annotation dump on the offending term.**
+  Deserialize just the free-mu-tilde PHL 4-occ term (from the C60 trace),
+  build the C60 `SizeRegime` (mu-tilde ~1800, Kappa ~4300, PNO moments, occ),
+  run `single_term_opt` at 40 GB threshold, and print the per-node
+  `batch_axes`. This requires only the cost-model callbacks + a minimal
+  size_in_bytes -- not the full runtime backend. It answers directly:
+  - if the offending intermediate's node has NO mu-tilde annotation ->
+    layer-1 (cost-model/threshold) bug: the DP never asked to slice mu-tilde;
+  - if it DOES carry a mu-tilde annotation -> layer-2 (runtime) bug: the
+    batched evaluator dropped it.
+  Validation gate: the moment sizing must reproduce the real trace numbers
+  for this term (the ~1.87 GB aux-batch giant `g(mu-tilde,mu-tilde,Kappa)`
+  and the ~186 GB free-mu-tilde intermediate) within a small factor, else the
+  regime is mis-modeled and later verdicts are untrustworthy.
+
+- **Phase 2: full size-only Result backend** (Component 1) with moment-aware
+  `size_in_bytes`, `slice_mode`, `mode_batches`, `prod`/`sum`/`DeNest`.
+
+- **Phase 3: full harness** (Component 3): deserialize the whole residual,
+  run the batched evaluate against the backend with tracing, report modeled
+  vs realized peak, flag leaks, assert the peak invariant. This is the
+  end-to-end leak reproducer.
+
+- **Phase 4: lock the C60 regime as a regression test** -- failing now,
+  passing after the batching fix (whichever layer Phase 1 implicates).
+
+## Validation strategy
+
+Trust the harness only after it reproduces known real numbers. Anchor points
+from the C60 log (approximate, per the 8-rank run):
+
+- `g(mu-tilde, mu-tilde, Kappa)` full ~1.87 GB per aux-batch (sliced to 60
+  aux batches);
+- `I(i_3, i_2, mu-tilde_1241, Kappa_2; a_3)` ~186 GB (free mu-tilde + free
+  aux, unsliced).
+
+The size backend, fed the C60 regime, must land within a small factor of
+these before its factorization/leak verdicts are believed. (Exact match is
+not expected: the regime uses representative moments, not per-pair sizes.)
+
+## File layout
+
+- `SeQuant/core/eval/backends/sizeonly/result.hpp` -- `ResultSize`,
+  `ResultSizeOfSize`.
+- `SeQuant/core/eval/backends/sizeonly/eval_expr.hpp` -- leaf adapter.
+- `SeQuant/core/eval/backends/sizeonly/regime.hpp` -- `SizeRegime` + callback
+  builders + leaf yielder (or test-side if it stays test-only).
+- `SeQuant/tests/unit/test_eval_sizeonly.cpp` -- probe + harness cases.
+- `SeQuant/tests/unit/data/csv_ccsd_residual.txt` -- committed residual
+  fixture (readable deserialize form).
+
+## Risks
+
+- **ToT / proto-index nesting fidelity (main risk).** The size model for
+  nested (CSV) Results must match how the real backend nests -- the
+  outer-occ vs inner-PNO split and the moment-aware sizing -- so
+  `prod`+`DeNest`, `slice_mode`, and `mode_batches` behave consistently with
+  reality. Mitigated by reusing the cost model's `inner_aware_volume` and by
+  the Phase 1 validation gate against real trace numbers.
+- **DP/runtime sizing drift.** If the runtime backend and the cost model ever
+  computed sizes differently, modeled-vs-realized gaps would be artifacts.
+  Mitigated by sharing one `SizeRegime` and one `inner_aware_volume` helper.
+- **Fixture staleness.** The committed residual could drift from what MPQC
+  generates. Mitigated by keeping it in the readable deserialize form and
+  refreshing it from an MPQC dump when the CC/CSV equations change.

From 314cfc5a922ee9f30ad1ffe1bdf85312e1046383 Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Sat, 4 Jul 2026 12:39:42 -0400
Subject: [PATCH 19/78] doc: size-only backend sizing is a pluggable oracle
 (dense default), not hardwired dense

---
 ...2026-07-04-sizeonly-eval-backend-design.md | 42 ++++++++++++++++---
 1 file changed, 36 insertions(+), 6 deletions(-)

diff --git a/doc/dev/specs/2026-07-04-sizeonly-eval-backend-design.md b/doc/dev/specs/2026-07-04-sizeonly-eval-backend-design.md
index bbc4079237..5e32a7344d 100644
--- a/doc/dev/specs/2026-07-04-sizeonly-eval-backend-design.md
+++ b/doc/dev/specs/2026-07-04-sizeonly-eval-backend-design.md
@@ -83,12 +83,14 @@ Two Result types implementing the abstract `Result` interface:
 
 Virtuals implemented (pure virtuals from `result.hpp`):
 
-- `size_in_bytes()`: moment-aware. Partitions the Result's proto-indexed
-  modes by shared proto-index set and sizes each k-group with
-  `csv_moment(rank, k)`; non-proto modes contribute their scalar extent;
-  multiply by `numeric_size`. Reuses the cost model's `inner_aware_volume` /
-  `memsize_counter` helper so the byte formula is IDENTICAL to the DP's, not
-  a re-derivation.
+- `size_in_bytes()`: consults a pluggable **size oracle** (see "Size oracle"
+  below) over the Result's current index set + extents. The DEFAULT oracle is
+  the dense moment model: partition the proto-indexed modes by shared
+  proto-index set, size each k-group with `csv_moment(rank, k)`, multiply by
+  the non-proto scalar extents and `numeric_size`, reusing the cost model's
+  `inner_aware_volume` / `memsize_counter` helper so the byte formula is
+  IDENTICAL to the DP's, not a re-derivation. The backend does not hardwire
+  dense: any oracle (sparse-shape-aware, adversarial) plugs in here.
 - `prod(other, target, DeNest)`: computes the result index set (union minus
   contracted) and its extents; honors `DeNest` for ToT -> T. Returns a new
   `ResultSize`/`ResultSizeOfSize`.
@@ -106,6 +108,34 @@ Virtuals implemented (pure virtuals from `result.hpp`):
 evaluator can build these Results from an `EvalExpr`, carrying its indices
 (including proto structure) and `batch_axes_`.
 
+### Size oracle: dense default, sparsity as a plug-in
+
+The backend does NOT assume dense tensors as a baked-in property. Only
+`size_in_bytes` needs a size model; every other mechanism -- index-set
+tracking, `prod`/`sum`/`DeNest`, `slice_mode`, `mode_batches`, and the
+batching loop -- is sparsity-agnostic (batching tiles by ELEMENT count,
+slicing shrinks EXTENTS). So the size model is a single pluggable seam: a
+`SizeOracle` = invocable `(index set + extents + proto structure) -> bytes`.
+
+The default oracle is the dense moment model above. This is the RIGHT default,
+not a limitation, for the C60 target:
+
+- The C60 optimizer runs `objective_function: dense_peak_size` -- the DP is
+  itself dense -- so the dense oracle reproduces the factorizer's decisions
+  (and `batch_axes` annotations) exactly. This is what the Phase 1 probe
+  needs.
+- The C60 runtime has `result_shape_constraints: true` (SparseShape on CC
+  intermediates), so realized sizes can be below dense. The dense oracle is
+  therefore a CONSERVATIVE UPPER BOUND on the realized peak: dense-under-budget
+  implies sparse-under-budget, so it never yields a false "fix worked."
+- The leaking intermediate is fully dense anyway (`nnz_tiles=54000/54000`), so
+  the dense oracle reproduces the 186 GB leak with no sparsity to model.
+
+A sparse-shape-aware or adversarial oracle is a future plug-in at this same
+seam, with NO change to backend mechanics. Reimplementing SparseShape
+propagation is explicitly out of scope for the first cut (heavy, and
+unnecessary for a dense leak).
+
 ### Component 2: `SizeRegime` config and leaf yielder
 
 Location: alongside the harness (test-side or a small `sizeonly/regime.hpp`).

From b02a9a82b2b46127b6987640ed0ba95a29b9d173 Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Sat, 4 Jul 2026 13:00:17 -0400
Subject: [PATCH 20/78] doc: reframe eval-backend spec as cost-model replay
 (report memsize+FLOPs+exec cost, not just size)

---
 ...04-costmodel-replay-eval-backend-design.md | 286 ++++++++++++++++++
 ...2026-07-04-sizeonly-eval-backend-design.md | 272 -----------------
 2 files changed, 286 insertions(+), 272 deletions(-)
 create mode 100644 doc/dev/specs/2026-07-04-costmodel-replay-eval-backend-design.md
 delete mode 100644 doc/dev/specs/2026-07-04-sizeonly-eval-backend-design.md

diff --git a/doc/dev/specs/2026-07-04-costmodel-replay-eval-backend-design.md b/doc/dev/specs/2026-07-04-costmodel-replay-eval-backend-design.md
new file mode 100644
index 0000000000..059ec13176
--- /dev/null
+++ b/doc/dev/specs/2026-07-04-costmodel-replay-eval-backend-design.md
@@ -0,0 +1,286 @@
+# Cost-model replay eval backend and PNO-CCSD cost harness
+
+_Design spec. Repo: SeQuant. Related: the aux+PAO nested batching feature on
+`feature/eval-predicted-peak-trace` (SeQuant) / mpqc4 CSV-CCk._
+
+## Goal
+
+A cost-model replay eval backend plus a Catch2 harness that factorizes and
+replays the PNO-CCSD (CSV-CCk) residual schedule over `CacheManager` against
+thin structural tokens (no numeric data, no TiledArray, no MPQC), reporting
+for each evaluation exactly what the optimizer's OWN cost model reports:
+projected memory size, FLOPs, and projected execution cost. This lets us
+reproduce arbitrary size regimes -- including the C60 out-of-memory -- as a
+unit test in seconds instead of a multi-hour cluster build-run-debug loop, and
+see the optimizer-projected cost (the `dense_peak_size` frontier) side by side
+with the cost actually realized when the schedule is replayed.
+
+## Motivation
+
+The C60 PNO-CCSD run (job 614336) was OUT_OF_MEMORY: aggregate MaxRSS 770 GB
+vs a 743 GB node limit. It died building the intermediate
+
+    I(i_3, i_2, mu-tilde_1241, Kappa_2; a_3) = C(...;mu-tilde_1242) * g(mu-tilde_1241, mu-tilde_1242, Kappa_2)
+
+which the trace projected at ~186 GB. This intermediate carries BOTH a free
+PAO index (mu-tilde_1241) and a free aux index (Kappa_2). The batched
+evaluator sliced only aux ("over 60 aux batches") and never sliced mu-tilde,
+so the intermediate materialized full. The optimizer ran
+`objective_function: dense_peak_size` at `peak_threshold = 40 GB`, yet the
+schedule did single-mode aux batching only.
+
+`dense_peak_size` optimizes on a frontier of two quantities: peak memory and a
+projected execution cost (roofline of FLOPs against `machine_balance` /
+`fast_mem_elems`). To understand why the frontier search chose an aux-only
+schedule -- and whether the runtime then diverged from it -- we want to report
+those SAME quantities, per evaluation, on a local replay. Diagnosing this on
+the cluster is intractable (hours per iteration).
+
+## Non-goals (YAGNI)
+
+- No numeric correctness (the backend holds no data; exactness is covered by
+  the TiledArray-backed `[eval]` tests).
+- No per-pair proto-index instantiation and no real size tables from MPQC (a
+  moment model suffices; per-pair defeats the arbitrary-regime goal).
+- No SparseShape propagation in the first cut. The cost model is a pluggable
+  object (see Component 1); a sparse or adversarial model is a later plug-in
+  with no change to the replay mechanics.
+- No standalone CLI driver in the first cut (a Catch2 case with an editable
+  regime is a seconds-long loop). The harness core is reusable, so a CLI is a
+  trivial later add.
+
+## Key idea
+
+The quantities we want -- memory, FLOPs, projected execution cost -- are ALL
+already produced by one object: the optimizer's cost model. `cost_model.hpp`
+defines a CostModel concept with concrete models (`DensePeakSize`,
+`DensePeakSizeBatched`, `DenseFLOPs`), each built from the reusable per-op
+functors `memsize_counter(idxsz, inner_pow)` and `flops_counter(idxsz,
+inner_pow)` plus `roofline_op_cost(flops, block_tiles, ...,  machine_balance,
+fast_mem_elems)` (the projected execution cost; pure FLOPs when
+`machine_balance == 0`).
+
+So the harness does not re-derive any sizing: it PASSES the cost model object
+and queries it per evaluation. The eval machinery (`evaluate` +
+`make_batched_custom_evaluator` over `CacheManager`) supplies the SCHEDULE and
+the alive-set dynamics (including batching -- a slice alive instead of the
+whole); the cost model supplies the numbers. Peak memory is the max over
+schedule-time of the summed cost-model memory of the alive set. Because the DP
+and the replay use the SAME cost model, a gap between DP-projected and
+replay-realized cost is a real DP-vs-runtime bug (the leak), not a modeling
+artifact.
+
+## Architecture
+
+Reuse the entire pipeline unchanged:
+
+    deserialize -> single_term_opt (chosen objective + threshold) -> binarize
+                -> make_batched_custom_evaluator -> evaluate  (over CacheManager)
+
+Add a cost-model replay backend as a fourth backend alongside
+`tiledarray`/`btas`/`tapp`. Two hooks carry the cost model's numbers:
+
+1. Peak memory reuses CacheManager verbatim. `CacheManager::note_working_set`
+   maintains `working_set_hwmark_` (printed as `hw=`, documented as the running
+   peak), driven by `Result::size_in_bytes()`. The cost-token Result's
+   `size_in_bytes()` DELEGATES to the cost model's `memsize`. This is a
+   modeling backend: it holds no data, so its only "size" IS the modeled one
+   -- not an actual-size abuse but the sole size the token has. So the hwmark
+   becomes the cost-model-projected peak, for free.
+2. FLOPs and projected execution cost do NOT fit `size_in_bytes`. At each
+   `prod`/`sum` the harness queries the SAME cost model object for the op's
+   FLOPs and roofline cost, emits them in the trace, and accumulates totals.
+
+## Components
+
+### Component 1: the cost model object
+
+Location: reuse `SeQuant/core/optimize/` cost functors; expose a small bundle
+(e.g. `SeQuant/core/eval/backends/costtoken/cost_model_object.hpp`).
+
+A queryable object bundling the optimizer's OWN functors, built from a
+`SizeRegime` (Component 3):
+
+- `memsize(index_set) -> bytes` (from `memsize_counter(idxsz, inner_pow)`);
+- `flops(op) -> count` (from `flops_counter(idxsz, inner_pow)`);
+- `exec_cost(op) -> double` (from `roofline_op_cost(..., machine_balance,
+  fast_mem_elems, block_tiles, block_prefactor)`).
+
+Default construction mirrors `DensePeakSize` (dense, moment-aware) so the
+replay reports exactly what the C60 `dense_peak_size` optimization used. The
+object is the single seam for the size model: a SparseShape-aware or
+adversarial cost model plugs in here with NO change to the token or the replay.
+Nothing is re-derived -- `memsize_counter`/`flops_counter`/`roofline_op_cost`
+are the optimizer's own code.
+
+### Component 2: cost-token Result backend
+
+Location: `SeQuant/core/eval/backends/costtoken/{result.hpp, eval_expr.hpp}`
+(mirroring `backends/tiledarray`).
+
+Two Result types implementing the abstract `Result` interface:
+
+- `ResultCostToken` (flat / Tensor-of-scalars): carries an ordered `Index`
+  list (with proto info) and per-mode extents. No buffer.
+- `ResultCostTokenNested` (Tensor-of-Tensor, for CSV amplitudes/coefficients):
+  carries the outer (occ proto) and inner (PNO/OSV composite) index lists.
+
+Virtuals:
+
+- `size_in_bytes()`: returns `cost_model.memsize(this token's current index
+  set)`. Delegated to Component 1; no bespoke math in the token. (See
+  Architecture hook 1 for the semantics.)
+- `prod(other, target, DeNest)`: computes the result index set (union minus
+  contracted); honors `DeNest` for ToT -> T. Structural only.
+- `sum(other, ...)`: same index set.
+- `slice_mode(mode, lo, hi)`: copy with that mode's extent reduced to `hi -
+  lo` (how a batch slice shrinks a token; makes its `memsize` drop).
+- `mode_batches(mode, target)`: tile-aligned `[lo,hi)` batch ranges,
+  `max(target,1)` floor (mirrors `mode_batches_of_trange1`).
+- `add_inplace`, `permute`, `symmetrize`, `antisymmetrize`, `mult_by_phase`,
+  `adjoint`: size-preserving (structural no-ops).
+- `type_id()`: a new backend id.
+
+FLOPs and exec cost are NOT exposed through the token; the harness reports them
+per op from the cost model object (Architecture hook 2).
+
+`eval_expr.hpp`: thin adapter so the leaf evaluator builds tokens from an
+`EvalExpr`, carrying indices (proto structure) and `batch_axes_`.
+
+### Component 3: `SizeRegime` + harness
+
+Location: `SeQuant/tests/unit/test_eval_costtoken.cpp` plus a committed
+readable residual fixture under `SeQuant/tests/unit/data/`. `SizeRegime` may
+live test-side or in `backends/costtoken/regime.hpp`.
+
+`SizeRegime` supplies the cost model's parameters:
+
+- scalar extents for non-proto spaces: `occ`, `aux` (Kappa), `pao`
+  (mu-tilde);
+- a moment table `csv_moment(rank, k)` = mean over pairs of (domain(rank))^k,
+  rank in {1 (OSV), 2 (PNO pair), 3 (triple)}, k in 1..4. These are
+  INDEPENDENT numbers, so both hold: rank-dependent (`<#OSV>` != `<#PNO>`) and
+  moment-dependent (`<#PNO^2>` != `<#PNO>^2`). This is the
+  `average_csv_extent_pow(rank, k)` shape MPQC feeds the optimizer; k up to 4
+  covers the 4-occ PHL terms (CC with a 2-body Hamiltonian).
+- roofline parameters: `machine_balance`, `fast_mem_elems`, block params
+  (matching the C60 `optimize` block: `machine_balance 200`, `fast_mem_elems
+  1000000`), so the projected exec cost matches the run.
+
+One `SizeRegime` builds the single cost model object used by BOTH
+`single_term_opt` (the DP frontier) and the replay (token `size_in_bytes` +
+per-op flops/exec). No drift by construction.
+
+Fixture: the CSV-CCk residual in the human-readable `deserialize` format (same
+text form as mpqc4 `csv_eqn_Rs.serialized`), committed as test data. The
+harness also accepts an inline deserialized expression, so a single offending
+term pasted from a trace works.
+
+Driver flow, given `SizeRegime` + batch config (`peak_threshold`,
+`aux_target_size`, `pao_target_size`):
+
+1. deserialize the residual (or a single term);
+2. `single_term_opt` with the chosen objective + threshold and the regime's
+   cost model -> factorized tree with per-node `batch_axes`, and the
+   DP-projected frontier point (peak, exec cost);
+3. `binarize` -> `EvalNode`;
+4. replay: `make_batched_custom_evaluator` + `evaluate` over `CacheManager`
+   with the cost-token backend, tracing on;
+5. report, per op: cost-model `{memsize, flops, exec_cost}`; and overall:
+   realized peak memory (hwmark), total FLOPs, total exec cost; alongside the
+   DP-projected frontier point from step 2;
+6. flag any op whose realized memsize exceeds `peak_threshold` (a leak);
+7. assert: realized peak <= tolerance * peak_threshold (tolerance a small
+   factor, e.g. 2x, pinned in the plan). On the C60 regime this FAILS today
+   (reproducing the 186 GB leak) and PASSES once the batching fix lands -- so
+   the same test is reproducer and regression lock.
+
+## Data flow
+
+    SizeRegime --> CostModel object (memsize, flops, exec_cost)
+                     |                                   |
+                     v                                   v
+              single_term_opt                 replay over CacheManager:
+              (DP frontier: peak,             token.size_in_bytes=memsize -> hwmark (peak)
+               exec cost) + batch_axes        per-op query -> flops + exec cost
+                     |                                   |
+                     +------------ report: DP-projected vs realized ----------+
+                                   {peak memory, FLOPs, exec cost} + leak flags + assert
+
+## Phasing (drives the implementation plan)
+
+Task 1 is the go/no-go that localizes the C60 bug to factorizer vs runtime,
+and de-risks the cost model object.
+
+- **Phase 1 (probe / audit): DP-annotation dump on the offending term.**
+  Deserialize just the free-mu-tilde PHL 4-occ term (from the C60 trace),
+  build the C60 `SizeRegime` and cost model object, run `single_term_opt` at
+  40 GB threshold, and print the per-node `batch_axes`. Needs only the cost
+  model object + `single_term_opt` -- not the replay backend. It answers:
+  - offending node has NO mu-tilde annotation -> layer-1 (cost-model /
+    threshold) bug: the DP never asked to slice mu-tilde;
+  - node DOES carry a mu-tilde annotation -> layer-2 (runtime) bug: the batched
+    evaluator dropped it.
+  Validation gate: the cost model's `memsize` must reproduce the real trace
+  numbers for this term (the ~1.87 GB aux-batch `g(mu-tilde,mu-tilde,Kappa)`
+  and the ~186 GB free-mu-tilde intermediate) within a small factor, and the
+  FLOPs/exec cost should be sane, else the regime is mis-modeled.
+
+- **Phase 2: cost model object + cost-token backend** (Components 1-2), with
+  `size_in_bytes` delegating to `memsize`, plus `slice_mode`, `mode_batches`,
+  `prod`/`sum`/`DeNest`.
+
+- **Phase 3: full harness** (Component 3): deserialize the whole residual,
+  replay over CacheManager, report per-op `{memsize, flops, exec_cost}` +
+  realized peak/totals vs the DP-projected frontier, flag leaks, assert the
+  peak invariant. The end-to-end leak reproducer.
+
+- **Phase 4: lock the C60 regime as a regression test** -- failing now,
+  passing after the batching fix (whichever layer Phase 1 implicates).
+
+## Validation strategy
+
+Trust the harness only after the cost model reproduces known real numbers.
+Anchors from the C60 log (approximate, 8-rank run):
+
+- `g(mu-tilde, mu-tilde, Kappa)` ~1.87 GB per aux-batch (sliced to 60 aux
+  batches);
+- `I(i_3, i_2, mu-tilde_1241, Kappa_2; a_3)` ~186 GB (free mu-tilde + free
+  aux, unsliced).
+
+The cost model, fed the C60 regime, must land within a small factor of these
+before its factorization/leak verdicts are believed. Exact match is not
+expected (representative moments, not per-pair sizes). Sanity-check FLOPs and
+exec cost on one known contraction too.
+
+## File layout
+
+- `SeQuant/core/eval/backends/costtoken/cost_model_object.hpp` -- the queryable
+  bundle over the optimizer's functors.
+- `SeQuant/core/eval/backends/costtoken/result.hpp` -- `ResultCostToken`,
+  `ResultCostTokenNested`.
+- `SeQuant/core/eval/backends/costtoken/eval_expr.hpp` -- leaf adapter.
+- `SeQuant/core/eval/backends/costtoken/regime.hpp` -- `SizeRegime` + builders
+  (or test-side if it stays test-only).
+- `SeQuant/tests/unit/test_eval_costtoken.cpp` -- probe + harness cases.
+- `SeQuant/tests/unit/data/csv_ccsd_residual.txt` -- committed residual
+  fixture (readable deserialize form).
+
+## Risks
+
+- **ToT / proto-index nesting fidelity (main risk).** The nested token must
+  match how the real backend nests -- outer-occ vs inner-PNO split and the
+  moment-aware sizing -- so `prod`+`DeNest`, `slice_mode`, and `mode_batches`
+  behave consistently with reality. Mitigated by reusing the optimizer's
+  `memsize_counter`/`inner_pow` and by the Phase 1 validation gate against real
+  trace numbers.
+- **`size_in_bytes` delegation.** Semantically `size_in_bytes` is the actual
+  size on real backends; here it returns the modeled `memsize`. Contained: only
+  the cost-token backend does this, documented as a modeling backend with no
+  data. Real backends are untouched.
+- **DP/replay cost drift.** If the DP and the replay ever computed cost
+  differently, gaps would be artifacts. Mitigated by building both from one
+  cost model object.
+- **Fixture staleness.** The committed residual could drift from MPQC's.
+  Mitigated by keeping it in the readable deserialize form and refreshing from
+  an MPQC dump when the CC/CSV equations change.
diff --git a/doc/dev/specs/2026-07-04-sizeonly-eval-backend-design.md b/doc/dev/specs/2026-07-04-sizeonly-eval-backend-design.md
deleted file mode 100644
index 5e32a7344d..0000000000
--- a/doc/dev/specs/2026-07-04-sizeonly-eval-backend-design.md
+++ /dev/null
@@ -1,272 +0,0 @@
-# Size-only ("Debug") eval backend and PNO-CCSD size harness
-
-_Design spec. Repo: SeQuant. Related: the aux+PAO nested batching feature on
-`feature/eval-predicted-peak-trace` (SeQuant) / mpqc4 CSV-CCk._
-
-## Goal
-
-A size-only SeQuant eval backend plus a Catch2 harness that factorizes and
-"runs" the PNO-CCSD (CSV-CCk) residual schedule against extent-tracking
-tensors (no numeric data, no TiledArray, no MPQC), so we can reproduce
-arbitrary size regimes -- including the C60 out-of-memory -- in seconds as a
-unit test instead of a multi-hour cluster build-run-debug loop.
-
-## Motivation
-
-The C60 PNO-CCSD run (job 614336) was OUT_OF_MEMORY: aggregate MaxRSS 770 GB
-vs a 743 GB node limit. It died building the intermediate
-
-    I(i_3, i_2, mu-tilde_1241, Kappa_2; a_3) = C(...;mu-tilde_1242) * g(mu-tilde_1241, mu-tilde_1242, Kappa_2)
-
-which the trace predicted at ~186 GB. This intermediate carries BOTH a free
-PAO index (mu-tilde_1241) and a free aux index (Kappa_2). The batched
-evaluator sliced only aux ("over 60 aux batches") and never sliced mu-tilde,
-so the intermediate materialized full. This is the exact free-mu-tilde leak
-the aux+PAO nested batching feature was meant to close, yet at
-`peak_threshold = 40 GB` it did single-mode aux batching only.
-
-Diagnosing this on the cluster is intractable: one build + queue + run to the
-CCSD residual is hours. We need a local reproducer that exercises the SAME
-factorizer and batched-evaluator code with configurable index sizes.
-
-## Non-goals (YAGNI)
-
-- No numeric correctness (the backend holds no data; exactness is already
-  covered by the TiledArray-backed `[eval]` tests).
-- No per-pair proto-index instantiation and no real size tables exported from
-  MPQC (defeats the arbitrary-regime goal; a moment model suffices).
-- No standalone CLI driver in the first cut (a Catch2 case with an editable
-  regime is a seconds-long loop). The harness core is a reusable function, so
-  a CLI wrapper is a trivial later add if wanted.
-
-## Architecture
-
-Reuse the entire existing pipeline unchanged:
-
-    deserialize -> single_term_opt (peak model + threshold) -> binarize
-                -> make_batched_custom_evaluator -> evaluate
-
-Swap in a size-only backend as a fourth backend alongside
-`tiledarray`/`btas`/`tapp`. Two facts make this cheap and faithful:
-
-1. The eval trace and the peak high-water mark are already driven by
-   `Result::size_in_bytes()`: `CacheManager::note_working_set()` maintains
-   `working_set_hwmark_`, printed as `hw=` and documented as the running
-   maximum peak. So running the size backend with tracing on reproduces the
-   C60 log's `Eval | ... | result=...B | hw=...B` and `BatchGroup` lines
-   exactly, instantly, and the realized peak is the final hwmark -- for free.
-2. The optimizer's cost model already consumes an `inner_pow(composite, k)`
-   moment callback (k-th power mean of a CSV composite sharing its proto set
-   with k composites), and a plain index-extent callback. The harness feeds
-   both from one config, so the DP-modeled peak and the runtime-realized peak
-   are computed from the same size model.
-
-Because the leak is a mismatch in EXTENTS (did slicing happen), not in the
-size FORMULA (both moment-aware), the harness faithfully reports whatever the
-batched evaluator actually produced -- leak included.
-
-## Components
-
-### Component 1: size-only `Result` backend
-
-Location: `SeQuant/core/eval/backends/sizeonly/{result.hpp, eval_expr.hpp}`
-(mirroring the existing `backends/tiledarray` layout).
-
-Two Result types implementing the abstract `Result` interface:
-
-- `ResultSize` (flat / Tensor-of-scalars): carries an ordered list of
-  `Index` objects (with proto-index info) and their per-mode extents. No
-  buffer.
-- `ResultSizeOfSize` (nested / Tensor-of-Tensor, for CSV amplitudes and
-  coefficients): carries the outer index list (occ proto indices) and the
-  inner index list (PNO/OSV composites).
-
-Virtuals implemented (pure virtuals from `result.hpp`):
-
-- `size_in_bytes()`: consults a pluggable **size oracle** (see "Size oracle"
-  below) over the Result's current index set + extents. The DEFAULT oracle is
-  the dense moment model: partition the proto-indexed modes by shared
-  proto-index set, size each k-group with `csv_moment(rank, k)`, multiply by
-  the non-proto scalar extents and `numeric_size`, reusing the cost model's
-  `inner_aware_volume` / `memsize_counter` helper so the byte formula is
-  IDENTICAL to the DP's, not a re-derivation. The backend does not hardwire
-  dense: any oracle (sparse-shape-aware, adversarial) plugs in here.
-- `prod(other, target, DeNest)`: computes the result index set (union minus
-  contracted) and its extents; honors `DeNest` for ToT -> T. Returns a new
-  `ResultSize`/`ResultSizeOfSize`.
-- `sum(other, ...)`: same index set, size-preserving.
-- `slice_mode(mode, lo, hi)`: returns a copy with that mode's extent reduced
-  to `hi - lo` (this is how a batch slice shrinks a Result).
-- `mode_batches(mode, target)`: returns tile-aligned `[lo,hi)` batch ranges
-  covering the mode's extent with each batch <= target elements (mirrors
-  `mode_batches_of_trange1`, including the `max(target,1)` floor).
-- `add_inplace`, `permute`, `symmetrize`, `antisymmetrize`, `mult_by_phase`,
-  `adjoint`: size-preserving (no-op on extents, return self-equivalent).
-- `type_id()`: a new backend id.
-
-`eval_expr.hpp`: a thin adapter (like the other backends) so the leaf
-evaluator can build these Results from an `EvalExpr`, carrying its indices
-(including proto structure) and `batch_axes_`.
-
-### Size oracle: dense default, sparsity as a plug-in
-
-The backend does NOT assume dense tensors as a baked-in property. Only
-`size_in_bytes` needs a size model; every other mechanism -- index-set
-tracking, `prod`/`sum`/`DeNest`, `slice_mode`, `mode_batches`, and the
-batching loop -- is sparsity-agnostic (batching tiles by ELEMENT count,
-slicing shrinks EXTENTS). So the size model is a single pluggable seam: a
-`SizeOracle` = invocable `(index set + extents + proto structure) -> bytes`.
-
-The default oracle is the dense moment model above. This is the RIGHT default,
-not a limitation, for the C60 target:
-
-- The C60 optimizer runs `objective_function: dense_peak_size` -- the DP is
-  itself dense -- so the dense oracle reproduces the factorizer's decisions
-  (and `batch_axes` annotations) exactly. This is what the Phase 1 probe
-  needs.
-- The C60 runtime has `result_shape_constraints: true` (SparseShape on CC
-  intermediates), so realized sizes can be below dense. The dense oracle is
-  therefore a CONSERVATIVE UPPER BOUND on the realized peak: dense-under-budget
-  implies sparse-under-budget, so it never yields a false "fix worked."
-- The leaking intermediate is fully dense anyway (`nnz_tiles=54000/54000`), so
-  the dense oracle reproduces the 186 GB leak with no sparsity to model.
-
-A sparse-shape-aware or adversarial oracle is a future plug-in at this same
-seam, with NO change to backend mechanics. Reimplementing SparseShape
-propagation is explicitly out of scope for the first cut (heavy, and
-unnecessary for a dense leak).
-
-### Component 2: `SizeRegime` config and leaf yielder
-
-Location: alongside the harness (test-side or a small `sizeonly/regime.hpp`).
-
-`SizeRegime` holds:
-
-- Scalar extents for non-proto spaces: `occ`, `aux` (Kappa), `pao`
-  (mu-tilde), and any others that appear (e.g. obs virtual if present).
-- A moment table `csv_moment(rank, k)` = mean over pairs of
-  (domain(rank))^k, indexed by rank (OSV = 1 proto index, PNO-pair = 2,
-  triple = 3) and power k in 1..4. These are INDEPENDENT numbers, not derived
-  from a single mean, so both requirements hold:
-  - rank-dependent: `<#OSV>` (rank 1, k 1) != `<#PNO>` (rank 2, k 1);
-  - moment-dependent: `<#PNO^2>` (rank 2, k 2) != `<#PNO>^2`.
-  This is the `average_csv_extent_pow(rank, k)` shape MPQC feeds the
-  optimizer. k up to 4 covers the 4-occ PHL terms (CC with a 2-body
-  Hamiltonian tops out at 4 co-proto PNO modes).
-
-The same `SizeRegime` is used to build:
-- the cost-model callbacks (index extent + `inner_pow`) for `single_term_opt`;
-- the leaf yielder `(EvalNode) -> ResultPtr` that materializes each leaf as a
-  `ResultSize`/`ResultSizeOfSize`.
-
-so the DP and the runtime see one identical size model.
-
-### Component 3: Catch2 harness/driver
-
-Location: `SeQuant/tests/unit/test_eval_sizeonly.cpp`, with a committed
-readable residual fixture under `SeQuant/tests/unit/data/`.
-
-Fixture: the CSV-CCk residual in the human-readable `deserialize` format
-(same text form as mpqc4 `csv_eqn_Rs.serialized`), committed as a test data
-file. The harness also accepts any inline deserialized expression, so a
-single offending term pasted from a trace works.
-
-Driver flow, given a `SizeRegime` + batch config (`peak_threshold`,
-`aux_target_size`, `pao_target_size`):
-
-1. deserialize the residual (or a single term);
-2. `single_term_opt` with the peak objective + threshold and the regime's
-   cost callbacks -> factorized tree with per-node `batch_axes`;
-3. `binarize` -> `EvalNode`;
-4. `make_batched_custom_evaluator` + `evaluate` against the size backend,
-   tracing on;
-5. report: DP-modeled peak vs realized hwmark; per-op result sizes; and flag
-   any op whose realized result exceeds `peak_threshold` (a leak);
-6. assert an invariant: realized peak <= tolerance * peak_threshold, where
-   tolerance is a small factor (the plan pins it, e.g. 2x, to absorb batch
-   co-residency and tile granularity without admitting a real leak). On the
-   C60 regime this assertion FAILS today (reproducing the 186 GB leak) and
-   PASSES once the fix lands -- so the same test is both the reproducer and
-   the regression lock.
-
-## Data flow
-
-    SizeRegime --+--> cost callbacks (extent, inner_pow) --> single_term_opt --> batch_axes
-                 |                                                                    |
-                 +--> leaf yielder --> ResultSize/ResultSizeOfSize                    v
-                                                     \--> make_batched_custom_evaluator + evaluate
-                                                                    |
-                                              trace (Eval/BatchGroup/hw)  +  realized peak (hwmark)
-                                                                    |
-                                              report modeled vs realized + leak flags + assert
-
-## Phasing (drives the implementation plan)
-
-Task 1 is the go/no-go that localizes the C60 bug to factorizer vs runtime;
-it is also the smallest useful slice and de-risks the sizing model.
-
-- **Phase 1 (probe / audit): DP-annotation dump on the offending term.**
-  Deserialize just the free-mu-tilde PHL 4-occ term (from the C60 trace),
-  build the C60 `SizeRegime` (mu-tilde ~1800, Kappa ~4300, PNO moments, occ),
-  run `single_term_opt` at 40 GB threshold, and print the per-node
-  `batch_axes`. This requires only the cost-model callbacks + a minimal
-  size_in_bytes -- not the full runtime backend. It answers directly:
-  - if the offending intermediate's node has NO mu-tilde annotation ->
-    layer-1 (cost-model/threshold) bug: the DP never asked to slice mu-tilde;
-  - if it DOES carry a mu-tilde annotation -> layer-2 (runtime) bug: the
-    batched evaluator dropped it.
-  Validation gate: the moment sizing must reproduce the real trace numbers
-  for this term (the ~1.87 GB aux-batch giant `g(mu-tilde,mu-tilde,Kappa)`
-  and the ~186 GB free-mu-tilde intermediate) within a small factor, else the
-  regime is mis-modeled and later verdicts are untrustworthy.
-
-- **Phase 2: full size-only Result backend** (Component 1) with moment-aware
-  `size_in_bytes`, `slice_mode`, `mode_batches`, `prod`/`sum`/`DeNest`.
-
-- **Phase 3: full harness** (Component 3): deserialize the whole residual,
-  run the batched evaluate against the backend with tracing, report modeled
-  vs realized peak, flag leaks, assert the peak invariant. This is the
-  end-to-end leak reproducer.
-
-- **Phase 4: lock the C60 regime as a regression test** -- failing now,
-  passing after the batching fix (whichever layer Phase 1 implicates).
-
-## Validation strategy
-
-Trust the harness only after it reproduces known real numbers. Anchor points
-from the C60 log (approximate, per the 8-rank run):
-
-- `g(mu-tilde, mu-tilde, Kappa)` full ~1.87 GB per aux-batch (sliced to 60
-  aux batches);
-- `I(i_3, i_2, mu-tilde_1241, Kappa_2; a_3)` ~186 GB (free mu-tilde + free
-  aux, unsliced).
-
-The size backend, fed the C60 regime, must land within a small factor of
-these before its factorization/leak verdicts are believed. (Exact match is
-not expected: the regime uses representative moments, not per-pair sizes.)
-
-## File layout
-
-- `SeQuant/core/eval/backends/sizeonly/result.hpp` -- `ResultSize`,
-  `ResultSizeOfSize`.
-- `SeQuant/core/eval/backends/sizeonly/eval_expr.hpp` -- leaf adapter.
-- `SeQuant/core/eval/backends/sizeonly/regime.hpp` -- `SizeRegime` + callback
-  builders + leaf yielder (or test-side if it stays test-only).
-- `SeQuant/tests/unit/test_eval_sizeonly.cpp` -- probe + harness cases.
-- `SeQuant/tests/unit/data/csv_ccsd_residual.txt` -- committed residual
-  fixture (readable deserialize form).
-
-## Risks
-
-- **ToT / proto-index nesting fidelity (main risk).** The size model for
-  nested (CSV) Results must match how the real backend nests -- the
-  outer-occ vs inner-PNO split and the moment-aware sizing -- so
-  `prod`+`DeNest`, `slice_mode`, and `mode_batches` behave consistently with
-  reality. Mitigated by reusing the cost model's `inner_aware_volume` and by
-  the Phase 1 validation gate against real trace numbers.
-- **DP/runtime sizing drift.** If the runtime backend and the cost model ever
-  computed sizes differently, modeled-vs-realized gaps would be artifacts.
-  Mitigated by sharing one `SizeRegime` and one `inner_aware_volume` helper.
-- **Fixture staleness.** The committed residual could drift from what MPQC
-  generates. Mitigated by keeping it in the readable deserialize form and
-  refreshing it from an MPQC dump when the CC/CSV equations change.

From 0c5c0aa3dd0d87d6c2e1994d5746084fbbb334d6 Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Sat, 4 Jul 2026 13:15:25 -0400
Subject: [PATCH 21/78] doc: rename eval backend brand CostToken -> DryRun
 (clearer for users)

---
 ...04-costmodel-replay-eval-backend-design.md | 77 +++++++------------
 1 file changed, 26 insertions(+), 51 deletions(-)

diff --git a/doc/dev/specs/2026-07-04-costmodel-replay-eval-backend-design.md b/doc/dev/specs/2026-07-04-costmodel-replay-eval-backend-design.md
index 059ec13176..b850a699e3 100644
--- a/doc/dev/specs/2026-07-04-costmodel-replay-eval-backend-design.md
+++ b/doc/dev/specs/2026-07-04-costmodel-replay-eval-backend-design.md
@@ -1,4 +1,4 @@
-# Cost-model replay eval backend and PNO-CCSD cost harness
+# DryRun eval backend and PNO-CCSD cost harness
 
 _Design spec. Repo: SeQuant. Related: the aux+PAO nested batching feature on
 `feature/eval-predicted-peak-trace` (SeQuant) / mpqc4 CSV-CCk._
@@ -6,35 +6,13 @@ _Design spec. Repo: SeQuant. Related: the aux+PAO nested batching feature on
 ## Goal
 
 A cost-model replay eval backend plus a Catch2 harness that factorizes and
-replays the PNO-CCSD (CSV-CCk) residual schedule over `CacheManager` against
-thin structural tokens (no numeric data, no TiledArray, no MPQC), reporting
+replays IR over `CacheManager` (dry-run only, no numeric data or compute), reporting
 for each evaluation exactly what the optimizer's OWN cost model reports:
 projected memory size, FLOPs, and projected execution cost. This lets us
-reproduce arbitrary size regimes -- including the C60 out-of-memory -- as a
-unit test in seconds instead of a multi-hour cluster build-run-debug loop, and
-see the optimizer-projected cost (the `dense_peak_size` frontier) side by side
-with the cost actually realized when the schedule is replayed.
-
-## Motivation
-
-The C60 PNO-CCSD run (job 614336) was OUT_OF_MEMORY: aggregate MaxRSS 770 GB
-vs a 743 GB node limit. It died building the intermediate
-
-    I(i_3, i_2, mu-tilde_1241, Kappa_2; a_3) = C(...;mu-tilde_1242) * g(mu-tilde_1241, mu-tilde_1242, Kappa_2)
-
-which the trace projected at ~186 GB. This intermediate carries BOTH a free
-PAO index (mu-tilde_1241) and a free aux index (Kappa_2). The batched
-evaluator sliced only aux ("over 60 aux batches") and never sliced mu-tilde,
-so the intermediate materialized full. The optimizer ran
-`objective_function: dense_peak_size` at `peak_threshold = 40 GB`, yet the
-schedule did single-mode aux batching only.
-
-`dense_peak_size` optimizes on a frontier of two quantities: peak memory and a
-projected execution cost (roofline of FLOPs against `machine_balance` /
-`fast_mem_elems`). To understand why the frontier search chose an aux-only
-schedule -- and whether the runtime then diverged from it -- we want to report
-those SAME quantities, per evaluation, on a local replay. Diagnosing this on
-the cluster is intractable (hours per iteration).
+(1) rapid exploration
+of the dependence of projected resource (memory, time) costs on the cost model
+for arbitrary problem sizes, as well as (2) estimate resource use
+by production computations before starting actual evaluation.
 
 ## Non-goals (YAGNI)
 
@@ -82,7 +60,7 @@ Add a cost-model replay backend as a fourth backend alongside
 
 1. Peak memory reuses CacheManager verbatim. `CacheManager::note_working_set`
    maintains `working_set_hwmark_` (printed as `hw=`, documented as the running
-   peak), driven by `Result::size_in_bytes()`. The cost-token Result's
+   peak), driven by `Result::size_in_bytes()`. The dry-run Result's
    `size_in_bytes()` DELEGATES to the cost model's `memsize`. This is a
    modeling backend: it holds no data, so its only "size" IS the modeled one
    -- not an actual-size abuse but the sole size the token has. So the hwmark
@@ -96,7 +74,7 @@ Add a cost-model replay backend as a fourth backend alongside
 ### Component 1: the cost model object
 
 Location: reuse `SeQuant/core/optimize/` cost functors; expose a small bundle
-(e.g. `SeQuant/core/eval/backends/costtoken/cost_model_object.hpp`).
+(e.g. `SeQuant/core/eval/backends/dryrun/cost_model_object.hpp`).
 
 A queryable object bundling the optimizer's OWN functors, built from a
 `SizeRegime` (Component 3):
@@ -106,23 +84,21 @@ A queryable object bundling the optimizer's OWN functors, built from a
 - `exec_cost(op) -> double` (from `roofline_op_cost(..., machine_balance,
   fast_mem_elems, block_tiles, block_prefactor)`).
 
-Default construction mirrors `DensePeakSize` (dense, moment-aware) so the
-replay reports exactly what the C60 `dense_peak_size` optimization used. The
-object is the single seam for the size model: a SparseShape-aware or
+The  object is the single seam for the size model: a SparseShape-aware or
 adversarial cost model plugs in here with NO change to the token or the replay.
 Nothing is re-derived -- `memsize_counter`/`flops_counter`/`roofline_op_cost`
 are the optimizer's own code.
 
-### Component 2: cost-token Result backend
+### Component 2: dry-run Result backend
 
-Location: `SeQuant/core/eval/backends/costtoken/{result.hpp, eval_expr.hpp}`
+Location: `SeQuant/core/eval/backends/dryrun/{result.hpp, eval_expr.hpp}`
 (mirroring `backends/tiledarray`).
 
 Two Result types implementing the abstract `Result` interface:
 
-- `ResultCostToken` (flat / Tensor-of-scalars): carries an ordered `Index`
+- `ResultDryRun` (flat / Tensor-of-scalars): carries an ordered `Index`
   list (with proto info) and per-mode extents. No buffer.
-- `ResultCostTokenNested` (Tensor-of-Tensor, for CSV amplitudes/coefficients):
+- `ResultDryRunNested` (Tensor-of-Tensor, for CSV amplitudes/coefficients):
   carries the outer (occ proto) and inner (PNO/OSV composite) index lists.
 
 Virtuals:
@@ -149,9 +125,9 @@ per op from the cost model object (Architecture hook 2).
 
 ### Component 3: `SizeRegime` + harness
 
-Location: `SeQuant/tests/unit/test_eval_costtoken.cpp` plus a committed
+Location: `SeQuant/tests/unit/test_eval_dryrun.cpp` plus a committed
 readable residual fixture under `SeQuant/tests/unit/data/`. `SizeRegime` may
-live test-side or in `backends/costtoken/regime.hpp`.
+live test-side or in `backends/dryrun/regime.hpp`.
 
 `SizeRegime` supplies the cost model's parameters:
 
@@ -163,9 +139,8 @@ live test-side or in `backends/costtoken/regime.hpp`.
   moment-dependent (`<#PNO^2>` != `<#PNO>^2`). This is the
   `average_csv_extent_pow(rank, k)` shape MPQC feeds the optimizer; k up to 4
   covers the 4-occ PHL terms (CC with a 2-body Hamiltonian).
-- roofline parameters: `machine_balance`, `fast_mem_elems`, block params
-  (matching the C60 `optimize` block: `machine_balance 200`, `fast_mem_elems
-  1000000`), so the projected exec cost matches the run.
+- roofline parameters: `machine_balance`, `fast_mem_elems`, block params, 
+   so the projected exec cost matches the run.
 
 One `SizeRegime` builds the single cost model object used by BOTH
 `single_term_opt` (the DP frontier) and the replay (token `size_in_bytes` +
@@ -185,7 +160,7 @@ Driver flow, given `SizeRegime` + batch config (`peak_threshold`,
    DP-projected frontier point (peak, exec cost);
 3. `binarize` -> `EvalNode`;
 4. replay: `make_batched_custom_evaluator` + `evaluate` over `CacheManager`
-   with the cost-token backend, tracing on;
+   with the dry-run backend, tracing on;
 5. report, per op: cost-model `{memsize, flops, exec_cost}`; and overall:
    realized peak memory (hwmark), total FLOPs, total exec cost; alongside the
    DP-projected frontier point from step 2;
@@ -226,7 +201,7 @@ and de-risks the cost model object.
   and the ~186 GB free-mu-tilde intermediate) within a small factor, and the
   FLOPs/exec cost should be sane, else the regime is mis-modeled.
 
-- **Phase 2: cost model object + cost-token backend** (Components 1-2), with
+- **Phase 2: cost model object + dry-run backend** (Components 1-2), with
   `size_in_bytes` delegating to `memsize`, plus `slice_mode`, `mode_batches`,
   `prod`/`sum`/`DeNest`.
 
@@ -255,14 +230,14 @@ exec cost on one known contraction too.
 
 ## File layout
 
-- `SeQuant/core/eval/backends/costtoken/cost_model_object.hpp` -- the queryable
+- `SeQuant/core/eval/backends/dryrun/cost_model_object.hpp` -- the queryable
   bundle over the optimizer's functors.
-- `SeQuant/core/eval/backends/costtoken/result.hpp` -- `ResultCostToken`,
-  `ResultCostTokenNested`.
-- `SeQuant/core/eval/backends/costtoken/eval_expr.hpp` -- leaf adapter.
-- `SeQuant/core/eval/backends/costtoken/regime.hpp` -- `SizeRegime` + builders
+- `SeQuant/core/eval/backends/dryrun/result.hpp` -- `ResultDryRun`,
+  `ResultDryRunNested`.
+- `SeQuant/core/eval/backends/dryrun/eval_expr.hpp` -- leaf adapter.
+- `SeQuant/core/eval/backends/dryrun/regime.hpp` -- `SizeRegime` + builders
   (or test-side if it stays test-only).
-- `SeQuant/tests/unit/test_eval_costtoken.cpp` -- probe + harness cases.
+- `SeQuant/tests/unit/test_eval_dryrun.cpp` -- probe + harness cases.
 - `SeQuant/tests/unit/data/csv_ccsd_residual.txt` -- committed residual
   fixture (readable deserialize form).
 
@@ -276,7 +251,7 @@ exec cost on one known contraction too.
   trace numbers.
 - **`size_in_bytes` delegation.** Semantically `size_in_bytes` is the actual
   size on real backends; here it returns the modeled `memsize`. Contained: only
-  the cost-token backend does this, documented as a modeling backend with no
+  the dry-run backend does this, documented as a modeling backend with no
   data. Real backends are untouched.
 - **DP/replay cost drift.** If the DP and the replay ever computed cost
   differently, gaps would be artifacts. Mitigated by building both from one

From 02eae1a7ecbf9b5702334acc5de7a5df4ddd1fc5 Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Sat, 4 Jul 2026 14:22:41 -0400
Subject: [PATCH 22/78] dryrun: size regime + DP-inspection mechanics on
 pre-transform C60 residual

Adds sequant::eval::dryrun::SizeRegime (per-space extents + CSV/OSV power-mean
moment tables) and a dedicated unit-test OBJECT-lib group exercising it against
the real C60 CSV-CCSD residual fixture (mpqc's csv_eqn_Rs.serialized). Confirms
the deserialize path and the DensePeakSizeBatched + term_batch_axes + binarize
round-trip mechanics end-to-end (per-summand optimize(), Product::Flatten::Yes
re-flattening of the deserializer's literal nesting), plus a self-consistency
memsize check.

The fixture is pre-transform (no PAO/DF-aux indices), so this is
infrastructure and mechanics only -- the actual PAO/K batch-axis go/no-go
verdict needs a post-transform fixture and is deferred to a follow-up. See
.superpowers/sdd/task-1-report.md for the full history.
---
 .../core/eval/backends/dryrun/size_regime.hpp |  55 ++
 tests/unit/CMakeLists.txt                     |  13 +
 tests/unit/data/csv_ccsd_residual.txt         |   6 +
 tests/unit/test_eval_dryrun.cpp               | 478 ++++++++++++++++++
 4 files changed, 552 insertions(+)
 create mode 100644 SeQuant/core/eval/backends/dryrun/size_regime.hpp
 create mode 100644 tests/unit/data/csv_ccsd_residual.txt
 create mode 100644 tests/unit/test_eval_dryrun.cpp

diff --git a/SeQuant/core/eval/backends/dryrun/size_regime.hpp b/SeQuant/core/eval/backends/dryrun/size_regime.hpp
new file mode 100644
index 0000000000..ea26172bb9
--- /dev/null
+++ b/SeQuant/core/eval/backends/dryrun/size_regime.hpp
@@ -0,0 +1,55 @@
+#ifndef SEQUANT_CORE_EVAL_BACKENDS_DRYRUN_SIZE_REGIME_HPP
+#define SEQUANT_CORE_EVAL_BACKENDS_DRYRUN_SIZE_REGIME_HPP
+
+#include <SeQuant/core/index.hpp>
+
+#include <array>
+#include <cmath>
+#include <cstddef>
+#include <functional>
+#include <map>
+#include <string>
+
+namespace sequant::eval::dryrun {
+
+/// Per-space extents and per-rank CSV moment tables that define one size
+/// regime for a dry-run replay. Extents are element counts; CSV moments are
+/// power means over occupied pairs (PNO) or singles (OSV).
+struct SizeRegime {
+  std::map<std::wstring, std::size_t> space_extent;
+  std::array<double, 5> csv_pno_moment{1.0, 1.0, 1.0, 1.0, 1.0};
+  std::array<double, 5> csv_osv_moment{1.0, 1.0, 1.0, 1.0, 1.0};
+
+  /// \return the flat extent of \p ix's space; throws \c std::out_of_range
+  ///         if the space is not present in \c space_extent (fail loud rather
+  ///         than silently defaulting to 1).
+  [[nodiscard]] std::size_t extent(Index const& ix) const {
+    return space_extent.at(std::wstring{ix.space().base_key()});
+  }
+
+  /// \return the k-th power-mean moment for a proto-indexed CSV/PNO composite
+  ///         index (\p k clamped to 0..4), or \c pow(extent, k) for a plain
+  ///         (non-composite) index. Rank is determined by the number of proto
+  ///         indices: 2 => PNO (occupied pair), 1 => OSV (occupied single).
+  [[nodiscard]] double inner_pow(Index const& composite, std::size_t k) const {
+    if (k > 4) k = 4;
+    auto const& protos = composite.proto_indices();
+    if (protos.empty())
+      return std::pow(static_cast<double>(extent(composite)),
+                      static_cast<double>(k));
+    return (protos.size() >= 2) ? csv_pno_moment[k] : csv_osv_moment[k];
+  }
+
+  [[nodiscard]] std::function<std::size_t(Index const&)> idx_to_extent() const {
+    return [this](Index const& ix) { return extent(ix); };
+  }
+
+  [[nodiscard]] std::function<double(Index const&, std::size_t)> inner_pow_fn()
+      const {
+    return [this](Index const& ix, std::size_t k) { return inner_pow(ix, k); };
+  }
+};
+
+}  // namespace sequant::eval::dryrun
+
+#endif  // SEQUANT_CORE_EVAL_BACKENDS_DRYRUN_SIZE_REGIME_HPP
diff --git a/tests/unit/CMakeLists.txt b/tests/unit/CMakeLists.txt
index 3411d2ee0e..2a98a0b70d 100644
--- a/tests/unit/CMakeLists.txt
+++ b/tests/unit/CMakeLists.txt
@@ -155,6 +155,18 @@ if (SEQUANT_HAS_TAPP)
         PROPERTIES SKIP_UNITY_BUILD_INCLUSION ON)
 endif()
 
+##########################
+# OBJECT library: DryRun backend tests
+##########################
+set(eval_dryrun_test_sources "test_eval_dryrun.cpp")
+add_library(unit_tests-sequant-eval-dryrun-obj OBJECT ${eval_dryrun_test_sources})
+set_target_properties(unit_tests-sequant-eval-dryrun-obj PROPERTIES CXX_SCAN_FOR_MODULES OFF)
+target_link_libraries(unit_tests-sequant-eval-dryrun-obj
+    PUBLIC SeQuant::eval SeQuant::optimize SeQuant::bliss SeQuant::mbpt
+    PRIVATE Catch2::Catch2 dtl::dtl)
+target_compile_definitions(unit_tests-sequant-eval-dryrun-obj PRIVATE
+    SEQUANT_UNIT_TESTS_SOURCE_DIR="${CMAKE_CURRENT_SOURCE_DIR}")
+
 ##########################
 # Single executable combining all OBJECT libraries
 # NB linking OBJECT libraries (since CMake 3.21) both includes their object
@@ -171,6 +183,7 @@ target_link_libraries(unit_tests-sequant PRIVATE
     unit_tests-sequant-optimize-obj
     unit_tests-sequant-export-obj
     unit_tests-sequant-mbpt-obj
+    unit_tests-sequant-eval-dryrun-obj
     Catch2::Catch2
     dtl::dtl)
 if (SEQUANT_HAS_TILEDARRAY)
diff --git a/tests/unit/data/csv_ccsd_residual.txt b/tests/unit/data/csv_ccsd_residual.txt
new file mode 100644
index 0000000000..ab9551cbfb
--- /dev/null
+++ b/tests/unit/data/csv_ccsd_residual.txt
@@ -0,0 +1,6 @@
+==== Rs[0] ====
+2 ((g{i_1,i_2;a_21514,a_21515}:N-C-S * (C{a_21514;a_1<i_1>}:N-C-S * t{a_1<i_1>;i_1}:N-N-S)) * C{a_21515;a_2<i_2>}:N-C-S) * t{a_2<i_2>;i_2}:N-N-S - 1 ((g{i_1,i_2;a_21516,a_21517}:N-C-S * (C{a_21516;a_1<i_2>}:N-C-S * t{a_1<i_2>;i_2}:N-N-S)) * C{a_21517;a_2<i_1>}:N-C-S) * t{a_2<i_1>;i_1}:N-N-S + 2 (f{i_1;a_21518}:N-C-S * C{a_21518;a_1<i_1>}:N-C-S) * t{a_1<i_1>;i_1}:N-N-S - 1 ((g{i_1,i_2;a_21519,a_21520}:N-C-S * C{a_21519;a_1<i_1,i_2>}:N-C-S) * C{a_21520;a_2<i_1,i_2>}:N-C-S) * t{a_1<i_1,i_2>,a_2<i_1,i_2>;i_2,i_1}:N-N-S + 2 ((g{i_1,i_2;a_21521,a_21522}:N-C-S * C{a_21521;a_1<i_1,i_2>}:N-C-S) * C{a_21522;a_2<i_1,i_2>}:N-C-S) * t{a_1<i_1,i_2>,a_2<i_1,i_2>;i_1,i_2}:N-N-S
+==== Rs[1] ====
+-1 (f{i_2;i_1}:N-C-S * (C{a_1;a_2<i_2>}:N-C-S * t{a_2<i_2>;i_2}:N-N-S)) * C{a_1<i_1>;a_1}:N-C-S + 2 (g{i_2,a_21523;a_21524,i_1}:N-C-S * (C{a_21524;a_2<i_2>}:N-C-S * t{a_2<i_2>;i_2}:N-N-S)) * C{a_1<i_1>;a_21523}:N-C-S - 1 ((g{i_2,a_21525;a_21526,a_21527}:N-C-S * (C{a_21527;a_3<i_2>}:N-C-S * t{a_3<i_2>;i_2}:N-N-S)) * (C{a_21526;a_2<i_1>}:N-C-S * t{a_2<i_1>;i_1}:N-N-S)) * C{a_1<i_1>;a_21525}:N-C-S + 2 ((g{i_2,a_21528;a_21529,a_21530}:N-C-S * (C{a_21529;a_2<i_2>}:N-C-S * t{a_2<i_2>;i_2}:N-N-S)) * (C{a_21530;a_3<i_1>}:N-C-S * t{a_3<i_1>;i_1}:N-N-S)) * C{a_1<i_1>;a_21528}:N-C-S - 2 ((((g{i_2,i_3;a_21532,a_21533}:N-C-S * (C{a_21532;a_2<i_1>}:N-C-S * t{a_2<i_1>;i_1}:N-N-S)) * C{a_21533;a_3<i_2,i_3>}:N-C-S) * t{a_3<i_2,i_3>,a_4<i_2,i_3>;i_3,i_2}:N-N-S) * C{a_1;a_4<i_2,i_3>}:N-C-S) * C{a_1<i_1>;a_1}:N-C-S + ((((g{i_2,i_3;a_21556,a_21557}:N-C-S * (C{a_21556;a_2<i_1>}:N-C-S * t{a_2<i_1>;i_1}:N-N-S)) * C{a_21557;a_3<i_2,i_3>}:N-C-S) * t{a_3<i_2,i_3>,a_4<i_2,i_3>;i_2,i_3}:N-N-S) * C{a_1;a_4<i_2,i_3>}:N-C-S) * C{a_1<i_1>;a_1}:N-C-S + ((g{i_2,i_3;a_21534,a_21535}:N-C-S * ((C{a_21534;a_2<i_1,i_2>}:N-C-S * t{a_2<i_1,i_2>,a_3<i_1,i_2>;i_1,i_2}:N-N-S) * C{a_21535;a_3<i_1,i_2>}:N-C-S)) * (C{a_1;a_4<i_3>}:N-C-S * t{a_4<i_3>;i_3}:N-N-S)) * C{a_1<i_1>;a_1}:N-C-S + 2 (g{i_2,a_21542;a_21543,a_21544}:N-C-S * ((C{a_21543;a_2<i_1,i_2>}:N-C-S * t{a_2<i_1,i_2>,a_3<i_1,i_2>;i_2,i_1}:N-N-S) * C{a_21544;a_3<i_1,i_2>}:N-C-S)) * C{a_1<i_1>;a_21542}:N-C-S - 1 (g{i_2,a_21560;a_21561,a_21562}:N-C-S * ((C{a_21561;a_2<i_1,i_2>}:N-C-S * t{a_2<i_1,i_2>,a_3<i_1,i_2>;i_1,i_2}:N-N-S) * C{a_21562;a_3<i_1,i_2>}:N-C-S)) * C{a_1<i_1>;a_21560}:N-C-S - 2 ((g{i_2,i_3;a_21563,a_21564}:N-C-S * ((C{a_21563;a_2<i_1,i_3>}:N-C-S * t{a_2<i_1,i_3>,a_3<i_1,i_3>;i_1,i_3}:N-N-S) * C{a_21564;a_3<i_1,i_3>}:N-C-S)) * (C{a_1;a_4<i_2>}:N-C-S * t{a_4<i_2>;i_2}:N-N-S)) * C{a_1<i_1>;a_1}:N-C-S - 1 (g{i_2,a_21538;i_1,a_21539}:N-C-S * (C{a_21539;a_2<i_2>}:N-C-S * t{a_2<i_2>;i_2}:N-N-S)) * C{a_1<i_1>;a_21538}:N-C-S + ((g{i_2,i_3;i_1,a_21540}:N-C-S * (C{a_21540;a_2<i_2>}:N-C-S * t{a_2<i_2>;i_2}:N-N-S)) * (C{a_1;a_3<i_3>}:N-C-S * t{a_3<i_3>;i_3}:N-N-S)) * C{a_1<i_1>;a_1}:N-C-S + (f{a_21545;a_21546}:N-C-S * (C{a_21546;a_2<i_1>}:N-C-S * t{a_2<i_1>;i_1}:N-N-S)) * C{a_1<i_1>;a_21545}:N-C-S + (((g{i_2,i_3;a_21547,a_21548}:N-C-S * (C{a_21548;a_3<i_2>}:N-C-S * t{a_3<i_2>;i_2}:N-N-S)) * (C{a_21547;a_2<i_1>}:N-C-S * t{a_2<i_1>;i_1}:N-N-S)) * (C{a_1;a_4<i_3>}:N-C-S * t{a_4<i_3>;i_3}:N-N-S)) * C{a_1<i_1>;a_1}:N-C-S - 2 ((((g{i_2,i_3;a_21554,a_21555}:N-C-S * (C{a_21554;a_2<i_3>}:N-C-S * t{a_2<i_3>;i_3}:N-N-S)) * C{a_21555;a_3<i_1,i_2>}:N-C-S) * t{a_3<i_1,i_2>,a_4<i_1,i_2>;i_2,i_1}:N-N-S) * C{a_1;a_4<i_1,i_2>}:N-C-S) * C{a_1<i_1>;a_1}:N-C-S + ((((g{i_2,i_3;a_21567,a_21568}:N-C-S * (C{a_21567;a_2<i_3>}:N-C-S * t{a_2<i_3>;i_3}:N-N-S)) * C{a_21568;a_3<i_1,i_2>}:N-C-S) * t{a_3<i_1,i_2>,a_4<i_1,i_2>;i_1,i_2}:N-N-S) * C{a_1;a_4<i_1,i_2>}:N-C-S) * C{a_1<i_1>;a_1}:N-C-S - 2 ((g{i_2,i_3;i_1,a_21549}:N-C-S * (C{a_21549;a_2<i_3>}:N-C-S * t{a_2<i_3>;i_3}:N-N-S)) * (C{a_1;a_3<i_2>}:N-C-S * t{a_3<i_2>;i_2}:N-N-S)) * C{a_1<i_1>;a_1}:N-C-S + 4 ((((g{i_2,i_3;a_21550,a_21551}:N-C-S * (C{a_21550;a_2<i_2>}:N-C-S * t{a_2<i_2>;i_2}:N-N-S)) * C{a_21551;a_3<i_1,i_3>}:N-C-S) * t{a_3<i_1,i_3>,a_4<i_1,i_3>;i_3,i_1}:N-N-S) * C{a_1;a_4<i_1,i_3>}:N-C-S) * C{a_1<i_1>;a_1}:N-C-S - 2 ((((g{i_2,i_3;a_21565,a_21566}:N-C-S * (C{a_21565;a_2<i_2>}:N-C-S * t{a_2<i_2>;i_2}:N-N-S)) * C{a_21566;a_3<i_1,i_3>}:N-C-S) * t{a_3<i_1,i_3>,a_4<i_1,i_3>;i_1,i_3}:N-N-S) * C{a_1;a_4<i_1,i_3>}:N-C-S) * C{a_1<i_1>;a_1}:N-C-S - 2 (((g{i_2,i_3;a_21558,a_21559}:N-C-S * (C{a_21558;a_2<i_2>}:N-C-S * t{a_2<i_2>;i_2}:N-N-S)) * (C{a_21559;a_3<i_1>}:N-C-S * t{a_3<i_1>;i_1}:N-N-S)) * (C{a_1;a_4<i_3>}:N-C-S * t{a_4<i_3>;i_3}:N-N-S)) * C{a_1<i_1>;a_1}:N-C-S - 1 ((f{i_2;a_21552}:N-C-S * (C{a_21552;a_2<i_1>}:N-C-S * t{a_2<i_1>;i_1}:N-N-S)) * (C{a_1;a_3<i_2>}:N-C-S * t{a_3<i_2>;i_2}:N-N-S)) * C{a_1<i_1>;a_1}:N-C-S - 2 (((g{i_2,i_3;i_1,a_21531}:N-C-S * C{a_21531;a_2<i_2,i_3>}:N-C-S) * t{a_2<i_2,i_3>,a_3<i_2,i_3>;i_3,i_2}:N-N-S) * C{a_1;a_3<i_2,i_3>}:N-C-S) * C{a_1<i_1>;a_1}:N-C-S + (((g{i_2,i_3;i_1,a_21541}:N-C-S * C{a_21541;a_2<i_2,i_3>}:N-C-S) * t{a_2<i_2,i_3>,a_3<i_2,i_3>;i_2,i_3}:N-N-S) * C{a_1;a_3<i_2,i_3>}:N-C-S) * C{a_1<i_1>;a_1}:N-C-S - 1 (((f{i_2;a_21536}:N-C-S * C{a_21536;a_2<i_1,i_2>}:N-C-S) * t{a_2<i_1,i_2>,a_3<i_1,i_2>;i_1,i_2}:N-N-S) * C{a_1;a_3<i_1,i_2>}:N-C-S) * C{a_1<i_1>;a_1}:N-C-S + 2 (((f{i_2;a_21537}:N-C-S * C{a_21537;a_2<i_1,i_2>}:N-C-S) * t{a_2<i_1,i_2>,a_3<i_1,i_2>;i_2,i_1}:N-N-S) * C{a_1;a_3<i_1,i_2>}:N-C-S) * C{a_1<i_1>;a_1}:N-C-S + f{a_21553;i_1}:N-C-S * C{a_1<i_1>;a_21553}:N-C-S
+==== Rs[2] ====
+4 (((g{i_3,a_21569;a_21570,a_21571}:N-C-S * (C{a_21570;a_3<i_3>}:N-C-S * t{a_3<i_3>;i_3}:N-N-S)) * C{a_2<i_1,i_2>;a_21569}:N-C-S) * C{a_21571;a_4<i_1,i_2>}:N-C-S) * t{a_1<i_1,i_2>,a_4<i_1,i_2>;i_1,i_2}:N-N-S - 2 (((g{i_3,a_21572;a_21573,a_21574}:N-C-S * (C{a_21573;a_3<i_1>}:N-C-S * t{a_3<i_1>;i_1}:N-N-S)) * ((C{a_21574;a_4<i_2,i_3>}:N-C-S * t{a_4<i_2,i_3>,a_5<i_2,i_3>;i_2,i_3}:N-N-S) * C{a_1;a_5<i_2,i_3>}:N-C-S)) * C{a_2<i_1,i_2>;a_21572}:N-C-S) * C{a_1<i_1,i_2>;a_1}:N-C-S + 2 ((g{i_3,i_4;i_2,a_21575}:N-C-S * ((C{a_21575;a_3<i_1,i_3>}:N-C-S * t{a_3<i_1,i_3>,a_4<i_1,i_3>;i_1,i_3}:N-N-S) * C{a_2;a_4<i_1,i_3>}:N-C-S)) * C{a_2<i_1,i_2>;a_2}:N-C-S) * (C{a_1<i_1,i_2>;a_1}:N-C-S * (C{a_1;a_5<i_4>}:N-C-S * t{a_5<i_4>;i_4}:N-N-S)) + 2 ((g{i_3,i_4;i_2,a_21576}:N-C-S * ((C{a_21576;a_3<i_1,i_3>}:N-C-S * t{a_3<i_1,i_3>,a_4<i_1,i_3>;i_3,i_1}:N-N-S) * C{a_1;a_4<i_1,i_3>}:N-C-S)) * C{a_1<i_1,i_2>;a_1}:N-C-S) * (C{a_2<i_1,i_2>;a_2}:N-C-S * (C{a_2;a_5<i_4>}:N-C-S * t{a_5<i_4>;i_4}:N-N-S)) + 2 (((g{i_3,i_4;a_21579,a_21580}:N-C-S * (C{a_21579;a_3<i_2>}:N-C-S * t{a_3<i_2>;i_2}:N-N-S)) * ((C{a_21580;a_4<i_1,i_4>}:N-C-S * t{a_4<i_1,i_4>,a_5<i_1,i_4>;i_1,i_4}:N-N-S) * C{a_1;a_5<i_1,i_4>}:N-C-S)) * C{a_1<i_1,i_2>;a_1}:N-C-S) * (C{a_2<i_1,i_2>;a_2}:N-C-S * (C{a_2;a_6<i_3>}:N-C-S * t{a_6<i_3>;i_3}:N-N-S)) - 4 (((g{i_3,i_4;a_21583,a_21584}:N-C-S * (C{a_21583;a_3<i_2>}:N-C-S * t{a_3<i_2>;i_2}:N-N-S)) * ((C{a_21584;a_4<i_1,i_4>}:N-C-S * t{a_4<i_1,i_4>,a_5<i_1,i_4>;i_4,i_1}:N-N-S) * C{a_1;a_5<i_1,i_4>}:N-C-S)) * C{a_1<i_1,i_2>;a_1}:N-C-S) * (C{a_2<i_1,i_2>;a_2}:N-C-S * (C{a_2;a_6<i_3>}:N-C-S * t{a_6<i_3>;i_3}:N-N-S)) - 2 ((g{i_3,a_21607;a_21608,i_2}:N-C-S * (C{a_21608;a_3<i_1>}:N-C-S * t{a_3<i_1>;i_1}:N-N-S)) * C{a_2<i_1,i_2>;a_21607}:N-C-S) * (C{a_1<i_1,i_2>;a_1}:N-C-S * (C{a_1;a_4<i_3>}:N-C-S * t{a_4<i_3>;i_3}:N-N-S)) + (g{i_3,i_4;i_1,i_2}:N-C-S * (C{a_1<i_1,i_2>;a_1}:N-C-S * (C{a_1;a_3<i_3>}:N-C-S * t{a_3<i_3>;i_3}:N-N-S))) * (C{a_2<i_1,i_2>;a_2}:N-C-S * (C{a_2;a_4<i_4>}:N-C-S * t{a_4<i_4>;i_4}:N-N-S)) + 2 ((g{i_3,i_4;i_2,a_21623}:N-C-S * (C{a_21623;a_3<i_1>}:N-C-S * t{a_3<i_1>;i_1}:N-N-S)) * (C{a_1<i_1,i_2>;a_1}:N-C-S * (C{a_1;a_4<i_4>}:N-C-S * t{a_4<i_4>;i_4}:N-N-S))) * (C{a_2<i_1,i_2>;a_2}:N-C-S * (C{a_2;a_5<i_3>}:N-C-S * t{a_5<i_3>;i_3}:N-N-S)) + 2 (((g{i_3,i_4;i_1,a_21674}:N-C-S * (C{a_21674;a_3<i_2>}:N-C-S * t{a_3<i_2>;i_2}:N-N-S)) * ((C{a_1;a_4<i_3,i_4>}:N-C-S * t{a_4<i_3,i_4>,a_5<i_3,i_4>;i_3,i_4}:N-N-S) * C{a_2;a_5<i_3,i_4>}:N-C-S)) * C{a_1<i_1,i_2>;a_1}:N-C-S) * C{a_2<i_1,i_2>;a_2}:N-C-S - 4 ((g{i_3,i_4;i_2,a_21626}:N-C-S * ((C{a_21626;a_3<i_1,i_4>}:N-C-S * t{a_3<i_1,i_4>,a_4<i_1,i_4>;i_4,i_1}:N-N-S) * C{a_1;a_4<i_1,i_4>}:N-C-S)) * C{a_1<i_1,i_2>;a_1}:N-C-S) * (C{a_2<i_1,i_2>;a_2}:N-C-S * (C{a_2;a_5<i_3>}:N-C-S * t{a_5<i_3>;i_3}:N-N-S)) + 2 (((g{i_3,i_4;a_21633,a_21634}:N-C-S * (C{a_21633;a_3<i_2>}:N-C-S * t{a_3<i_2>;i_2}:N-N-S)) * ((C{a_21634;a_4<i_1,i_3>}:N-C-S * t{a_4<i_1,i_3>,a_6<i_1,i_3>;i_1,i_3}:N-N-S) * C{a_2;a_6<i_1,i_3>}:N-C-S)) * C{a_2<i_1,i_2>;a_2}:N-C-S) * (C{a_1<i_1,i_2>;a_1}:N-C-S * (C{a_1;a_5<i_4>}:N-C-S * t{a_5<i_4>;i_4}:N-N-S)) + ((g{i_3,i_4;a_21637,a_21638}:N-C-S * ((C{a_21637;a_3<i_1,i_2>}:N-C-S * t{a_3<i_1,i_2>,a_4<i_1,i_2>;i_1,i_2}:N-N-S) * C{a_21638;a_4<i_1,i_2>}:N-C-S)) * (C{a_1<i_1,i_2>;a_1}:N-C-S * (C{a_1;a_5<i_3>}:N-C-S * t{a_5<i_3>;i_3}:N-N-S))) * (C{a_2<i_1,i_2>;a_2}:N-C-S * (C{a_2;a_6<i_4>}:N-C-S * t{a_6<i_4>;i_4}:N-N-S)) + 2 ((g{i_3,i_4;i_2,a_21642}:N-C-S * ((C{a_21642;a_3<i_1,i_4>}:N-C-S * t{a_3<i_1,i_4>,a_4<i_1,i_4>;i_1,i_4}:N-N-S) * C{a_1;a_4<i_1,i_4>}:N-C-S)) * C{a_1<i_1,i_2>;a_1}:N-C-S) * (C{a_2<i_1,i_2>;a_2}:N-C-S * (C{a_2;a_5<i_3>}:N-C-S * t{a_5<i_3>;i_3}:N-N-S)) - 2 ((g{i_3,a_21645;i_2,a_21646}:N-C-S * (C{a_21646;a_3<i_1>}:N-C-S * t{a_3<i_1>;i_1}:N-N-S)) * C{a_1<i_1,i_2>;a_21645}:N-C-S) * (C{a_2<i_1,i_2>;a_2}:N-C-S * (C{a_2;a_4<i_3>}:N-C-S * t{a_4<i_3>;i_3}:N-N-S)) - 4 (((g{i_3,i_4;a_21649,a_21650}:N-C-S * (C{a_21649;a_3<i_3>}:N-C-S * t{a_3<i_3>;i_3}:N-N-S)) * C{a_21650;a_4<i_1,i_2>}:N-C-S) * t{a_1<i_1,i_2>,a_4<i_1,i_2>;i_1,i_2}:N-N-S) * (C{a_2<i_1,i_2>;a_2}:N-C-S * (C{a_2;a_5<i_4>}:N-C-S * t{a_5<i_4>;i_4}:N-N-S)) - 2 ((g{i_3,a_21651;a_21652,a_21653}:N-C-S * ((C{a_21652;a_3<i_1,i_2>}:N-C-S * t{a_3<i_1,i_2>,a_4<i_1,i_2>;i_2,i_1}:N-N-S) * C{a_21653;a_4<i_1,i_2>}:N-C-S)) * C{a_1<i_1,i_2>;a_21651}:N-C-S) * (C{a_2<i_1,i_2>;a_2}:N-C-S * (C{a_2;a_5<i_3>}:N-C-S * t{a_5<i_3>;i_3}:N-N-S)) + 2 (((g{i_3,i_4;a_21654,a_21655}:N-C-S * (C{a_21654;a_3<i_4>}:N-C-S * t{a_3<i_4>;i_4}:N-N-S)) * C{a_21655;a_4<i_1,i_2>}:N-C-S) * t{a_1<i_1,i_2>,a_4<i_1,i_2>;i_1,i_2}:N-N-S) * (C{a_2<i_1,i_2>;a_2}:N-C-S * (C{a_2;a_5<i_3>}:N-C-S * t{a_5<i_3>;i_3}:N-N-S)) + 2 ((((g{i_3,i_4;a_21659,a_21660}:N-C-S * (C{a_21659;a_3<i_4>}:N-C-S * t{a_3<i_4>;i_4}:N-N-S)) * (C{a_21660;a_4<i_2>}:N-C-S * t{a_4<i_2>;i_2}:N-N-S)) * ((C{a_1;a_5<i_1,i_3>}:N-C-S * t{a_5<i_1,i_3>,a_6<i_1,i_3>;i_1,i_3}:N-N-S) * C{a_2;a_6<i_1,i_3>}:N-C-S)) * C{a_1<i_1,i_2>;a_1}:N-C-S) * C{a_2<i_1,i_2>;a_2}:N-C-S - 2 (((g{i_3,a_21656;a_21657,a_21658}:N-C-S * (C{a_21657;a_3<i_2>}:N-C-S * t{a_3<i_2>;i_2}:N-N-S)) * (C{a_21658;a_4<i_1>}:N-C-S * t{a_4<i_1>;i_1}:N-N-S)) * C{a_1<i_1,i_2>;a_21656}:N-C-S) * (C{a_2<i_1,i_2>;a_2}:N-C-S * (C{a_2;a_5<i_3>}:N-C-S * t{a_5<i_3>;i_3}:N-N-S)) - 2 ((f{i_3;a_21661}:N-C-S * C{a_21661;a_3<i_1,i_2>}:N-C-S) * t{a_1<i_1,i_2>,a_3<i_1,i_2>;i_1,i_2}:N-N-S) * (C{a_2<i_1,i_2>;a_2}:N-C-S * (C{a_2;a_4<i_3>}:N-C-S * t{a_4<i_3>;i_3}:N-N-S)) + (((g{i_3,i_4;a_21662,a_21663}:N-C-S * (C{a_21662;a_3<i_1>}:N-C-S * t{a_3<i_1>;i_1}:N-N-S)) * (C{a_21663;a_4<i_2>}:N-C-S * t{a_4<i_2>;i_2}:N-N-S)) * (C{a_1<i_1,i_2>;a_1}:N-C-S * (C{a_1;a_5<i_3>}:N-C-S * t{a_5<i_3>;i_3}:N-N-S))) * (C{a_2<i_1,i_2>;a_2}:N-C-S * (C{a_2;a_6<i_4>}:N-C-S * t{a_6<i_4>;i_4}:N-N-S)) + 2 (((g{i_3,i_4;a_21671,a_21672}:N-C-S * (C{a_21671;a_3<i_2>}:N-C-S * t{a_3<i_2>;i_2}:N-N-S)) * ((C{a_21672;a_4<i_1,i_3>}:N-C-S * t{a_4<i_1,i_3>,a_5<i_1,i_3>;i_3,i_1}:N-N-S) * C{a_1;a_5<i_1,i_3>}:N-C-S)) * C{a_1<i_1,i_2>;a_1}:N-C-S) * (C{a_2<i_1,i_2>;a_2}:N-C-S * (C{a_2;a_6<i_4>}:N-C-S * t{a_6<i_4>;i_4}:N-N-S)) - 2 (g{i_3,a_21673;i_2,i_1}:N-C-S * C{a_1<i_1,i_2>;a_21673}:N-C-S) * (C{a_2<i_1,i_2>;a_2}:N-C-S * (C{a_2;a_3<i_3>}:N-C-S * t{a_3<i_3>;i_3}:N-N-S)) + ((((g{i_3,i_4;a_21577,a_21578}:N-C-S * (C{a_21577;a_3<i_1>}:N-C-S * t{a_3<i_1>;i_1}:N-N-S)) * (C{a_21578;a_4<i_2>}:N-C-S * t{a_4<i_2>;i_2}:N-N-S)) * ((C{a_1;a_5<i_3,i_4>}:N-C-S * t{a_5<i_3,i_4>,a_6<i_3,i_4>;i_3,i_4}:N-N-S) * C{a_2;a_6<i_3,i_4>}:N-C-S)) * C{a_1<i_1,i_2>;a_1}:N-C-S) * C{a_2<i_1,i_2>;a_2}:N-C-S - 2 (((g{i_3,i_4;a_21581,a_21582}:N-C-S * ((C{a_21581;a_3<i_2,i_4>}:N-C-S * t{a_3<i_2,i_4>,a_6<i_2,i_4>;i_4,i_2}:N-N-S) * C{a_2;a_6<i_2,i_4>}:N-C-S)) * ((C{a_21582;a_4<i_1,i_3>}:N-C-S * t{a_4<i_1,i_3>,a_5<i_1,i_3>;i_3,i_1}:N-N-S) * C{a_1;a_5<i_1,i_3>}:N-C-S)) * C{a_1<i_1,i_2>;a_1}:N-C-S) * C{a_2<i_1,i_2>;a_2}:N-C-S + 2 (((g{i_3,i_4;a_21643,a_21644}:N-C-S * ((C{a_21643;a_3<i_1,i_4>}:N-C-S * t{a_3<i_1,i_4>,a_5<i_1,i_4>;i_4,i_1}:N-N-S) * C{a_1;a_5<i_1,i_4>}:N-C-S)) * ((C{a_21644;a_4<i_2,i_3>}:N-C-S * t{a_4<i_2,i_3>,a_6<i_2,i_3>;i_2,i_3}:N-N-S) * C{a_2;a_6<i_2,i_3>}:N-C-S)) * C{a_1<i_1,i_2>;a_1}:N-C-S) * C{a_2<i_1,i_2>;a_2}:N-C-S + 4 (((g{i_3,a_21589;a_21590,a_21591}:N-C-S * (C{a_21591;a_4<i_2>}:N-C-S * t{a_4<i_2>;i_2}:N-N-S)) * ((C{a_21590;a_3<i_1,i_3>}:N-C-S * t{a_3<i_1,i_3>,a_5<i_1,i_3>;i_3,i_1}:N-N-S) * C{a_1;a_5<i_1,i_3>}:N-C-S)) * C{a_2<i_1,i_2>;a_21589}:N-C-S) * C{a_1<i_1,i_2>;a_1}:N-C-S - 2 (((g{i_3,a_21664;a_21665,a_21666}:N-C-S * (C{a_21666;a_4<i_2>}:N-C-S * t{a_4<i_2>;i_2}:N-N-S)) * ((C{a_21665;a_3<i_1,i_3>}:N-C-S * t{a_3<i_1,i_3>,a_5<i_1,i_3>;i_1,i_3}:N-N-S) * C{a_1;a_5<i_1,i_3>}:N-C-S)) * C{a_2<i_1,i_2>;a_21664}:N-C-S) * C{a_1<i_1,i_2>;a_1}:N-C-S - 4 ((((g{i_3,i_4;a_21592,a_21593}:N-C-S * (C{a_21592;a_3<i_3>}:N-C-S * t{a_3<i_3>;i_3}:N-N-S)) * (C{a_21593;a_4<i_2>}:N-C-S * t{a_4<i_2>;i_2}:N-N-S)) * ((C{a_1;a_5<i_1,i_4>}:N-C-S * t{a_5<i_1,i_4>,a_6<i_1,i_4>;i_1,i_4}:N-N-S) * C{a_2;a_6<i_1,i_4>}:N-C-S)) * C{a_1<i_1,i_2>;a_1}:N-C-S) * C{a_2<i_1,i_2>;a_2}:N-C-S + 4 (((g{i_3,i_4;a_21597,a_21598}:N-C-S * ((C{a_21597;a_3<i_1,i_3>}:N-C-S * t{a_3<i_1,i_3>,a_5<i_1,i_3>;i_3,i_1}:N-N-S) * C{a_1;a_5<i_1,i_3>}:N-C-S)) * ((C{a_21598;a_4<i_2,i_4>}:N-C-S * t{a_4<i_2,i_4>,a_6<i_2,i_4>;i_4,i_2}:N-N-S) * C{a_2;a_6<i_2,i_4>}:N-C-S)) * C{a_1<i_1,i_2>;a_1}:N-C-S) * C{a_2<i_1,i_2>;a_2}:N-C-S - 4 (((g{i_3,i_4;a_21610,a_21611}:N-C-S * ((C{a_21610;a_3<i_1,i_3>}:N-C-S * t{a_3<i_1,i_3>,a_5<i_1,i_3>;i_3,i_1}:N-N-S) * C{a_1;a_5<i_1,i_3>}:N-C-S)) * ((C{a_21611;a_4<i_2,i_4>}:N-C-S * t{a_4<i_2,i_4>,a_6<i_2,i_4>;i_2,i_4}:N-N-S) * C{a_2;a_6<i_2,i_4>}:N-C-S)) * C{a_1<i_1,i_2>;a_1}:N-C-S) * C{a_2<i_1,i_2>;a_2}:N-C-S + ((g{i_3,i_4;i_1,i_2}:N-C-S * ((C{a_1;a_3<i_3,i_4>}:N-C-S * t{a_3<i_3,i_4>,a_4<i_3,i_4>;i_3,i_4}:N-N-S) * C{a_2;a_4<i_3,i_4>}:N-C-S)) * C{a_1<i_1,i_2>;a_1}:N-C-S) * C{a_2<i_1,i_2>;a_2}:N-C-S - 2 ((g{i_3,a_21601;i_1,a_21602}:N-C-S * ((C{a_21602;a_3<i_2,i_3>}:N-C-S * t{a_3<i_2,i_3>,a_4<i_2,i_3>;i_2,i_3}:N-N-S) * C{a_1;a_4<i_2,i_3>}:N-C-S)) * C{a_2<i_1,i_2>;a_21601}:N-C-S) * C{a_1<i_1,i_2>;a_1}:N-C-S - 2 ((f{i_3;i_2}:N-C-S * ((C{a_1;a_3<i_1,i_3>}:N-C-S * t{a_3<i_1,i_3>,a_4<i_1,i_3>;i_1,i_3}:N-N-S) * C{a_2;a_4<i_1,i_3>}:N-C-S)) * C{a_1<i_1,i_2>;a_1}:N-C-S) * C{a_2<i_1,i_2>;a_2}:N-C-S - 4 (((g{i_3,i_4;a_21603,a_21604}:N-C-S * ((C{a_21603;a_3<i_2,i_4>}:N-C-S * t{a_3<i_2,i_4>,a_4<i_2,i_4>;i_2,i_4}:N-N-S) * C{a_21604;a_4<i_2,i_4>}:N-C-S)) * ((C{a_1;a_5<i_1,i_3>}:N-C-S * t{a_5<i_1,i_3>,a_6<i_1,i_3>;i_1,i_3}:N-N-S) * C{a_2;a_6<i_1,i_3>}:N-C-S)) * C{a_1<i_1,i_2>;a_1}:N-C-S) * C{a_2<i_1,i_2>;a_2}:N-C-S - 2 ((g{i_3,a_21605;i_1,a_21606}:N-C-S * ((C{a_21606;a_3<i_2,i_3>}:N-C-S * t{a_3<i_2,i_3>,a_4<i_2,i_3>;i_3,i_2}:N-N-S) * C{a_2;a_4<i_2,i_3>}:N-C-S)) * C{a_1<i_1,i_2>;a_21605}:N-C-S) * C{a_2<i_1,i_2>;a_2}:N-C-S - 4 (((g{i_3,i_4;i_1,a_21609}:N-C-S * (C{a_21609;a_3<i_4>}:N-C-S * t{a_3<i_4>;i_4}:N-N-S)) * ((C{a_1;a_4<i_2,i_3>}:N-C-S * t{a_4<i_2,i_3>,a_5<i_2,i_3>;i_3,i_2}:N-N-S) * C{a_2;a_5<i_2,i_3>}:N-C-S)) * C{a_1<i_1,i_2>;a_1}:N-C-S) * C{a_2<i_1,i_2>;a_2}:N-C-S + 2 (((g{i_3,i_4;i_2,a_21612}:N-C-S * (C{a_21612;a_3<i_3>}:N-C-S * t{a_3<i_3>;i_3}:N-N-S)) * ((C{a_1;a_4<i_1,i_4>}:N-C-S * t{a_4<i_1,i_4>,a_5<i_1,i_4>;i_1,i_4}:N-N-S) * C{a_2;a_5<i_1,i_4>}:N-C-S)) * C{a_1<i_1,i_2>;a_1}:N-C-S) * C{a_2<i_1,i_2>;a_2}:N-C-S + (((g{i_3,i_4;a_21615,a_21616}:N-C-S * ((C{a_21615;a_3<i_1,i_2>}:N-C-S * t{a_3<i_1,i_2>,a_4<i_1,i_2>;i_1,i_2}:N-N-S) * C{a_21616;a_4<i_1,i_2>}:N-C-S)) * ((C{a_1;a_5<i_3,i_4>}:N-C-S * t{a_5<i_3,i_4>,a_6<i_3,i_4>;i_3,i_4}:N-N-S) * C{a_2;a_6<i_3,i_4>}:N-C-S)) * C{a_1<i_1,i_2>;a_1}:N-C-S) * C{a_2<i_1,i_2>;a_2}:N-C-S - 2 (((f{i_3;a_21617}:N-C-S * (C{a_21617;a_3<i_1>}:N-C-S * t{a_3<i_1>;i_1}:N-N-S)) * ((C{a_1;a_4<i_2,i_3>}:N-C-S * t{a_4<i_2,i_3>,a_5<i_2,i_3>;i_3,i_2}:N-N-S) * C{a_2;a_5<i_2,i_3>}:N-C-S)) * C{a_1<i_1,i_2>;a_1}:N-C-S) * C{a_2<i_1,i_2>;a_2}:N-C-S - 2 ((g{i_3,a_21618;a_21619,i_1}:N-C-S * ((C{a_21619;a_3<i_2,i_3>}:N-C-S * t{a_3<i_2,i_3>,a_4<i_2,i_3>;i_2,i_3}:N-N-S) * C{a_2;a_4<i_2,i_3>}:N-C-S)) * C{a_1<i_1,i_2>;a_21618}:N-C-S) * C{a_2<i_1,i_2>;a_2}:N-C-S + 2 (((g{i_3,i_4;a_21627,a_21628}:N-C-S * ((C{a_21627;a_3<i_2,i_3>}:N-C-S * t{a_3<i_2,i_3>,a_4<i_2,i_3>;i_2,i_3}:N-N-S) * C{a_21628;a_4<i_2,i_3>}:N-C-S)) * ((C{a_1;a_5<i_1,i_4>}:N-C-S * t{a_5<i_1,i_4>,a_6<i_1,i_4>;i_1,i_4}:N-N-S) * C{a_2;a_6<i_1,i_4>}:N-C-S)) * C{a_1<i_1,i_2>;a_1}:N-C-S) * C{a_2<i_1,i_2>;a_2}:N-C-S + (((g{i_3,i_4;a_21631,a_21632}:N-C-S * ((C{a_21631;a_3<i_1,i_3>}:N-C-S * t{a_3<i_1,i_3>,a_5<i_1,i_3>;i_1,i_3}:N-N-S) * C{a_1;a_5<i_1,i_3>}:N-C-S)) * ((C{a_21632;a_4<i_2,i_4>}:N-C-S * t{a_4<i_2,i_4>,a_6<i_2,i_4>;i_2,i_4}:N-N-S) * C{a_2;a_6<i_2,i_4>}:N-C-S)) * C{a_1<i_1,i_2>;a_1}:N-C-S) * C{a_2<i_1,i_2>;a_2}:N-C-S + 4 ((g{i_3,a_21635;a_21636,i_1}:N-C-S * ((C{a_21636;a_3<i_2,i_3>}:N-C-S * t{a_3<i_2,i_3>,a_4<i_2,i_3>;i_3,i_2}:N-N-S) * C{a_2;a_4<i_2,i_3>}:N-C-S)) * C{a_1<i_1,i_2>;a_21635}:N-C-S) * C{a_2<i_1,i_2>;a_2}:N-C-S - 2 (((g{i_3,a_21639;a_21640,a_21641}:N-C-S * (C{a_21640;a_3<i_1>}:N-C-S * t{a_3<i_1>;i_1}:N-N-S)) * ((C{a_21641;a_4<i_2,i_3>}:N-C-S * t{a_4<i_2,i_3>,a_5<i_2,i_3>;i_3,i_2}:N-N-S) * C{a_2;a_5<i_2,i_3>}:N-C-S)) * C{a_1<i_1,i_2>;a_21639}:N-C-S) * C{a_2<i_1,i_2>;a_2}:N-C-S + (((g{i_3,i_4;a_21647,a_21648}:N-C-S * ((C{a_21647;a_3<i_2,i_4>}:N-C-S * t{a_3<i_2,i_4>,a_5<i_2,i_4>;i_2,i_4}:N-N-S) * C{a_1;a_5<i_2,i_4>}:N-C-S)) * ((C{a_21648;a_4<i_1,i_3>}:N-C-S * t{a_4<i_1,i_3>,a_6<i_1,i_3>;i_1,i_3}:N-N-S) * C{a_2;a_6<i_1,i_3>}:N-C-S)) * C{a_1<i_1,i_2>;a_1}:N-C-S) * C{a_2<i_1,i_2>;a_2}:N-C-S + ((g{a_21667,a_21668;a_21669,a_21670}:N-C-S * ((C{a_21669;a_3<i_1,i_2>}:N-C-S * t{a_3<i_1,i_2>,a_4<i_1,i_2>;i_1,i_2}:N-N-S) * C{a_21670;a_4<i_1,i_2>}:N-C-S)) * C{a_1<i_1,i_2>;a_21667}:N-C-S) * C{a_2<i_1,i_2>;a_21668}:N-C-S + (((g{a_21585,a_21586;a_21587,a_21588}:N-C-S * (C{a_21587;a_3<i_1>}:N-C-S * t{a_3<i_1>;i_1}:N-N-S)) * (C{a_21588;a_4<i_2>}:N-C-S * t{a_4<i_2>;i_2}:N-N-S)) * C{a_1<i_1,i_2>;a_21585}:N-C-S) * C{a_2<i_1,i_2>;a_21586}:N-C-S - 2 (((g{i_3,a_21594;a_21595,a_21596}:N-C-S * (C{a_21596;a_4<i_3>}:N-C-S * t{a_4<i_3>;i_3}:N-N-S)) * C{a_2<i_1,i_2>;a_21594}:N-C-S) * C{a_21595;a_3<i_1,i_2>}:N-C-S) * t{a_1<i_1,i_2>,a_3<i_1,i_2>;i_1,i_2}:N-N-S + 2 ((g{a_21620,a_21621;i_1,a_21622}:N-C-S * (C{a_21622;a_3<i_2>}:N-C-S * t{a_3<i_2>;i_2}:N-N-S)) * C{a_1<i_1,i_2>;a_21620}:N-C-S) * C{a_2<i_1,i_2>;a_21621}:N-C-S + 2 (((((g{i_3,i_4;a_21599,a_21600}:N-C-S * C{a_21600;a_4<i_3,i_4>}:N-C-S) * t{a_4<i_3,i_4>,a_5<i_3,i_4>;i_3,i_4}:N-N-S) * C{a_2;a_5<i_3,i_4>}:N-C-S) * C{a_21599;a_3<i_1,i_2>}:N-C-S) * C{a_2<i_1,i_2>;a_2}:N-C-S) * t{a_1<i_1,i_2>,a_3<i_1,i_2>;i_1,i_2}:N-N-S - 4 (((((g{i_3,i_4;a_21613,a_21614}:N-C-S * C{a_21613;a_3<i_3,i_4>}:N-C-S) * t{a_3<i_3,i_4>,a_5<i_3,i_4>;i_3,i_4}:N-N-S) * C{a_2;a_5<i_3,i_4>}:N-C-S) * C{a_21614;a_4<i_1,i_2>}:N-C-S) * C{a_2<i_1,i_2>;a_2}:N-C-S) * t{a_1<i_1,i_2>,a_4<i_1,i_2>;i_1,i_2}:N-N-S + (g{a_21624,a_21625;i_1,i_2}:N-C-S * C{a_1<i_1,i_2>;a_21624}:N-C-S) * C{a_2<i_1,i_2>;a_21625}:N-C-S + 2 ((f{a_21629;a_21630}:N-C-S * C{a_2<i_1,i_2>;a_21629}:N-C-S) * C{a_21630;a_3<i_1,i_2>}:N-C-S) * t{a_1<i_1,i_2>,a_3<i_1,i_2>;i_1,i_2}:N-N-S
diff --git a/tests/unit/test_eval_dryrun.cpp b/tests/unit/test_eval_dryrun.cpp
new file mode 100644
index 0000000000..ad9c13710f
--- /dev/null
+++ b/tests/unit/test_eval_dryrun.cpp
@@ -0,0 +1,478 @@
+// Task 1 (DryRun eval backend, Phase 1): infrastructure + DP-inspection
+// mechanics for the eventual go/no-go probe on the C60 batched-schedule
+// factorization.
+//
+// SCOPE NOTE (two course corrections; see task-1-report.md for the full
+// history): the committed fixture `data/csv_ccsd_residual.txt` (mpqc's
+// `csv_eqn_Rs.serialized`) is a PRE-transform residual: every two-electron
+// integral `g` is still 4-index (`g{i,i;a,a}`-shaped), there is no auxiliary
+// DF ("K"/Kappa) index anywhere in it, and the non-proto `a_NNNNN` indices are
+// the GENERIC BASE VIRTUAL space, NOT the PAO ("mu~") space -- PAO and DF aux
+// are introduced downstream by mpqc's CSV->base-integral transform and
+// density-fitting refactorization, which run in mpqc's own pipeline against
+// mpqc's extended LCAO space registry, not the standalone SeQuant mbpt
+// registry this test has access to. So:
+//   - the two K-based memsize anchors from the cluster trace (~1.87 GB /
+//     ~186 GB) are NOT reproducible from this fixture, and this file does not
+//     attempt them (see the self-consistency case below instead);
+//   - a faithful PAO/K batch-axis GO/NO-GO VERDICT is NOT obtainable from this
+//     pre-transform fixture either, since the factorizer that produced the
+//     C60 trace ran on the POST-transform (mu~ + K) form. That verdict is
+//     deferred to a follow-up once a post-transform fixture is available.
+//
+// What this file DOES deliver and verify, against the real residual:
+//   1. the deserialize path works under the standalone mbpt context (mirrors
+//      test_optimize.cpp's context setup), and reports the term count;
+//   2. the DP-inspection MECHANICS work end-to-end: running optimize() with
+//      objective_function = DensePeakSizeBatched and a finite peak_threshold,
+//      using a generic (stand-in) batchable predicate over the base virtual
+//      space "a", and reading back per-node batch_axes() via
+//      OptimizeOptions::term_batch_axes -> BinarizationOptions::
+//      node_batch_axes -> binarize() -> EvalExpr::batch_axes(). This is the
+//      exact plumbing later tasks (and the eventual real verdict) will reuse;
+//      it is explicitly NOT a PAO/mu~ finding (see the log labelling below);
+//   3. a harness self-check with a tiny forced peak_threshold, proving the
+//      plumbing CAN produce a non-empty batch_axes annotation when the DP is
+//      forced to batch (rules out "the harness can't express batching" as an
+//      explanation for whatever the mechanics case observes);
+//   4. a self-consistency memsize check against SizeRegime's own extents/
+//      moments (replaces the unreachable cluster K-anchors).
+
+#include <SeQuant/core/eval/backends/dryrun/size_regime.hpp>
+
+#include <SeQuant/core/eval/eval_expr.hpp>
+#include <SeQuant/core/expr.hpp>
+#include <SeQuant/core/expressions/tensor.hpp>
+#include <SeQuant/core/index.hpp>
+#include <SeQuant/core/io/shorthands.hpp>
+#include <SeQuant/core/optimize/optimize.hpp>
+#include <SeQuant/core/optimize/options.hpp>
+#include <SeQuant/core/optimize/single_term_detail.hpp>
+#include <SeQuant/core/runtime.hpp>
+#include <SeQuant/core/space.hpp>
+#include <SeQuant/core/utility/macros.hpp>
+#include <SeQuant/domain/mbpt/convention.hpp>
+
+#include <catch2/catch_approx.hpp>
+#include <catch2/catch_test_macros.hpp>
+
+#include <cmath>
+#include <cstddef>
+#include <fstream>
+#include <iostream>
+#include <memory>
+#include <sstream>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+using namespace sequant;
+using sequant::eval::dryrun::SizeRegime;
+
+namespace {
+
+std::string slurp(std::string const& path) {
+  std::ifstream in(path);
+  std::stringstream ss;
+  ss << in.rdbuf();
+  return ss.str();
+}
+
+// The fixture is mpqc's raw debug dump: three "==== Rs[k] ====" header lines,
+// each immediately followed by one line holding the serialized residual
+// member k (a Sum of Products). Strip the headers; return the three
+// expression lines in order.
+std::vector<std::string> split_residual_members(std::string const& text) {
+  std::vector<std::string> members;
+  std::istringstream in(text);
+  std::string line;
+  while (std::getline(in, line)) {
+    if (line.empty() || line.rfind("====", 0) == 0) continue;
+    members.push_back(line);
+  }
+  return members;
+}
+
+// Stand-in regime for the pre-transform residual: extents are plausible
+// order-of-magnitude values (the real per-atom/per-basis extents live in
+// mpqc's post-transform pipeline, not reachable from a bare SeQuant unit
+// test -- see the file header). `a` is dual-purpose exactly as in mpqc's
+// ctx.idx_to_extent (cck.ipp): a bare (non-proto) occurrence is the generic
+// base virtual (sized by space_extent); a proto-indexed occurrence is a PNO
+// (2 protos) or OSV (1 proto) domain composite (sized by the moment tables).
+// NOTE: bare "a" here is NOT the PAO ("mu~") space (see file header) -- it is
+// used only as a stand-in batchable axis to exercise the DP-inspection
+// mechanics below.
+SizeRegime c60_regime() {
+  SizeRegime r;
+  r.space_extent = {
+      {L"i", 120},   // active occupied (order-of-magnitude stand-in)
+      {L"a", 1800},  // generic base virtual (order-of-magnitude stand-in)
+  };
+  // CC-average PNO ~58, OSV ~20 (order-of-magnitude stand-ins; see report).
+  double const pno = 58.0, osv = 20.0;
+  for (std::size_t k = 0; k <= 4; ++k) {
+    r.csv_pno_moment[k] = std::pow(pno, double(k));
+    r.csv_osv_moment[k] = std::pow(osv, double(k));
+  }
+  return r;
+}
+
+// Stand-in batchable predicate for the mechanics check: a non-proto-indexed
+// index in the (generic base virtual) space "a". This is NOT a claim that "a"
+// is the PAO space -- see the file header. It only needs to pick SOME
+// contracted index so the DP-inspection round-trip (OptimizeOptions ->
+// term_batch_axes -> BinarizationOptions -> binarize -> EvalExpr::
+// batch_axes()) can be exercised end-to-end against the real residual.
+bool is_stand_in_batchable(Index const& ix) {
+  return ix.space().base_key() == L"a" && !ix.has_proto_indices();
+}
+
+// Free (external) indices of a binarized-tree node's result, read off its
+// EvalExpr tensor (scalar-result nodes return an empty vector).
+std::vector<Index> node_free_indices(EvalExpr const& n) {
+  std::vector<Index> v;
+  if (!n.is_tensor()) return v;
+  for (auto const& ix : n.as_tensor().const_braketaux_indices())
+    v.push_back(ix);
+  return v;
+}
+
+std::wstring describe_indices(std::vector<Index> const& ixs) {
+  std::wstring s;
+  for (auto const& ix : ixs) {
+    s += std::wstring(ix.full_label());
+    s += L" ";
+  }
+  return s;
+}
+
+}  // namespace
+
+TEST_CASE("dryrun size regime basic extents", "[dryrun-probe]") {
+  auto r = c60_regime();
+  // A bare occ index resolves to its space extent.
+  auto i = Index{L"i_1"};
+  CHECK(r.extent(i) == 120);
+  auto a = Index{L"a_1"};
+  CHECK(r.extent(a) == 1800);
+  CHECK_THROWS_AS(r.extent(Index{L"x_1"}), std::out_of_range);
+}
+
+TEST_CASE("dryrun regime self-consistency (no cluster anchors needed)",
+          "[dryrun-probe]") {
+  // Replaces the (unreachable) two K-anchor checks: pick one concrete index
+  // set, hand-compute its expected element count from SizeRegime's own
+  // extents/moments, and confirm memsize_counter agrees. This validates the
+  // size MODEL (extent lookup + inner_pow composite dispatch), independent of
+  // whether the specific numeric extents match any particular cluster run.
+  auto r = c60_regime();
+  auto memsize = sequant::opt::detail::memsize_counter(r.idx_to_extent(),
+                                                       r.inner_pow_fn());
+
+  // A dense operand: two occ + two bare (base-virtual) indices, e.g. the
+  // ladder term's g{i,i;a,a}.
+  {
+    std::vector<Index> ixs{Index{L"i_1"}, Index{L"i_2"}, Index{L"a_1"},
+                           Index{L"a_2"}};
+    double const expected = 120.0 * 120.0 * 1800.0 * 1800.0;  // i * i * a * a
+    double const got = memsize(ixs, std::vector<Index>{}, std::vector<Index>{});
+    CHECK(got == Catch::Approx(expected));
+    INFO("dense operand elems=" << got << " (" << (got * 8 / 1e9)
+                                << " GB dense)");
+  }
+
+  // A CSV/PNO composite operand: one occ-pair-domain composite (2 protos),
+  // e.g. an intermediate carrying a_1<i_1,i_2>. tot_indices() pulls the
+  // composite's own proto indices (i_1, i_2) into the outer set too (they are
+  // genuinely free tensor slots the composite depends on), so the expected
+  // volume is i_1 * i_2 * <#PNO^1>, not just one occ factor.
+  {
+    Index i1{L"i_1"}, i2{L"i_2"};
+    Index pno_leg{L"a_1", {i1, i2}};
+    std::vector<Index> ixs{pno_leg};
+    double const expected = 120.0 * 120.0 * 58.0;  // i * i * <#PNO^1>
+    double const got = memsize(ixs, std::vector<Index>{}, std::vector<Index>{});
+    CHECK(got == Catch::Approx(expected));
+  }
+}
+
+// Sanity check for the probe's own plumbing (is_stand_in_batchable /
+// batch_policy / term_batch_axes / binarize round-trip), independent of the
+// real residual: with a tiny peak_threshold that makes every schedule
+// infeasible except the sliced one, the DP MUST annotate a batch axis
+// somewhere. If this failed it would mean the harness itself cannot express
+// batching (rather than the mechanics case below observing a genuine
+// non-annotation for some other reason).
+TEST_CASE("dryrun harness sanity: forced threshold does annotate a batch axis",
+          "[dryrun-probe]") {
+  auto ctx = get_default_context().clone();
+  ctx.set_first_dummy_index_ordinal(1000000);
+  auto ctx_resetter = set_scoped_default_context(std::move(ctx));
+
+  auto r = c60_regime();
+
+  // 4-tensor network with a_1 shared between the two g's (the only batchable
+  // contraction), mirroring test_optimize.cpp's "binarize stamps per-node
+  // batch axes from optimize()" case but using the stand-in base-virtual
+  // ("a", non-proto) axis instead of a DF aux axis.
+  auto expr = deserialize<ExprPtr>(
+      "g{a_100;i_1;a_1} g{a_101;i_2;a_1} f{i_1;i_3} f{i_2;i_4}");
+  REQUIRE(static_cast<bool>(expr));
+
+  auto axes_map = std::make_shared<std::unordered_map<
+      Expr const*, container::vector<container::svector<Index>>>>();
+
+  OptimizeOptions opts;
+  opts.objective_function = ObjectiveFunction::DensePeakSizeBatched;
+  opts.idx_to_extent = r.idx_to_extent();
+  opts.inner_pow = r.inner_pow_fn();
+  opts.batch_policy.is_batchable_index = [](Index const& ix) {
+    return is_stand_in_batchable(ix);
+  };
+  opts.batch_policy.batch_target_size = [](Index const&) {
+    return std::size_t{20};
+  };
+  opts.batch_policy.peak_threshold = 1.0;  // tiny budget => force batching
+  opts.term_batch_axes = axes_map;
+
+  auto optimized = optimize(expr, opts);
+  REQUIRE(static_cast<bool>(optimized));
+
+  auto it = axes_map->find(optimized.get());
+  REQUIRE(it != axes_map->end());
+  auto const& node_axes = it->second;
+  REQUIRE(!node_axes.empty());
+
+  BinarizationOptions bopts;
+  bopts.node_batch_axes = node_axes;
+
+  SEQUANT_PRAGMA_IGNORE_DEPRECATED_BEGIN
+  auto node = binarize(optimized, {}, bopts);
+  SEQUANT_PRAGMA_IGNORE_DEPRECATED_END
+
+  bool any_annotated = false;
+  bool axis_found = false;
+  node.visit([&](auto const& n) {
+    if (n->batch_axes().empty()) return;
+    any_annotated = true;
+    for (auto const& ix : n->batch_axes())
+      if (is_stand_in_batchable(ix)) axis_found = true;
+  });
+  CHECK(any_annotated);
+  CHECK(axis_found);
+}
+
+TEST_CASE("dryrun residual fixture deserializes", "[dryrun-probe]") {
+  // The fixture's dummy-index ordinals (a_21514, ...) come from mpqc's
+  // globally-incrementing internal counter and can reach into the tens of
+  // thousands; raise first_dummy_index_ordinal well above that so the parser
+  // does not mistake them for SeQuant's own reserved temporary-index range
+  // (default threshold 100, set by test_main.cpp).
+  auto ctx = get_default_context().clone();
+  ctx.set_first_dummy_index_ordinal(1000000);
+  auto ctx_resetter = set_scoped_default_context(std::move(ctx));
+
+  auto const residual = slurp(std::string(SEQUANT_UNIT_TESTS_SOURCE_DIR) +
+                              "/data/csv_ccsd_residual.txt");
+  REQUIRE(!residual.empty());
+  auto members = split_residual_members(residual);
+  REQUIRE(members.size() == 3);
+
+  for (std::size_t k = 0; k < members.size(); ++k) {
+    auto expr = deserialize<ExprPtr>(members[k]);
+    bool const have_expr = static_cast<bool>(expr);
+    REQUIRE(have_expr);
+    std::size_t nterms =
+        expr->is<Sum>() ? expr->as<Sum>().summands().size() : 1;
+    INFO("Rs[" << k << "] term count = " << nterms);
+    CHECK(nterms > 0);
+    std::wcout << L"Rs[" << k << L"] terms=" << nterms << L"\n";
+  }
+}
+
+// DP-inspection MECHANICS check on the real (pre-transform) residual: run
+// optimize() with objective_function = DensePeakSizeBatched and a finite
+// peak_threshold, using the stand-in batchable predicate over the generic
+// base-virtual space "a" (NOT the PAO/mu~ space -- see file header), purely
+// to exercise the API end-to-end and confirm per-node batch_axes() can be
+// read back after optimize(). This is NOT a PAO/mu~ go/no-go verdict; that
+// verdict needs a post-transform (mu~ + K) fixture (follow-up).
+TEST_CASE(
+    "dryrun DP-inspection mechanics on pre-transform residual "
+    "(verdict pending post-transform fixture)",
+    "[dryrun-probe]") {
+  // See the ordinal-range comment in the "residual fixture deserializes"
+  // case above.
+  auto ctx = get_default_context().clone();
+  ctx.set_first_dummy_index_ordinal(1000000);
+  auto ctx_resetter = set_scoped_default_context(std::move(ctx));
+
+  auto const residual = slurp(std::string(SEQUANT_UNIT_TESTS_SOURCE_DIR) +
+                              "/data/csv_ccsd_residual.txt");
+  auto members = split_residual_members(residual);
+  REQUIRE(members.size() == 3);
+
+  auto r = c60_regime();
+
+  double biggest_bytes = 0.0;
+  std::wstring biggest_desc;
+  bool biggest_has_axis = false;
+  bool any_axis_anywhere = false;
+  std::size_t n_carrying_nodes = 0;
+  // Confirms the term_batch_axes read-back mechanism itself (not just that
+  // optimize() ran): at least one optimized summand must have a non-empty
+  // entry in the map, i.e. the DP actually recorded a per-node sliced-set
+  // vector for it (see SeQuantEngine::make_optimize_options /
+  // sequant.cpp's to_node for the same read-back shape in mpqc).
+  std::size_t n_summands_with_nonempty_axes_entry = 0;
+
+  auto memsize = sequant::opt::detail::memsize_counter(r.idx_to_extent(),
+                                                       r.inner_pow_fn());
+
+  for (std::size_t k = 0; k < members.size(); ++k) {
+    auto expr = deserialize<ExprPtr>(members[k]);
+    bool const have_expr = static_cast<bool>(expr);
+    REQUIRE(have_expr);
+
+    // One summand per Sum entry. IMPORTANT: mirror mpqc's own to_node
+    // (sequant.cpp, process_for_evaluation) and call optimize() SEPARATELY
+    // on each individual summand, rather than once on the whole Sum. Calling
+    // optimize() on a multi-summand Sum with the default
+    // opts.reorder == ReorderSum::Reorder makes optimize_impl's Sum branch
+    // run opt::reorder(new_sum, nodes) at the end, which returns a NEW Sum
+    // whose summand ExprPtr identities differ from the ones opt_pure_product
+    // recorded term_batch_axes against -- so a post-hoc
+    // axes_map->find(optimized_summand.get()) on the whole-Sum result always
+    // misses (I hit exactly this: it silently returned 0 non-empty entries
+    // for all 86 real summands, no crash, no assert -- see report). Per-term
+    // optimize() calls take the Product branch of optimize_impl directly, so
+    // the returned ExprPtr's identity IS the term_batch_axes key.
+    // deserialize() preserves the literal (deeply nested) parenthesization
+    // of the source text, e.g. "2 ((g * (C * t)) * C) * t" stays a Product
+    // whose own factors can themselves be Products; it is NOT auto-flattened
+    // to a single flat factor list. single_term_opt (and thus
+    // TensorNetwork::tensors().size(), which run_single_term_opt_axes's
+    // nt==1 shortcut keys off) only sees the network of GENUINE Tensor
+    // leaves after flattening -- test_optimize.cpp's own "threshold gates
+    // batching" test hits the exact same thing and re-flattens explicitly
+    // (Product::Flatten::Yes) before calling single_term_opt. Do the same
+    // here; without it every term looks like a trivial 1-or-2-tensor network
+    // to the DP (which is exactly what I originally observed: node_axes came
+    // back empty for all 86 real summands, even ones with genuine multi-GB
+    // PAO-role-carrying intermediates found by the manual node walk below).
+    auto flatten_product = [](ExprPtr const& e) -> ExprPtr {
+      if (!e->is<Product>()) return e;
+      auto const& p = e->as<Product>();
+      return ex<Product>(p.scalar(), p.factors(), Product::Flatten::Yes);
+    };
+
+    std::vector<ExprPtr> input_terms;
+    if (expr->is<Sum>()) {
+      for (auto const& s : expr->as<Sum>()) input_terms.push_back(s);
+    } else {
+      input_terms.push_back(expr);
+    }
+    for (auto& t : input_terms) t = flatten_product(t);
+
+    for (auto const& input_term : input_terms) {
+      auto axes_map = std::make_shared<std::unordered_map<
+          Expr const*, container::vector<container::svector<Index>>>>();
+
+      OptimizeOptions opts;
+      opts.objective_function = ObjectiveFunction::DensePeakSizeBatched;
+      opts.idx_to_extent = r.idx_to_extent();
+      opts.inner_pow = r.inner_pow_fn();
+      opts.batch_policy.is_batchable_index = [](Index const& ix) {
+        return is_stand_in_batchable(ix);
+      };
+      opts.batch_policy.batch_target_size = [](Index const&) {
+        return std::size_t{100};
+      };
+      opts.batch_policy.peak_threshold = 40e9;  // 40 GB, matches the C60 run
+      opts.term_batch_axes = axes_map;
+
+      auto term = optimize(input_term, opts);
+      bool const have_optimized = static_cast<bool>(term);
+      REQUIRE(have_optimized);
+
+      auto it = axes_map->find(term.get());
+      container::vector<container::svector<Index>> node_axes;
+      if (it != axes_map->end()) {
+        node_axes = it->second;
+        if (!node_axes.empty()) ++n_summands_with_nonempty_axes_entry;
+      }
+
+      BinarizationOptions bopts;
+      bopts.node_batch_axes = node_axes;
+
+      SEQUANT_PRAGMA_IGNORE_DEPRECATED_BEGIN
+      auto node = binarize(term, {}, bopts);
+      SEQUANT_PRAGMA_IGNORE_DEPRECATED_END
+
+      // visit_internal only: leaves (original tensor factors, e.g. "g"/"C")
+      // are never DP decision points and can never carry a batch-axis
+      // annotation, so including them would understate the DP's actual
+      // annotation rate on genuine contraction (intermediate) results.
+      node.visit_internal([&](auto const& n) {
+        auto free_ixs = node_free_indices(*n);
+        if (free_ixs.empty()) return;
+        bool has_axis_candidate = false;
+        for (auto const& ix : free_ixs)
+          if (is_stand_in_batchable(ix)) has_axis_candidate = true;
+        if (!has_axis_candidate) return;
+        ++n_carrying_nodes;
+
+        double const bytes =
+            memsize(free_ixs, std::vector<Index>{}, std::vector<Index>{}) * 8.0;
+
+        bool node_has_axis = false;
+        for (auto const& ax : n->batch_axes())
+          if (is_stand_in_batchable(ax)) node_has_axis = true;
+        if (node_has_axis) any_axis_anywhere = true;
+
+        std::wcout << L"[dryrun-probe] Rs[" << k << L"] node free={"
+                   << describe_indices(free_ixs) << L"} bytes=" << bytes
+                   << L" (" << (bytes / 1e9) << L" GB) batch_axes={"
+                   << describe_indices(container::vector<Index>(
+                          n->batch_axes().begin(), n->batch_axes().end()))
+                   << L"}\n";
+
+        if (bytes > biggest_bytes) {
+          biggest_bytes = bytes;
+          biggest_desc = describe_indices(free_ixs);
+          biggest_has_axis = node_has_axis;
+        }
+      });
+    }
+  }
+
+  INFO("largest stand-in-axis-carrying node: "
+       << std::string(biggest_desc.begin(), biggest_desc.end())
+       << " bytes=" << biggest_bytes);
+  std::wcout
+      << L"\n=== DP-INSPECTION MECHANICS (pre-transform residual; NOT a "
+         L"PAO/mu~ verdict) ===\n"
+      << L"stand-in-axis-carrying contraction nodes seen: " << n_carrying_nodes
+      << L"\n"
+      << L"summands with a non-empty term_batch_axes entry: "
+      << n_summands_with_nonempty_axes_entry << L"\n"
+      << L"any node annotated with the stand-in batch axis: "
+      << (any_axis_anywhere ? L"YES" : L"NO") << L"\n"
+      << L"largest stand-in-axis-carrying node: " << biggest_desc << L" bytes="
+      << biggest_bytes << L" (" << (biggest_bytes / 1e9) << L" GB)"
+      << L" -- got stand-in batch axis: " << (biggest_has_axis ? L"YES" : L"NO")
+      << L"\n"
+      << L"NOTE: 'a' here is the generic base virtual space, not PAO/mu~; "
+         L"the real PAO/K go/no-go verdict needs a post-transform fixture "
+         L"(follow-up).\n";
+
+  // Mechanics check only: confirms the round-trip runs and per-node
+  // batch_axes() is readable; does not assert a pass/fail verdict on whether
+  // any particular node got annotated (see file header).
+  REQUIRE(n_carrying_nodes > 0);
+  // Confirms the term_batch_axes read-back mechanism specifically: at least
+  // one real summand must have produced a non-empty per-node axes vector.
+  REQUIRE(n_summands_with_nonempty_axes_entry > 0);
+  SUCCEED();
+}

From b79be90afae1522b4501147a5b22f14d9f4eb0ea Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Sat, 4 Jul 2026 16:39:44 -0400
Subject: [PATCH 23/78] dryrun: post-transform PAO/K verdict, CostModel,
 zero-data Result backend, and runtime replay

Completes the DryRun eval backend across two fronts:

1. The real (post-transform) PAO(mu~)/DF-aux(K) batch-axis go/no-go verdict,
   deferred by Task 1: a [dryrun-df] case that deserializes the real
   post-transform CSV-CCSD doubles residual (fixture
   tests/unit/data/csv_ccsd_doubles_residual_df.txt, dumped from mpqc at the
   exact point handed to sequant::optimize()), runs the batched single-term
   optimizer under a C60-scale regime, and confirms the DP annotates a mu~
   batch axis on the free-mu~ giant intermediate (matching the ~1.2 TB
   cluster-trace anchor almost exactly).

2. The DryRun eval backend itself (Tasks 2-6 of
   doc/dev/plans/2026-07-04-dryrun-eval-backend.md): CostModel wraps the
   optimizer's own memsize_counter/flops_counter/roofline_op_cost verbatim,
   adding only an ExtentOverrides indirection so a Result can report a
   runtime-realized (sliced) size rather than always the regime's nominal
   extent. ResultDryRun/ResultDryRunNested are zero-data Result tokens
   (index set + cost model only, no tensor storage) mirroring
   ResultTensorTAPP's structure; both concrete types share one op
   implementation (DryRunOps) and dispatch flat-vs-nested by content via
   make_dryrun_result, matching how the real engine decides
   tensor-of-tensor-ness. EvalExprDryRun/DryRunLeafEvaluator complete the
   plumbing evaluate() needs.

The [dryrun-eval] harness replays the giant term's DP-annotated,
binarized schedule through the REAL runtime (make_batched_custom_evaluator /
evaluate<Trace::On>, with SEQUANT_EVAL_TRACE defined for this translation
unit so note_working_set() fires through the batched evaluator's nested
per-batch/per-member recursion, not just the outermost interception) against
these zero-data tokens, reusing one BatchPolicy object for both optimize()
and the runtime evaluator. On the current codebase the replay does NOT
reproduce the suspected "K-sliced but mu~-full" bug: the giant's realized
peak stays near 1.5 GB (a >99.9% reduction from its 1.21 TB nominal size),
and the largest single materialized result (1.556 GB) matches the nominal
size divided by the product of the mu~ and K batch counts (18 x 43) to
within tile-rounding, i.e. both axes are genuinely nested-sliced by the
runtime as currently implemented.
---
 .../backends/dryrun/cost_model_object.hpp     | 142 +++
 .../core/eval/backends/dryrun/eval_expr.hpp   |  87 ++
 SeQuant/core/eval/backends/dryrun/result.hpp  | 427 +++++++++
 .../plans/2026-07-04-dryrun-eval-backend.md   | 844 ++++++++++++++++++
 .../data/csv_ccsd_doubles_residual_df.txt     |   1 +
 tests/unit/test_eval_dryrun.cpp               | 754 ++++++++++++++++
 6 files changed, 2255 insertions(+)
 create mode 100644 SeQuant/core/eval/backends/dryrun/cost_model_object.hpp
 create mode 100644 SeQuant/core/eval/backends/dryrun/eval_expr.hpp
 create mode 100644 SeQuant/core/eval/backends/dryrun/result.hpp
 create mode 100644 doc/dev/plans/2026-07-04-dryrun-eval-backend.md
 create mode 100644 tests/unit/data/csv_ccsd_doubles_residual_df.txt

diff --git a/SeQuant/core/eval/backends/dryrun/cost_model_object.hpp b/SeQuant/core/eval/backends/dryrun/cost_model_object.hpp
new file mode 100644
index 0000000000..48cc230d50
--- /dev/null
+++ b/SeQuant/core/eval/backends/dryrun/cost_model_object.hpp
@@ -0,0 +1,142 @@
+#ifndef SEQUANT_CORE_EVAL_BACKENDS_DRYRUN_COST_MODEL_OBJECT_HPP
+#define SEQUANT_CORE_EVAL_BACKENDS_DRYRUN_COST_MODEL_OBJECT_HPP
+
+#include <SeQuant/core/container.hpp>
+#include <SeQuant/core/eval/backends/dryrun/size_regime.hpp>
+#include <SeQuant/core/index.hpp>
+#include <SeQuant/core/optimize/cost_model.hpp>
+#include <SeQuant/core/optimize/options.hpp>
+#include <SeQuant/core/optimize/single_term_detail.hpp>
+
+#include <cstddef>
+#include <functional>
+#include <utility>
+
+namespace sequant::eval::dryrun {
+
+/// Per-index extent OVERRIDE table: narrows specific indices (by identity, so
+/// it survives reshaping across prod/sum/permute -- the same shared/
+/// contracted Index object may occupy different tensor modes at different
+/// nodes) to a runtime-realized element count. Populated by
+/// Result::slice_mode()/mode_batches() call sites (see result.hpp); empty =>
+/// no override, the regime's nominal extent applies. This table -- not a
+/// second cost model -- is what lets a zero-data DryRun Result report the
+/// REALIZED (possibly runtime-sliced) size rather than always the full
+/// regime extent, which is exactly the signal Task 6's replay witnesses.
+using ExtentOverrides = container::map<Index, std::size_t>;
+
+///
+/// \brief Bundles the optimizer's own cost closures (memsize/flops/roofline)
+/// behind one value type so dry-run Results report MODEL size (not an
+/// allocated size), and the harness can additionally read FLOPs and
+/// projected execution cost per operation.
+///
+/// This is a thin wrapper: all arithmetic is delegated verbatim to
+/// \c sequant::opt::detail::memsize_counter / \c flops_counter / \c
+/// roofline_op_cost (see \c core/optimize/single_term_detail.hpp and \c
+/// core/optimize/cost_model.hpp) -- no parallel cost model is implemented
+/// here. The only thing this class adds is the ExtentOverrides indirection:
+/// each query builds a fresh (cheap; no heap allocation beyond the closure
+/// itself) index-to-extent callable that consults \p overrides before
+/// falling back to the SizeRegime's nominal extent, then hands that callable
+/// to the counter.
+///
+class CostModel {
+ public:
+  explicit CostModel(SizeRegime regime, RooflineParams roofline = {})
+      : regime_{std::move(regime)}, roofline_{roofline} {}
+
+  ///
+  /// \brief Bytes for a tensor with these (literal, canon-order) indices,
+  ///        honoring any per-index extent override (a runtime slice_mode()/
+  ///        mode_batches() narrowing).
+  ///
+  /// Delegates the extent-product / composite-moment math to \c
+  /// memsize_counter, invoked with \p idxset as the sole (`lhs`) operand and
+  /// empty `rhs`/`result` -- an empty operand's tot_indices() split
+  /// accumulates the starting product of 1.0, which memsize_counter itself
+  /// special-cases to contribute zero bytes, so this reproduces exactly the
+  /// single-operand byte count \c memsize_counter is designed to report per
+  /// operand.
+  ///
+  [[nodiscard]] std::size_t memsize(
+      container::svector<Index> const& idxset,
+      ExtentOverrides const& overrides = {}) const {
+    auto const ext = make_extent_fn(overrides);
+    auto const mc =
+        sequant::opt::detail::memsize_counter(ext, regime_.inner_pow_fn());
+    double const elems =
+        mc(idxset, container::svector<Index>{}, container::svector<Index>{});
+    return static_cast<std::size_t>(elems * numeric_size_);
+  }
+
+  ///
+  /// \brief Multiply-add count for a contraction whose free (result) indices
+  ///        are \p out and whose contracted (summed-over) indices are
+  ///        \p contracted.
+  ///
+  /// Delegates to \c flops_counter, which prices the union of its (lhs, rhs,
+  /// result) arguments; passing (\p out, \p contracted, {}) makes that union
+  /// exactly `out U contracted` -- the full index set touched by the
+  /// contraction, since by construction `contracted` holds precisely the
+  /// indices present in both operands but absent from the result.
+  ///
+  [[nodiscard]] double flops(container::svector<Index> const& out,
+                             container::svector<Index> const& contracted,
+                             ExtentOverrides const& overrides = {}) const {
+    auto const ext = make_extent_fn(overrides);
+    auto const fc =
+        sequant::opt::detail::flops_counter(ext, regime_.inner_pow_fn());
+    return fc(out, contracted, container::svector<Index>{});
+  }
+
+  ///
+  /// \brief Roofline-projected execution cost of one contraction (see
+  ///        \c sequant::opt::detail::roofline_op_cost).
+  ///
+  /// \p left_bytes / \p right_bytes are operand footprints in BYTES (as
+  /// reported by \c Result::size_in_bytes()); converted to elements (the
+  /// counter's native unit) via \c numeric_size before delegating.
+  ///
+  [[nodiscard]] double exec_cost(double flops_count, std::size_t left_bytes,
+                                 std::size_t right_bytes) const {
+    double const traffic_elems =
+        static_cast<double>(left_bytes + right_bytes) / numeric_size_;
+    return sequant::opt::detail::roofline_op_cost(
+        flops_count, traffic_elems, roofline_.machine_balance,
+        roofline_.fast_mem_elems, roofline_.block_tiles,
+        roofline_.block_prefactor);
+  }
+
+  [[nodiscard]] SizeRegime const& regime() const noexcept { return regime_; }
+
+ private:
+  // Index-to-extent callable consulting `overrides` first, else the
+  // regime's nominal extent. The returned std::function captures `overrides`
+  // (and `this`) BY REFERENCE and is only ever used -- never stored --
+  // within the (memsize/flops) call that constructs it, so the reference
+  // stays valid for its entire lifetime. Explicit (non-deduced) return type
+  // so this can be called from memsize()/flops(), which appear earlier in
+  // the class body (a deduced `auto` return type would require the
+  // definition to precede every use, even within the same class).
+  [[nodiscard]] std::function<std::size_t(Index const&)> make_extent_fn(
+      ExtentOverrides const& overrides) const {
+    return [this, &overrides](Index const& ix) -> std::size_t {
+      if (auto it = overrides.find(ix); it != overrides.end())
+        return it->second;
+      return regime_.extent(ix);
+    };
+  }
+
+  SizeRegime regime_;
+  RooflineParams roofline_;
+  // sizeof(double); see doc/dev/plans/2026-07-04-dryrun-eval-backend.md Task 2
+  // note on OptimizeOptions::numeric_size (hardcoded here, matching the C60
+  // trace's real-only CSV-CCk path; complex CSV-CCk is out of scope, see the
+  // plan's carried-minor N4).
+  double numeric_size_ = 8.0;
+};
+
+}  // namespace sequant::eval::dryrun
+
+#endif  // SEQUANT_CORE_EVAL_BACKENDS_DRYRUN_COST_MODEL_OBJECT_HPP
diff --git a/SeQuant/core/eval/backends/dryrun/eval_expr.hpp b/SeQuant/core/eval/backends/dryrun/eval_expr.hpp
new file mode 100644
index 0000000000..a7bcad51f9
--- /dev/null
+++ b/SeQuant/core/eval/backends/dryrun/eval_expr.hpp
@@ -0,0 +1,87 @@
+#ifndef SEQUANT_CORE_EVAL_BACKENDS_DRYRUN_EVAL_EXPR_HPP
+#define SEQUANT_CORE_EVAL_BACKENDS_DRYRUN_EVAL_EXPR_HPP
+
+#include <SeQuant/core/container.hpp>
+#include <SeQuant/core/eval/backends/dryrun/cost_model_object.hpp>
+#include <SeQuant/core/eval/backends/dryrun/result.hpp>
+#include <SeQuant/core/eval/eval_expr.hpp>
+#include <SeQuant/core/index.hpp>
+#include <SeQuant/core/utility/macros.hpp>
+
+#include <range/v3/range/conversion.hpp>
+
+#include <memory>
+#include <type_traits>
+#include <utility>
+
+namespace sequant::eval::dryrun {
+
+///
+/// \brief Extends EvalExpr with an annot() method so DryRun eval nodes can be
+///        evaluated.
+///
+/// Unlike \c EvalExprTAPP (opaque \c int64_t hashes of index labels -- see
+/// \c backends/tapp/eval_expr.hpp), DryRun's annotation IS the plain literal
+/// (canon-order) index list itself: \c Result::prod/sum/permute need each
+/// index's actual space/extent (via \c CostModel), not just its identity, to
+/// compute a modeled size.
+///
+class EvalExprDryRun final : public EvalExpr {
+ public:
+  using annot_t = dryrun::annot_t;  // container::svector<Index>
+
+  template <typename... Args, typename = std::enable_if_t<
+                                  std::is_constructible_v<EvalExpr, Args...>>>
+  explicit EvalExprDryRun(Args&&... args)
+      : EvalExpr{std::forward<Args>(args)...} {
+    annot_ = canon_indices() | ranges::to<annot_t>;
+  }
+
+  ///
+  /// \return Annotation (container::svector<Index>) for DryRun tensors.
+  ///
+  [[nodiscard]] annot_t const& annot() const noexcept { return annot_; }
+
+ private:
+  annot_t annot_;
+};
+
+/// Type alias for DryRun evaluation nodes
+using EvalNodeDryRun = EvalNode<EvalExprDryRun>;
+
+static_assert(meta::eval_node<EvalNodeDryRun>);
+static_assert(meta::can_evaluate<EvalNodeDryRun>);
+
+///
+/// \brief Leaf yielder: turns each IR leaf (a tensor/constant/variable node)
+///        into a zero-data DryRun Result. This is the `F` in
+///        \c evaluate<Trace>(node, layout, F, cache).
+///
+/// A tensor leaf's literal (canon-order) index list decides flat vs nested:
+/// \c make_dryrun_result builds a flat \c ResultDryRun if none of the leaf's
+/// indices are proto-indexed, or a nested \c ResultDryRunNested (a CSV/PNO
+/// amplitude or coefficient) if any are -- and threads that SAME literal list
+/// through as the nested result's canon-order position map, so a later
+/// \c slice_mode()/\c mode_batches() call (which the batched runtime only
+/// ever issues against a LEAF's result) resolves its positional `mode`
+/// argument correctly regardless of the leaf's flat/nested-ness.
+///
+struct DryRunLeafEvaluator {
+  std::shared_ptr<CostModel const> cm;
+
+  [[nodiscard]] ResultPtr operator()(EvalNodeDryRun const& leaf) const {
+    SEQUANT_ASSERT(leaf.leaf());
+    if (!leaf->is_tensor()) {
+      // Constant / Variable leaf: a bare scalar. No real numeric value is
+      // ever tracked by this zero-data backend (only sizes/costs), so 1.0 is
+      // a placeholder never meant to be read as a physical result.
+      return eval_result<ResultScalar<double>>(1.0);
+    }
+    container::svector<Index> idx = leaf->canon_indices() | ranges::to<annot_t>;
+    return make_dryrun_result(std::move(idx), cm);
+  }
+};
+
+}  // namespace sequant::eval::dryrun
+
+#endif  // SEQUANT_CORE_EVAL_BACKENDS_DRYRUN_EVAL_EXPR_HPP
diff --git a/SeQuant/core/eval/backends/dryrun/result.hpp b/SeQuant/core/eval/backends/dryrun/result.hpp
new file mode 100644
index 0000000000..25b3aac8ff
--- /dev/null
+++ b/SeQuant/core/eval/backends/dryrun/result.hpp
@@ -0,0 +1,427 @@
+#ifndef SEQUANT_CORE_EVAL_BACKENDS_DRYRUN_RESULT_HPP
+#define SEQUANT_CORE_EVAL_BACKENDS_DRYRUN_RESULT_HPP
+
+#include <SeQuant/core/container.hpp>
+#include <SeQuant/core/eval/backends/dryrun/cost_model_object.hpp>
+#include <SeQuant/core/eval/result.hpp>
+#include <SeQuant/core/index.hpp>
+#include <SeQuant/core/utility/macros.hpp>
+
+#include <algorithm>
+#include <any>
+#include <array>
+#include <cstddef>
+#include <memory>
+#include <utility>
+
+namespace sequant::eval::dryrun {
+
+///
+/// \brief Annotation type DryRun's Result ops decode from the eval engine's
+///        std::any [l,r,res] / [pre,post] triples/pairs.
+///
+/// Unlike \c EvalExprTAPP (opaque \c int64_t index-label hashes -- see
+/// \c backends/tapp/eval_expr.hpp), DryRun's annotation IS the plain literal
+/// (canon-order) index list itself: \c Result::prod/sum/permute need each
+/// index's actual space/extent (via \c CostModel), not just an opaque
+/// identity, to compute a modeled size.
+///
+using annot_t = container::svector<Index>;
+
+class ResultDryRun;
+class ResultDryRunNested;
+
+///
+/// \brief Builds whichever concrete DryRun Result type matches \p idx's
+///        content: a nested \c ResultDryRunNested if any index in \p idx is
+///        proto-indexed (a CSV/PNO composite leg, e.g. a CSV amplitude's PNO
+///        domain leg `a_1<i_1,i_2>`), otherwise a flat \c ResultDryRun.
+///
+/// Dispatch is by CONTENT of the decoded result annotation, not by either
+/// operand's concrete type -- exactly mirroring how the real eval engine
+/// itself decides tensor-of-tensor-ness (\c EvalExpr::tot(), from the same
+/// proto-indexed-leg criterion). This is what lets \c prod()/sum() freely
+/// combine a flat operand (e.g. a bare 3-center DF integral) with a nested
+/// one (e.g. a CSV/PNO coefficient), exactly as real CSV-CCSD terms do,
+/// without either side needing to know the other's concrete type.
+///
+[[nodiscard]] inline ResultPtr make_dryrun_result(
+    container::svector<Index> idx, std::shared_ptr<CostModel const> cm,
+    ExtentOverrides overrides = {});
+
+namespace detail {
+
+[[nodiscard]] inline bool has_proto(container::svector<Index> const& idx) {
+  return std::any_of(idx.begin(), idx.end(),
+                     [](Index const& ix) { return ix.has_proto_indices(); });
+}
+
+[[nodiscard]] inline ExtentOverrides merge_overrides(ExtentOverrides const& a,
+                                                     ExtentOverrides const& b) {
+  ExtentOverrides out = a;
+  for (auto const& [ix, n] : b) out[ix] = n;
+  return out;
+}
+
+// Uniform read access to a DryRun Result's (index list, overrides, cost
+// model) regardless of which concrete DryRun type `r` is. `is<T>()`/`as<T>()`
+// are public Result methods, so no friendship is needed; declared here (and
+// defined below, after both concrete classes) purely because their bodies
+// need the concrete classes' definitions.
+[[nodiscard]] container::svector<Index> indices_of(Result const& r);
+[[nodiscard]] ExtentOverrides overrides_of(Result const& r);
+
+///
+/// \brief Shared op bodies for the two DryRun Result concrete types.
+///
+/// Both \c ResultDryRun and \c ResultDryRunNested carry exactly an (index
+/// list, ExtentOverrides, CostModel) triple and differ only in what they
+/// additionally expose (\c ResultDryRunNested splits its index list into
+/// outer()/inner() views for CSV-composite-aware inspection/testing).
+/// Implemented once here so the two classes' prod/sum/permute/slice_mode/
+/// mode_batches bodies are one-line forwards, not near-duplicated logic.
+///
+struct DryRunOps {
+  [[nodiscard]] static ResultPtr sum(container::svector<Index> const& idx,
+                                     ExtentOverrides const& ov,
+                                     std::shared_ptr<CostModel const> const& cm,
+                                     Result const& other,
+                                     std::array<std::any, 3> const& annot) {
+    auto const a = Annot<annot_t>{annot};
+    auto merged = merge_overrides(ov, overrides_of(other));
+    return make_dryrun_result(
+        container::svector<Index>(a.this_annot.begin(), a.this_annot.end()), cm,
+        std::move(merged));
+  }
+
+  [[nodiscard]] static ResultPtr prod(
+      container::svector<Index> const& idx, ExtentOverrides const& ov,
+      std::shared_ptr<CostModel const> const& cm, Result const& other,
+      std::array<std::any, 3> const& annot) {
+    if (other.is<ResultScalar<double>>()) {
+      // Scalar * tensor: shape (and any accumulated slicing) unchanged.
+      return make_dryrun_result(idx, cm, ov);
+    }
+    auto const a = Annot<annot_t>{annot};
+    auto merged = merge_overrides(ov, overrides_of(other));
+    if (a.this_annot.empty()) {
+      // Full contraction -> scalar. No real numeric value is ever tracked by
+      // this zero-data backend (only sizes/costs), so the placeholder 0.0
+      // is never meant to be read as a physical result.
+      return eval_result<ResultScalar<double>>(0.0);
+    }
+    return make_dryrun_result(
+        container::svector<Index>(a.this_annot.begin(), a.this_annot.end()), cm,
+        std::move(merged));
+  }
+
+  [[nodiscard]] static ResultPtr permute(
+      container::svector<Index> const& /*idx*/, ExtentOverrides const& ov,
+      std::shared_ptr<CostModel const> const& cm,
+      std::array<std::any, 2> const& ann) {
+    auto const post = std::any_cast<annot_t>(ann[1]);
+    return make_dryrun_result(
+        container::svector<Index>(post.begin(), post.end()), cm, ov);
+  }
+
+  [[nodiscard]] static ResultPtr slice_mode(
+      container::svector<Index> const& idx, ExtentOverrides const& ov,
+      std::shared_ptr<CostModel const> const& cm, std::size_t mode,
+      std::size_t elem_lo, std::size_t elem_hi) {
+    SEQUANT_ASSERT(mode < idx.size());
+    auto merged = ov;
+    merged[idx[mode]] = elem_hi - elem_lo;
+    return make_dryrun_result(idx, cm, std::move(merged));
+  }
+
+  [[nodiscard]] static container::svector<std::pair<std::size_t, std::size_t>>
+  mode_batches(container::svector<Index> const& idx, ExtentOverrides const& ov,
+               std::shared_ptr<CostModel const> const& cm, std::size_t mode,
+               std::size_t target_batch_size) {
+    SEQUANT_ASSERT(mode < idx.size());
+    Index const& ix = idx[mode];
+    std::size_t extent;
+    if (auto it = ov.find(ix); it != ov.end())
+      extent = it->second;
+    else
+      extent = cm->regime().extent(ix);
+
+    container::svector<std::pair<std::size_t, std::size_t>> out;
+    if (target_batch_size == 0 || extent == 0) {
+      out.push_back({0, extent});
+      return out;
+    }
+    for (std::size_t lo = 0; lo < extent; lo += target_batch_size)
+      out.push_back({lo, std::min(extent, lo + target_batch_size)});
+    return out;
+  }
+};
+
+}  // namespace detail
+
+///
+/// \brief Flat (non-CSV) zero-data tensor token.
+///
+/// Carries only its own literal outer index list (canon order -- the same
+/// order \c EvalExpr::canon_indices()/annot() use, so \c slice_mode()/
+/// \c mode_batches()'s positional `mode` argument indexes it correctly), an
+/// \c ExtentOverrides table recording any runtime \c slice_mode()/
+/// \c mode_batches() narrowing (keyed by Index so it survives reshaping
+/// across prod/sum/permute), and a shared \c CostModel. No tensor data is
+/// ever allocated or copied; every op is index-set bookkeeping plus a
+/// CostModel query. Mirrors \c ResultTensorTAPP's structure
+/// (backends/tapp/result.hpp) with every real-tensor line replaced by that
+/// bookkeeping.
+///
+class ResultDryRun final : public Result {
+ public:
+  using Result::id_t;
+
+  ResultDryRun(container::svector<Index> idxset,
+               std::shared_ptr<CostModel const> cm,
+               ExtentOverrides overrides = {})
+      : Result{Payload{}},
+        indices_{std::move(idxset)},
+        cm_{std::move(cm)},
+        overrides_{std::move(overrides)} {}
+
+  [[nodiscard]] container::svector<Index> const& indices() const noexcept {
+    return indices_;
+  }
+  [[nodiscard]] ExtentOverrides const& overrides() const noexcept {
+    return overrides_;
+  }
+
+ private:
+  struct Payload {};
+
+  [[nodiscard]] id_t type_id() const noexcept override {
+    return id_for_type<ResultDryRun>();
+  }
+
+  [[nodiscard]] ResultPtr sum(
+      Result const& other,
+      std::array<std::any, 3> const& annot) const override {
+    return detail::DryRunOps::sum(indices_, overrides_, cm_, other, annot);
+  }
+
+  [[nodiscard]] ResultPtr prod(Result const& other,
+                               std::array<std::any, 3> const& annot,
+                               DeNest /*DeNestFlag*/) const override {
+    return detail::DryRunOps::prod(indices_, overrides_, cm_, other, annot);
+  }
+
+  [[nodiscard]] ResultPtr permute(
+      std::array<std::any, 2> const& ann) const override {
+    return detail::DryRunOps::permute(indices_, overrides_, cm_, ann);
+  }
+
+  [[nodiscard]] ResultPtr adjoint(
+      std::array<std::any, 2> const& ann) const override {
+    return detail::DryRunOps::permute(indices_, overrides_, cm_, ann);
+  }
+
+  [[nodiscard]] ResultPtr slice_mode(std::size_t mode, std::size_t elem_lo,
+                                     std::size_t elem_hi) const override {
+    return detail::DryRunOps::slice_mode(indices_, overrides_, cm_, mode,
+                                         elem_lo, elem_hi);
+  }
+
+  [[nodiscard]] container::svector<std::pair<std::size_t, std::size_t>>
+  mode_batches(std::size_t mode, std::size_t target_batch_size) const override {
+    return detail::DryRunOps::mode_batches(indices_, overrides_, cm_, mode,
+                                           target_batch_size);
+  }
+
+  void add_inplace(Result const& other) override {
+    SEQUANT_ASSERT(other.is<ResultDryRun>() || other.is<ResultDryRunNested>());
+    overrides_ =
+        detail::merge_overrides(overrides_, detail::overrides_of(other));
+  }
+
+  [[nodiscard]] ResultPtr symmetrize() const override {
+    return eval_result<ResultDryRun>(indices_, cm_, overrides_);
+  }
+
+  [[nodiscard]] ResultPtr antisymmetrize(size_t /*bra_rank*/) const override {
+    return eval_result<ResultDryRun>(indices_, cm_, overrides_);
+  }
+
+  [[nodiscard]] ResultPtr mult_by_phase(std::int8_t /*factor*/) const override {
+    return eval_result<ResultDryRun>(indices_, cm_, overrides_);
+  }
+
+  [[nodiscard]] std::size_t size_in_bytes() const final {
+    return cm_->memsize(indices_, overrides_);
+  }
+
+  container::svector<Index> indices_;
+  std::shared_ptr<CostModel const> cm_;
+  ExtentOverrides overrides_;
+};
+
+///
+/// \brief CSV/PNO tensor-of-tensor zero-data token.
+///
+/// Like \c ResultDryRun, but additionally exposes an outer()/inner() split of
+/// its (canon-order) index list -- inner = the proto-indexed (composite)
+/// legs, e.g. a CSV amplitude's PNO domain leg `a_1<i_1,i_2>`; outer = every
+/// other (plain) leg, e.g. the PAO index `mu~_1`. The split is purely an
+/// observability/testing convenience: \c size_in_bytes()'s arithmetic is
+/// IDENTICAL to \c ResultDryRun's (\c CostModel::memsize already routes any
+/// index list containing a proto-indexed entry through the moment-aware
+/// `inner_pow` path internally, via \c tot_indices/inner_aware_volume --
+/// content-driven, not type-driven), so tests that want to confirm "this used
+/// the k-th moment, not extent^k" can inspect inner() directly.
+///
+/// Position semantics for \c slice_mode()/\c mode_batches(): the `mode`
+/// argument the runtime passes is always resolved against the FULL
+/// canon-order list (an optional trailing constructor argument, defaulting to
+/// `outer ++ inner` when the caller does not need position accuracy, e.g. a
+/// hand-built test instance); the \c DryRunLeafEvaluator (eval_expr.hpp)
+/// always supplies the leaf's true \c canon_indices() order there, since only
+/// LEAF-constructed instances are ever sliced by the runtime (\c slice_mode()
+/// is invoked only inside the batched evaluator's leaf-wrapping closure, never
+/// on a prod()/sum()-produced intermediate).
+///
+class ResultDryRunNested final : public Result {
+ public:
+  using Result::id_t;
+
+  ResultDryRunNested(container::svector<Index> outer,
+                     container::svector<Index> inner,
+                     std::shared_ptr<CostModel const> cm,
+                     ExtentOverrides overrides = {},
+                     container::svector<Index> canon_order = {})
+      : Result{Payload{}},
+        outer_{std::move(outer)},
+        inner_{std::move(inner)},
+        indices_{canon_order.empty()
+                     ? [this] {
+                         container::svector<Index> c = outer_;
+                         c.insert(c.end(), inner_.begin(), inner_.end());
+                         return c;
+                       }()
+                     : std::move(canon_order)},
+        cm_{std::move(cm)},
+        overrides_{std::move(overrides)} {}
+
+  [[nodiscard]] container::svector<Index> const& outer() const noexcept {
+    return outer_;
+  }
+  [[nodiscard]] container::svector<Index> const& inner() const noexcept {
+    return inner_;
+  }
+  [[nodiscard]] container::svector<Index> const& indices() const noexcept {
+    return indices_;
+  }
+  [[nodiscard]] ExtentOverrides const& overrides() const noexcept {
+    return overrides_;
+  }
+
+ private:
+  struct Payload {};
+
+  [[nodiscard]] id_t type_id() const noexcept override {
+    return id_for_type<ResultDryRunNested>();
+  }
+
+  [[nodiscard]] ResultPtr sum(
+      Result const& other,
+      std::array<std::any, 3> const& annot) const override {
+    return detail::DryRunOps::sum(indices_, overrides_, cm_, other, annot);
+  }
+
+  [[nodiscard]] ResultPtr prod(Result const& other,
+                               std::array<std::any, 3> const& annot,
+                               DeNest /*DeNestFlag*/) const override {
+    return detail::DryRunOps::prod(indices_, overrides_, cm_, other, annot);
+  }
+
+  [[nodiscard]] ResultPtr permute(
+      std::array<std::any, 2> const& ann) const override {
+    return detail::DryRunOps::permute(indices_, overrides_, cm_, ann);
+  }
+
+  [[nodiscard]] ResultPtr adjoint(
+      std::array<std::any, 2> const& ann) const override {
+    return detail::DryRunOps::permute(indices_, overrides_, cm_, ann);
+  }
+
+  [[nodiscard]] ResultPtr slice_mode(std::size_t mode, std::size_t elem_lo,
+                                     std::size_t elem_hi) const override {
+    return detail::DryRunOps::slice_mode(indices_, overrides_, cm_, mode,
+                                         elem_lo, elem_hi);
+  }
+
+  [[nodiscard]] container::svector<std::pair<std::size_t, std::size_t>>
+  mode_batches(std::size_t mode, std::size_t target_batch_size) const override {
+    return detail::DryRunOps::mode_batches(indices_, overrides_, cm_, mode,
+                                           target_batch_size);
+  }
+
+  void add_inplace(Result const& other) override {
+    SEQUANT_ASSERT(other.is<ResultDryRun>() || other.is<ResultDryRunNested>());
+    overrides_ =
+        detail::merge_overrides(overrides_, detail::overrides_of(other));
+  }
+
+  [[nodiscard]] ResultPtr symmetrize() const override {
+    return eval_result<ResultDryRunNested>(outer_, inner_, cm_, overrides_,
+                                           indices_);
+  }
+
+  [[nodiscard]] ResultPtr antisymmetrize(size_t /*bra_rank*/) const override {
+    return eval_result<ResultDryRunNested>(outer_, inner_, cm_, overrides_,
+                                           indices_);
+  }
+
+  [[nodiscard]] ResultPtr mult_by_phase(std::int8_t /*factor*/) const override {
+    return eval_result<ResultDryRunNested>(outer_, inner_, cm_, overrides_,
+                                           indices_);
+  }
+
+  [[nodiscard]] std::size_t size_in_bytes() const final {
+    return cm_->memsize(indices_, overrides_);
+  }
+
+  container::svector<Index> outer_;
+  container::svector<Index> inner_;
+  container::svector<Index> indices_;  // canon order; outer_++inner_ content
+  std::shared_ptr<CostModel const> cm_;
+  ExtentOverrides overrides_;
+};
+
+[[nodiscard]] inline ResultPtr make_dryrun_result(
+    container::svector<Index> idx, std::shared_ptr<CostModel const> cm,
+    ExtentOverrides overrides) {
+  if (!detail::has_proto(idx))
+    return eval_result<ResultDryRun>(std::move(idx), std::move(cm),
+                                     std::move(overrides));
+  container::svector<Index> outer, inner;
+  for (auto const& ix : idx)
+    (ix.has_proto_indices() ? inner : outer).push_back(ix);
+  return eval_result<ResultDryRunNested>(std::move(outer), std::move(inner),
+                                         std::move(cm), std::move(overrides),
+                                         std::move(idx));
+}
+
+namespace detail {
+
+[[nodiscard]] inline container::svector<Index> indices_of(Result const& r) {
+  if (r.is<ResultDryRun>()) return r.as<ResultDryRun>().indices();
+  SEQUANT_ASSERT(r.is<ResultDryRunNested>());
+  return r.as<ResultDryRunNested>().indices();
+}
+
+[[nodiscard]] inline ExtentOverrides overrides_of(Result const& r) {
+  if (r.is<ResultDryRun>()) return r.as<ResultDryRun>().overrides();
+  SEQUANT_ASSERT(r.is<ResultDryRunNested>());
+  return r.as<ResultDryRunNested>().overrides();
+}
+
+}  // namespace detail
+
+}  // namespace sequant::eval::dryrun
+
+#endif  // SEQUANT_CORE_EVAL_BACKENDS_DRYRUN_RESULT_HPP
diff --git a/doc/dev/plans/2026-07-04-dryrun-eval-backend.md b/doc/dev/plans/2026-07-04-dryrun-eval-backend.md
new file mode 100644
index 0000000000..bbfb925902
--- /dev/null
+++ b/doc/dev/plans/2026-07-04-dryrun-eval-backend.md
@@ -0,0 +1,844 @@
+# DryRun eval backend and PNO-CCSD cost harness Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Add a "DryRun" SeQuant eval backend that replays a factorized IR over the real `CacheManager` and, for each evaluation, reports what the optimizer's own cost model reports (memsize, FLOPs, projected execution cost) so PNO-CCSD schedules can be exercised at arbitrary size regimes in seconds without building or running MPQC.
+
+**Architecture:** The DryRun backend implements the abstract `Result` interface with tensors carrying no data, only an index set plus a regime-driven extent/moment model. Each `Result` operation (`prod`/`sum`/`permute`/`slice_mode`/`mode_batches`/`add_inplace`) produces a new zero-data `Result` whose `size_in_bytes()` delegates to a shared `CostModel` object built from the optimizer's `memsize_counter`/`flops_counter`/`roofline_op_cost`. A Catch2 harness deserializes the committed CSV-CCSD residual, runs the real optimize -> binarize -> `make_batched_custom_evaluator` -> `evaluate` pipeline against this backend under a chosen `SizeRegime`, and prints a per-operation cost table plus the realized `CacheManager` working-set high-water mark.
+
+**Tech Stack:** C++20, SeQuant core (`io::serialization`, `core/optimize`, `core/eval`), Catch2 v3 unit tests, CMake + Unix Makefiles (existing `build-test` dir).
+
+## Global Constraints
+
+- ASCII only in all source, tests, and docs: no en-dashes (U+2013), no non-breaking spaces (U+00A0). The SeQuant pre-commit hook rejects them. Use plain hyphens.
+- No `Co-Authored-By` trailers in commit messages. Plain messages describing the change.
+- Docs (this plan, the spec) live under `doc/dev/{plans,specs}/`, not `docs/superpowers/`.
+- The DryRun backend carries NO tensor data. Every `Result` in it is a pure size/cost token. Any allocation proportional to the modeled extent is a defect.
+- Extents are rank-dependent and moment-dependent: `<#OSV> != <#PNO>` and `<#PNO^k> != <#PNO>^k`. The size model MUST route CSV (proto-indexed) inner extents through the moment-aware path (`inner_pow(index, k)`), not a scalar average. Support moments `k <= 4` (sufficient for a 2-body Hamiltonian).
+- The size model is the optimizer's existing model, reused verbatim: `memsize_counter`, `flops_counter`, `roofline_op_cost` from `core/optimize`. Do NOT reimplement a parallel cost model in the backend.
+- Reference backend to mirror for `Result` mechanics: `SeQuant/core/eval/backends/tapp/{result.hpp,eval_expr.hpp}`. Mirror its structure (final class deriving `Result`, `type_id()`, annotation unpacking from `std::array<std::any,N>`), and strip everything that touches real tensor storage.
+- **Build harness:** use the **Release** build at `SeQuant/cmake-build-release` (CMake + Ninja). Build with `cmake --build cmake-build-release --target unit_tests-sequant -j8`. Run with `./cmake-build-release/tests/unit/unit_tests-sequant "[tag]"`. **Release is mandatory:** the batched single-term DP (`DensePeakSizeBatched`) is exponential in the number of batchable indices and takes 20-60 s per giant term in Release; in the `build-test` Debug build it is minutes-to-hung. Do NOT use `build-test` for anything touching `optimize()`.
+- **Post-transform fixtures + mu~/K registration (VERDICT ALREADY OBTAINED):** the real factorizer-input residual is `tests/unit/data/csv_ccsd_doubles_residual_df.txt` (55-summand Sum; contains PAO `μ̃`, DF-aux `Κ`, 3-center DF `g{μ̃;i;Κ}`, CSV coeffs `C{a<i>;μ̃}`; the giant free-mu~ term is the first ~13-tensor summand). Standalone SeQuant's default registry lacks `μ̃`/`Κ`; register them by cloning the default context, `set_first_dummy_index_ordinal(1000000)`, `auto isr = ctx.mutable_index_space_registry(); sequant::mbpt::add_pao_spaces(isr); sequant::mbpt::add_df_spaces(isr);` then `set_scoped_default_context(std::move(ctx))`. The `[dryrun-df]` verdict case already PROVED the DP annotates a **μ̃** batch axis on the 188 GB (K=4320: 1210 GB) free-mu~ giant (`batch_axes={μ̃}`, K on outer nodes only) and that it survives `binarize`. So the eval backend's job is NOT to re-decide that -- it is to REPLAY the giant term's schedule through the runtime (`make_batched_custom_evaluator`) and witness that the runtime applies the OUTER K slice but DROPS the giant's nested μ̃ slice (giant K-sliced, μ~-full -> 186 GB/K-batch -> the OOM). That is the C60 runtime bug; the backend reproduces it locally.
+- **Interface traps (from the [dryrun-df] work, reuse verbatim):** (a) after deserialize, re-flatten each summand `ex<Product>(p.scalar(), p.factors(), Product::Flatten::Yes)` before `optimize()` or `term_batch_axes` comes back empty; (b) `set_first_dummy_index_ordinal(1000000)` (mpqc ordinals reach tens of thousands); (c) never pass a raw `ExprPtr`/`Product` to `REQUIRE`/`CHECK` (Catch2 stringification hits a `Product` hash-cache assert -- capture `static_cast<bool>(expr)` into a `bool` first); (d) `memsize_counter` lives in `sequant::opt::detail` and returns an ELEMENT count (multiply by 8 for bytes); (e) `OptimizeOptions` batchability nests under `opts.batch_policy.{is_batchable_index,batch_target_size,peak_threshold}`; `term_batch_axes` is a caller-allocated `std::shared_ptr<std::unordered_map<Expr const*, container::vector<container::svector<Index>>>>`; read back via `->find(optimized_summand.get())`; optimize PER SUMMAND, not the whole Sum. The SAME `BatchPolicy` object must be passed to `optimize()` and to the runtime evaluator factory (`sequant::make_evaluator`/`make_batched_custom_evaluator`) so they cannot drift (see mpqc `SeQuantEngine::make_optimize_options`).
+- **Focus the replay on the giant term only.** Do NOT sweep all 55 summands (20-60 s each). Deserialize, take the giant summand (the first, ~13-tensor `g·C·g·C·s·C·C·s·C·C·t·t·t` term), optimize it once at `{μ̃,Κ}` batchable / `peak_threshold=40e9` / regime {i=32, μ̃=1800, Κ=4320, PNO=19, OSV=57}, binarize, and replay THAT tree.
+- **Test registration:** the DryRun test needs both `SeQuant::eval` (for `make_batched_custom_evaluator`, `CacheManager`, `Result`) and `SeQuant::optimize` (for `optimize`, `OptimizeOptions`, `memsize_counter`). Register it as its own OBJECT-library group (see Task 1 Step 3), NOT by appending to an existing source list -- the existing groups link only one sub-library each.
+- Validation anchors (C60 pVDZ-F12 PNO-CCSD, from trace `614336.log`): the aux-batched giant `g(mu~,mu~,K)` reports `result=1867538944` bytes (~1.87 GB) per aux batch; the un-sliced free-mu~ intermediate `I(i_3,i_2,mu~_1241,K_2;a_3i_2i_3)` reports `pred_result=185979871872` bytes (~186 GB). The CostModel `memsize` for these two nodes MUST reproduce those numbers (within a few percent) before any Phase 1 verdict or Phase 3 report is trusted.
+
+---
+
+## File structure
+
+New backend (header-only, mirrors `backends/tapp/`):
+
+- `SeQuant/core/eval/backends/dryrun/cost_model_object.hpp` -- `CostModel` value type bundling `memsize`/`flops`/`exec_cost` closures built from a `SizeRegime`; owns the `idxsz` and `inner_pow` callbacks.
+- `SeQuant/core/eval/backends/dryrun/size_regime.hpp` -- `SizeRegime` struct (per-space extents + per-rank CSV moment table) and the `idx_to_extent` / `inner_pow` callbacks it produces.
+- `SeQuant/core/eval/backends/dryrun/result.hpp` -- `ResultDryRun` (flat) and `ResultDryRunNested` (ToT), both `final : public Result`.
+- `SeQuant/core/eval/backends/dryrun/eval_expr.hpp` -- `EvalExprDryRun`/`EvalNodeDryRun` alias plus the leaf yielder functor `DryRunLeafEvaluator`.
+
+New tests + fixture:
+
+- `SeQuant/tests/unit/test_eval_dryrun.cpp` -- all Catch2 cases below.
+- `SeQuant/tests/unit/data/csv_ccsd_residual.txt` -- the committed residual fixture (copied from mpqc4 `csv_eqn_Rs.serialized`).
+
+Modified:
+
+- `SeQuant/tests/unit/CMakeLists.txt` -- register `test_eval_dryrun.cpp`.
+
+Each file has one responsibility: `size_regime` = "what extents does this regime imply", `cost_model_object` = "what does the optimizer's model report for a given index set", `result` = "a zero-data tensor token that reshapes under ops and asks the cost model for its size", `eval_expr` = "turn IR leaves into tokens".
+
+---
+
+## Task 1: DP-annotation probe (Phase 1 go/no-go)
+
+The highest-value task: reproduce the C60 batch-axis decision locally and answer whether the free-mu~ giant fails to get a mu~ slice because the **cost model / threshold** never annotated it, or because the **runtime** dropped an annotation the model produced. This task builds only the `SizeRegime` + a thin `memsize` check -- NOT the full backend -- and inspects the optimizer's per-node batch axes directly.
+
+**Files:**
+- Create: `SeQuant/core/eval/backends/dryrun/size_regime.hpp`
+- Create: `SeQuant/tests/unit/data/csv_ccsd_residual.txt`
+- Create (probe test only): `SeQuant/tests/unit/test_eval_dryrun.cpp`
+- Modify: `SeQuant/tests/unit/CMakeLists.txt`
+
+**Interfaces:**
+- Consumes: `sequant::deserialize<ExprPtr>(std::string_view)` from `SeQuant/core/io/shorthands.hpp`; the `single_term_opt` ExprPtr overload and `OptimizeOptions` from `SeQuant/core/optimize/`.
+- Produces:
+  - `struct SizeRegime` in namespace `sequant::eval::dryrun` with fields:
+    - `std::map<std::wstring, std::size_t> space_extent;` -- key = `Index::space().base_key()` (e.g. `L"i"`, `L"a"`, `L"mu~"`, `L"K"`), value = number of elements in that space.
+    - `std::array<double, 5> csv_pno_moment;` and `std::array<double, 5> csv_osv_moment;` -- `csv_pno_moment[k]` = `<#PNO^k>` averaged over occ pairs, `k` in `0..4`; `csv_osv_moment[k]` = `<#OSV^k>` over occ singles. Index 0 is unused (set 1.0).
+  - `std::size_t SizeRegime::extent(Index const&) const;` -- returns `space_extent.at(base_key)`; throws `std::out_of_range` if the space is unknown (fail loud, do not default to 1).
+  - `double SizeRegime::inner_pow(Index const& composite, std::size_t k) const;` -- for a proto-indexed CSV index, returns the moment `<#X^k>` for its rank (PNO if the composite spans an occ pair, OSV if a single); `k` clamped to `0..4`. For a non-composite index returns `std::pow(extent(composite), double(k))`. (Rank detection: number of `composite.proto_indices()` -- 2 protos => PNO pair moment, 1 proto => OSV moment. Confirm against `average_csv_extent_pow` in `single_term_detail.hpp`.)
+  - `auto SizeRegime::idx_to_extent() const;` -- returns `std::function<std::size_t(Index const&)>` = `[this](Index const& ix){ return extent(ix); }`.
+  - `auto SizeRegime::inner_pow_fn() const;` -- returns `std::function<double(Index const&, std::size_t)>` = `[this](Index const& ix, std::size_t k){ return inner_pow(ix, k); }`.
+
+- [ ] **Step 1: Copy the residual fixture**
+
+Copy mpqc4's committed residual into the test data dir (it is the exact IR the C60 run factorizes):
+
+```bash
+cp /Users/efv/code/mpqc4/csv_eqn_Rs.serialized \
+   /Users/efv/code/SeQuant/tests/unit/data/csv_ccsd_residual.txt
+head -c 200 /Users/efv/code/SeQuant/tests/unit/data/csv_ccsd_residual.txt
+```
+
+Expected: prints the leading `2 ((g{i_1,i_2;a_...` text. If the file is not present in mpqc4, regenerate it by running any CSV-CCk input with the residual-dump enabled, or ask the human for the artifact.
+
+- [ ] **Step 2: Write `size_regime.hpp`**
+
+```cpp
+#ifndef SEQUANT_CORE_EVAL_BACKENDS_DRYRUN_SIZE_REGIME_HPP
+#define SEQUANT_CORE_EVAL_BACKENDS_DRYRUN_SIZE_REGIME_HPP
+
+#include <SeQuant/core/index.hpp>
+
+#include <array>
+#include <cmath>
+#include <cstddef>
+#include <functional>
+#include <map>
+#include <string>
+
+namespace sequant::eval::dryrun {
+
+/// Per-space extents and per-rank CSV moment tables that define one size
+/// regime for a dry-run replay. Extents are element counts; CSV moments are
+/// power means over occupied pairs (PNO) or singles (OSV).
+struct SizeRegime {
+  std::map<std::wstring, std::size_t> space_extent;
+  std::array<double, 5> csv_pno_moment{1.0, 1.0, 1.0, 1.0, 1.0};
+  std::array<double, 5> csv_osv_moment{1.0, 1.0, 1.0, 1.0, 1.0};
+
+  [[nodiscard]] std::size_t extent(Index const& ix) const {
+    return space_extent.at(std::wstring{ix.space().base_key()});
+  }
+
+  [[nodiscard]] double inner_pow(Index const& composite,
+                                 std::size_t k) const {
+    if (k > 4) k = 4;
+    auto const& protos = composite.proto_indices();
+    if (protos.empty())
+      return std::pow(static_cast<double>(extent(composite)),
+                      static_cast<double>(k));
+    return (protos.size() >= 2) ? csv_pno_moment[k] : csv_osv_moment[k];
+  }
+
+  [[nodiscard]] std::function<std::size_t(Index const&)> idx_to_extent()
+      const {
+    return [this](Index const& ix) { return extent(ix); };
+  }
+
+  [[nodiscard]] std::function<double(Index const&, std::size_t)> inner_pow_fn()
+      const {
+    return [this](Index const& ix, std::size_t k) { return inner_pow(ix, k); };
+  }
+};
+
+}  // namespace sequant::eval::dryrun
+
+#endif  // SEQUANT_CORE_EVAL_BACKENDS_DRYRUN_SIZE_REGIME_HPP
+```
+
+- [ ] **Step 3: Register the test as its own OBJECT-library group in CMake**
+
+The DryRun test uses both `SeQuant::eval` and `SeQuant::optimize`; existing groups link only one sub-library each, so add a dedicated group. In `SeQuant/tests/unit/CMakeLists.txt`, after the TAPP backend block (ends near line 156, `endif()`), insert:
+
+```cmake
+##########################
+# OBJECT library: DryRun backend tests
+##########################
+set(eval_dryrun_test_sources "test_eval_dryrun.cpp")
+add_library(unit_tests-sequant-eval-dryrun-obj OBJECT ${eval_dryrun_test_sources})
+set_target_properties(unit_tests-sequant-eval-dryrun-obj PROPERTIES CXX_SCAN_FOR_MODULES OFF)
+target_link_libraries(unit_tests-sequant-eval-dryrun-obj
+    PUBLIC SeQuant::eval SeQuant::optimize SeQuant::bliss SeQuant::mbpt
+    PRIVATE Catch2::Catch2 dtl::dtl)
+target_compile_definitions(unit_tests-sequant-eval-dryrun-obj PRIVATE
+    SEQUANT_UNIT_TESTS_SOURCE_DIR="${CMAKE_CURRENT_SOURCE_DIR}")
+```
+
+Then add it to the combined executable's link list (the `target_link_libraries(unit_tests-sequant PRIVATE ...)` block near line 168), alongside `unit_tests-sequant-optimize-obj`:
+
+```cmake
+    unit_tests-sequant-eval-dryrun-obj
+```
+
+(`SeQuant::mbpt` is required so `deserialize` resolves the standard space registry, matching the tapp/ta/btas test groups; `SeQuant::bliss` matches the optimize group.)
+
+- [ ] **Step 4: Write the probe test (expected to FAIL to build first, then RUN)**
+
+Create `SeQuant/tests/unit/test_eval_dryrun.cpp`. This first case only exercises `SizeRegime` + the optimizer's batch-axis output. The C60 regime numbers below are the anchors; the moment tables come from the C60 CC-average PNO domain (avg PNO ~58, so use a representative geometric spread -- start from the flat approximation `moment[k] = avg^k` and refine in Step 6 if the memsize check misses the anchor).
+
+```cpp
+#include <SeQuant/core/eval/backends/dryrun/size_regime.hpp>
+#include <SeQuant/core/io/shorthands.hpp>
+#include <SeQuant/core/optimize/optimize.hpp>
+#include <SeQuant/core/optimize/options.hpp>
+
+#include <catch2/catch_test_macros.hpp>
+
+#include <fstream>
+#include <sstream>
+
+using namespace sequant;
+using sequant::eval::dryrun::SizeRegime;
+
+namespace {
+
+std::string slurp(std::string const& path) {
+  std::ifstream in(path);
+  std::stringstream ss;
+  ss << in.rdbuf();
+  return ss.str();
+}
+
+// C60 pVDZ-F12 PNO-CCSD regime (from trace 614336.log).
+SizeRegime c60_regime() {
+  SizeRegime r;
+  r.space_extent = {
+      {L"i", 120},      // occupied (60 C atoms, pVDZ-F12) -- CONFIRM from log
+      {L"a", 0},        // canonical virtual unused in CSV path
+      {L"mu~", 1800},   // PAO domain per union (nnz_tiles=1800 in log)
+      {L"K", 0},        // DF aux -- CONFIRM extent from log
+  };
+  // CC-average PNO ~58; OSV ~ smaller. Placeholder power-mean; refined in Step 6.
+  double const pno = 58.0, osv = 20.0;
+  for (std::size_t k = 0; k <= 4; ++k) {
+    r.csv_pno_moment[k] = std::pow(pno, double(k));
+    r.csv_osv_moment[k] = std::pow(osv, double(k));
+  }
+  return r;
+}
+
+}  // namespace
+
+TEST_CASE("dryrun size regime basic extents", "[dryrun-probe]") {
+  auto r = c60_regime();
+  // A bare occ index resolves to its space extent.
+  auto i = Index{L"i_1"};
+  CHECK(r.extent(i) == 120);
+  // A composite (proto-indexed) PAO index still resolves by base space.
+  // (moment routing is exercised in the memsize task)
+}
+
+TEST_CASE("dryrun DP annotates mu~ on the free-mu~ giant", "[dryrun-probe]") {
+  auto const residual = slurp(
+      std::string(SEQUANT_UNIT_TESTS_SOURCE_DIR) +
+      "/data/csv_ccsd_residual.txt");
+  auto expr = deserialize<ExprPtr>(residual);
+  REQUIRE(expr);
+
+  auto r = c60_regime();
+
+  // Build the SAME OptimizeOptions the C60 run used for the batched path.
+  OptimizeOptions opts;
+  opts.objective_function = ObjectiveFunction::DensePeakSizeBatched;
+  opts.idx_to_extent = r.idx_to_extent();
+  opts.inner_pow = r.inner_pow_fn();
+  opts.peak_threshold = 40e9;  // C60 run's peak_threshold (40 GB)
+  // batchable spaces: DF aux (K) AND PAO (mu~)
+  opts.is_batchable_index = [](Index const& ix) {
+    auto k = ix.space().base_key();
+    return k == L"K" || k == L"mu~";
+  };
+  opts.batch_target_size = /* aux_target_size */ 72;
+
+  auto optimized = optimize(expr, opts);
+  REQUIRE(optimized);
+
+  // Dump the per-node batch axes the DP produced and assert the offending
+  // node -- the one whose result carries a free mu~ AND a free K -- got a
+  // mu~ (or K) slice. term_batch_axes is keyed per binary node; see how
+  // make_optimize_options threads it in mpqc4 cck.h.
+  // GO/NO-GO:
+  //   - if the giant node's axis set is empty or aux-only  -> COST-MODEL bug
+  //     (DP never chose mu~ under the 40 GB threshold)
+  //   - if the DP annotated mu~ but the runtime trace shows no slice
+  //     -> RUNTIME bug (annotation dropped in make_batched_custom_evaluator)
+  // Record the finding in the ledger; do not assert a pass/fail verdict here
+  // beyond REQUIRE(optimized) -- this case is a probe. Print the axes:
+  INFO("inspect batch axes for I(i,i,mu~,K;a) node -- see stdout");
+  // ... iterate optimized's binary nodes, print node->annot() + assigned axes.
+  SUCCEED();
+}
+```
+
+- [ ] **Step 5: Build and run the probe**
+
+```bash
+cd /Users/efv/code/SeQuant
+cmake --build build-test --target unit_tests-sequant -j4 2>&1 | tail -20
+./build-test/tests/unit/unit_tests-sequant "[dryrun-probe]" -s 2>&1 | tail -60
+```
+
+Expected: builds; the second case prints the deserialized network's node annotations. Read the printed batch axes for the free-mu~ giant.
+
+- [ ] **Step 6: Calibrate the regime against the memsize anchors**
+
+Add an inline memsize check (using `memsize_counter(idxsz, inner_pow)` from `core/optimize/single_term_detail.hpp`) that computes the byte size of two known index sets and compares to the trace anchors:
+
+```cpp
+TEST_CASE("dryrun regime reproduces C60 trace sizes", "[dryrun-probe]") {
+  auto r = c60_regime();
+  auto memsize = memsize_counter(r.idx_to_extent(), r.inner_pow_fn());
+  // aux-batched giant g(mu~,mu~,K) at aux batch = 72:
+  //   expected ~1.87 GB (trace result=1867538944)
+  // free-mu~ intermediate I(i_3,i_2,mu~_1241,K_2;a_3i_2i_3):
+  //   expected ~186 GB (trace pred_result=185979871872)
+  // Build the index sets from parsed Index objects, call memsize, CHECK
+  // within +/-5%. If off, adjust csv_pno_moment / space_extent until both
+  // anchors land, THEN re-read the Step 4 verdict -- a mis-calibrated regime
+  // invalidates the go/no-go.
+  SUCCEED();
+}
+```
+
+Iterate `csv_pno_moment` / `space_extent` until both anchors reproduce within 5%. Confirm the exact `i`, `mu~`, `K` extents from `614336.log` (`nnz_tiles`, `result=` bytes) rather than trusting the placeholders above.
+
+- [ ] **Step 7: Commit**
+
+```bash
+cd /Users/efv/code/SeQuant
+clang-format --style=file -i \
+  SeQuant/core/eval/backends/dryrun/size_regime.hpp \
+  tests/unit/test_eval_dryrun.cpp
+git add SeQuant/core/eval/backends/dryrun/size_regime.hpp \
+        tests/unit/test_eval_dryrun.cpp tests/unit/data/csv_ccsd_residual.txt \
+        tests/unit/CMakeLists.txt
+git commit -m "dryrun: size regime + DP batch-axis probe on C60 free-mu~ giant"
+```
+
+**Go/no-go gate:** record in the SDD ledger which verdict the probe returned (cost-model vs runtime). Phase 2+ proceed regardless (the backend is useful either way), but the verdict decides where the eventual C60 fix lands.
+
+---
+
+## Task 2: CostModel object
+
+Bundle the optimizer's three cost closures behind one value type the backend `Result`s can query, so `size_in_bytes()` returns the MODEL size (not an allocated size) and the harness can also read FLOPs and projected exec cost per op.
+
+**Files:**
+- Create: `SeQuant/core/eval/backends/dryrun/cost_model_object.hpp`
+- Modify: `SeQuant/tests/unit/test_eval_dryrun.cpp` (add `[dryrun-costmodel]` cases)
+
+**Interfaces:**
+- Consumes: `SizeRegime` (Task 1); `memsize_counter`, `flops_counter` (`core/optimize/single_term_detail.hpp`), `roofline_op_cost` (`core/optimize/cost_model.hpp`), `RooflineParams` (`core/optimize/options.hpp`).
+- Produces: `struct CostModel` in `sequant::eval::dryrun` with:
+  - `explicit CostModel(SizeRegime, RooflineParams = {});`
+  - `std::size_t memsize(container::svector<Index> const& idxset) const;` -- bytes for a tensor with these outer indices (delegates to the `memsize_counter` closure).
+  - `double flops(container::svector<Index> const& out, container::svector<Index> const& contracted) const;` -- multiply-add count for a contraction producing `out` over `contracted` (delegates to `flops_counter`).
+  - `double exec_cost(double flops, std::size_t left_bytes, std::size_t right_bytes) const;` -- roofline projected cost (delegates to `roofline_op_cost` with the stored `RooflineParams`; C60 used `machine_balance=200`, `fast_mem_elems=1000000`).
+  - Public read-only accessor `SizeRegime const& regime() const;`.
+
+- [ ] **Step 1: Write the failing test**
+
+```cpp
+#include <SeQuant/core/eval/backends/dryrun/cost_model_object.hpp>
+
+TEST_CASE("cost model memsize matches memsize_counter", "[dryrun-costmodel]") {
+  auto r = c60_regime();
+  sequant::eval::dryrun::CostModel cm{r};
+  // g(i_1,i_2,K_2): 3 flat indices
+  container::svector<Index> idx{Index{L"i_1"}, Index{L"i_2"}, Index{L"K_2"}};
+  auto direct = memsize_counter(r.idx_to_extent(), r.inner_pow_fn())(idx);
+  CHECK(cm.memsize(idx) == direct);
+}
+```
+
+- [ ] **Step 2: Run to verify it fails**
+
+```bash
+cd /Users/efv/code/SeQuant
+./build-test/tests/unit/unit_tests-sequant "[dryrun-costmodel]" 2>&1 | tail -5
+```
+
+Expected: FAIL to compile (`cost_model_object.hpp` not found).
+
+- [ ] **Step 3: Write `cost_model_object.hpp`**
+
+```cpp
+#ifndef SEQUANT_CORE_EVAL_BACKENDS_DRYRUN_COST_MODEL_OBJECT_HPP
+#define SEQUANT_CORE_EVAL_BACKENDS_DRYRUN_COST_MODEL_OBJECT_HPP
+
+#include <SeQuant/core/container.hpp>
+#include <SeQuant/core/eval/backends/dryrun/size_regime.hpp>
+#include <SeQuant/core/optimize/cost_model.hpp>
+#include <SeQuant/core/optimize/options.hpp>
+
+#include <cstddef>
+
+namespace sequant::eval::dryrun {
+
+/// Bundles the optimizer's own cost closures (memsize / flops / roofline)
+/// behind one value type so dry-run Results report MODEL size and the harness
+/// can read FLOPs and projected execution cost per operation.
+class CostModel {
+ public:
+  explicit CostModel(SizeRegime regime, RooflineParams roofline = {})
+      : regime_{std::move(regime)},
+        roofline_{roofline},
+        memsize_{memsize_counter(regime_.idx_to_extent(),
+                                 regime_.inner_pow_fn())},
+        flops_{flops_counter(regime_.idx_to_extent(), regime_.inner_pow_fn())} {
+  }
+
+  [[nodiscard]] std::size_t memsize(
+      container::svector<Index> const& idxset) const {
+    return memsize_(idxset);
+  }
+
+  [[nodiscard]] double flops(container::svector<Index> const& out,
+                             container::svector<Index> const& contracted) const {
+    return flops_(out, contracted);
+  }
+
+  [[nodiscard]] double exec_cost(double flops, std::size_t left_bytes,
+                                 std::size_t right_bytes) const {
+    return roofline_op_cost(flops, roofline_.block_tiles,
+                            left_bytes + right_bytes, roofline_.machine_balance,
+                            roofline_.fast_mem_elems, roofline_.block_prefactor);
+  }
+
+  [[nodiscard]] SizeRegime const& regime() const { return regime_; }
+
+ private:
+  SizeRegime regime_;
+  RooflineParams roofline_;
+  decltype(memsize_counter(std::declval<SizeRegime>().idx_to_extent(),
+                           std::declval<SizeRegime>().inner_pow_fn())) memsize_;
+  decltype(flops_counter(std::declval<SizeRegime>().idx_to_extent(),
+                         std::declval<SizeRegime>().inner_pow_fn())) flops_;
+};
+
+}  // namespace sequant::eval::dryrun
+
+#endif  // SEQUANT_CORE_EVAL_BACKENDS_DRYRUN_COST_MODEL_OBJECT_HPP
+```
+
+Note: confirm the exact parameter order of `roofline_op_cost` against `cost_model.hpp:282` and the exact return types of `memsize_counter`/`flops_counter`; if `decltype(...)` on the members is awkward, store `std::function<std::size_t(container::svector<Index> const&)>` and `std::function<double(...)>` instead.
+
+- [ ] **Step 4: Run to verify it passes**
+
+```bash
+cd /Users/efv/code/SeQuant
+cmake --build build-test --target unit_tests-sequant -j4 2>&1 | tail -5
+./build-test/tests/unit/unit_tests-sequant "[dryrun-costmodel]" 2>&1 | tail -5
+```
+
+Expected: PASS.
+
+- [ ] **Step 5: Add a flops + exec_cost assertion**
+
+```cpp
+TEST_CASE("cost model flops and exec_cost are finite/positive",
+          "[dryrun-costmodel]") {
+  sequant::eval::dryrun::CostModel cm{c60_regime()};
+  container::svector<Index> out{Index{L"mu~_1"}, Index{L"i_1"}};
+  container::svector<Index> contracted{Index{L"i_2"}};
+  auto f = cm.flops(out, contracted);
+  CHECK(f > 0.0);
+  CHECK(cm.exec_cost(f, cm.memsize(out), 4096) > 0.0);
+}
+```
+
+Run `[dryrun-costmodel]` again; expect PASS.
+
+- [ ] **Step 6: Commit**
+
+```bash
+cd /Users/efv/code/SeQuant
+clang-format --style=file -i \
+  SeQuant/core/eval/backends/dryrun/cost_model_object.hpp \
+  tests/unit/test_eval_dryrun.cpp
+git add SeQuant/core/eval/backends/dryrun/cost_model_object.hpp \
+        tests/unit/test_eval_dryrun.cpp
+git commit -m "dryrun: CostModel object wrapping optimizer memsize/flops/roofline"
+```
+
+---
+
+## Task 3: Flat DryRun Result
+
+Implement `ResultDryRun` -- a zero-data tensor token carrying an ordered index set, whose ops reshape the index set and whose `size_in_bytes()` calls `CostModel::memsize`. Mirror `ResultTensorTAPP` structure; delete all tensor storage.
+
+**Files:**
+- Create: `SeQuant/core/eval/backends/dryrun/result.hpp` (flat class only in this task)
+- Modify: `SeQuant/tests/unit/test_eval_dryrun.cpp` (add `[dryrun-result]` cases)
+
+**Interfaces:**
+- Consumes: abstract `Result` (`core/eval/result.hpp`) -- override `type_id()`, `prod(Result const&, std::array<std::any,3> const&, DeNest)`, `sum(Result const&, std::array<std::any,3> const&)`, `permute(std::array<std::any,2> const&)`, `slice_mode(std::size_t, long, long)`, `mode_batches(std::size_t, std::size_t)`, `add_inplace(Result const&)`, `size_in_bytes()`. `CostModel` (Task 2).
+- Produces: `class ResultDryRun final : public Result` in `sequant::eval::dryrun` with:
+  - `ResultDryRun(container::svector<Index> idxset, std::shared_ptr<CostModel const> cm);`
+  - `container::svector<Index> const& indices() const;`
+  - The annotation arrays passed to `prod`/`sum`/`permute` are `[l_annot, r_annot, res_annot]` for the ternary ops and `[pre, post]` for `permute`. The `res_annot` (element `[2]`) IS the result index set -- decode it (each `std::any` holds the same annotation type tapp uses; for DryRun the natural annotation is `container::svector<Index>` or the node's `annot()` -- confirm what the leaf yielder and `evaluate()` pass, and unpack identically to tapp `Annot`).
+
+- [ ] **Step 1: Write the failing test**
+
+```cpp
+#include <SeQuant/core/eval/backends/dryrun/result.hpp>
+
+using sequant::eval::dryrun::CostModel;
+using sequant::eval::dryrun::ResultDryRun;
+
+TEST_CASE("flat result size delegates to cost model", "[dryrun-result]") {
+  auto cm = std::make_shared<CostModel const>(c60_regime());
+  container::svector<Index> idx{Index{L"i_1"}, Index{L"i_2"}, Index{L"K_2"}};
+  ResultDryRun t{idx, cm};
+  CHECK(t.size_in_bytes() == cm->memsize(idx));
+}
+
+TEST_CASE("flat result prod yields the result annotation index set",
+          "[dryrun-result]") {
+  auto cm = std::make_shared<CostModel const>(c60_regime());
+  ResultDryRun l{{Index{L"mu~_1"}, Index{L"i_2"}}, cm};
+  ResultDryRun r{{Index{L"i_2"}, Index{L"i_1"}}, cm};
+  // result annotation says the product produces (mu~_1, i_1) (i_2 contracted)
+  container::svector<Index> res{Index{L"mu~_1"}, Index{L"i_1"}};
+  auto out = l.prod(r, {l_annot_of(l), r_annot_of(r), annot_of(res)},
+                    Result::DeNest::None);
+  auto const& ot = dynamic_cast<ResultDryRun const&>(*out);
+  CHECK(ot.indices() == res);
+  CHECK(out->size_in_bytes() == cm->memsize(res));
+}
+```
+
+(`l_annot_of` / `annot_of` = helpers that wrap an index set into the same `std::any` payload `evaluate()` supplies; define them in the test's anonymous namespace to match whatever `EvalExprDryRun::annot()` returns from Task 5. If Task 5 is not yet done, temporarily construct the arrays from the raw index sets and adjust in Task 5.)
+
+- [ ] **Step 2: Run to verify it fails**
+
+```bash
+cd /Users/efv/code/SeQuant
+./build-test/tests/unit/unit_tests-sequant "[dryrun-result]" 2>&1 | tail -5
+```
+
+Expected: FAIL to compile.
+
+- [ ] **Step 3: Implement `ResultDryRun`**
+
+Mirror `backends/tapp/result.hpp` (`ResultTensorTAPP`): same `final : public Result`, same `type_id()` pattern (register a unique id), same annotation unpacking. Replace every `tapp_ops::permute(...)` / real-tensor line with pure index-set bookkeeping:
+
+- `prod`: the result index set is the decoded `res_annot` (element `[2]`). Return `make_result<ResultDryRun>(res_indices, cm_)`. No contraction is executed. (Optionally record FLOPs = `cm_->flops(res_indices, contracted)` where `contracted` = indices in `l_annot union r_annot` minus `res_annot`, for the harness to read via an accessor.)
+- `sum`: result index set = decoded `res_annot`; both operands must share it up to permutation. Return a new `ResultDryRun`.
+- `permute`: result index set = decoded `post` annotation (element `[1]`); same size.
+- `slice_mode(mode, elem_lo, elem_hi)`: return a `ResultDryRun` with the SAME index set but a per-mode extent override of `elem_hi - elem_lo` on `mode`. The simplest faithful model: store an optional `std::map<std::size_t, std::size_t> mode_extent_override_` and have `size_in_bytes()` scale the sliced mode's contribution. (If overriding the cost model's per-mode extent is awkward, model the slice by replacing that mode's Index with a narrower synthetic space in the index set; document the choice.)
+- `mode_batches(mode, target)`: return `svector<pair<size_t,size_t>>` tiling `[0, extent(mode))` into ceil(extent/target) element ranges -- identical to what the tiledarray backend does; this needs the regime extent for `indices_[mode]`.
+- `add_inplace`: assert same index set (up to permutation); no data, so a no-op beyond the assertion.
+- `size_in_bytes()`: `return cm_->memsize(indices_);` (applying any `mode_extent_override_`).
+
+Store `container::svector<Index> indices_;` and `std::shared_ptr<CostModel const> cm_;`.
+
+- [ ] **Step 4: Run to verify it passes**
+
+```bash
+cd /Users/efv/code/SeQuant
+cmake --build build-test --target unit_tests-sequant -j4 2>&1 | tail -5
+./build-test/tests/unit/unit_tests-sequant "[dryrun-result]" 2>&1 | tail -8
+```
+
+Expected: PASS.
+
+- [ ] **Step 5: Add slice_mode + mode_batches tests**
+
+```cpp
+TEST_CASE("flat result slice_mode shrinks the sliced mode", "[dryrun-result]") {
+  auto cm = std::make_shared<CostModel const>(c60_regime());
+  ResultDryRun t{{Index{L"mu~_1"}, Index{L"i_2"}}, cm};  // mu~ extent 1800
+  auto full = t.size_in_bytes();
+  auto sliced = t.slice_mode(0, 0, 450);  // quarter of mu~
+  CHECK(sliced->size_in_bytes() < full);
+  CHECK(sliced->size_in_bytes() == full / 4);  // linear in mu~
+}
+
+TEST_CASE("flat result mode_batches tiles the mode extent", "[dryrun-result]") {
+  auto cm = std::make_shared<CostModel const>(c60_regime());
+  ResultDryRun t{{Index{L"mu~_1"}, Index{L"i_2"}}, cm};
+  auto batches = t.mode_batches(0, 450);  // 1800 / 450 = 4 batches
+  CHECK(batches.size() == 4);
+  CHECK(batches.front().first == 0);
+  CHECK(batches.back().second == 1800);
+}
+```
+
+Run `[dryrun-result]`; expect PASS.
+
+- [ ] **Step 6: Commit**
+
+```bash
+cd /Users/efv/code/SeQuant
+clang-format --style=file -i \
+  SeQuant/core/eval/backends/dryrun/result.hpp tests/unit/test_eval_dryrun.cpp
+git add SeQuant/core/eval/backends/dryrun/result.hpp tests/unit/test_eval_dryrun.cpp
+git commit -m "dryrun: flat ResultDryRun (zero-data size/cost token)"
+```
+
+---
+
+## Task 4: Nested DryRun Result (ToT / proto-indexed CSV)
+
+CSV amplitudes are Tensor-of-Tensor: an outer occ-pair index set over inner PNO/OSV domains. `ResultDryRunNested` models this so `size_in_bytes()` uses the moment-aware inner extent (`<#PNO^k>`), reproducing `<#PNO^2> != <#PNO>^2`.
+
+**Files:**
+- Modify: `SeQuant/core/eval/backends/dryrun/result.hpp` (add `ResultDryRunNested`)
+- Modify: `SeQuant/tests/unit/test_eval_dryrun.cpp` (add `[dryrun-nested]` cases)
+
+**Interfaces:**
+- Consumes: same `Result` overrides + `CostModel`. The `DeNest` argument on `prod` decides whether a nested x nested product collapses the inner layer (mirror tapp's handling).
+- Produces: `class ResultDryRunNested final : public Result` in `sequant::eval::dryrun` with:
+  - `ResultDryRunNested(container::svector<Index> outer, container::svector<Index> inner, std::shared_ptr<CostModel const> cm);`
+  - `size_in_bytes()` = outer element count times the moment-aware inner element count. The inner count uses `CostModel::regime().inner_pow(inner_proto_index, 1)` for linear size, and the moment enters when a product raises the effective inner power (a nested x nested contraction over the inner domain yields `<#PNO^2>`, not `<#PNO>^2`). Route through `memsize_counter`, which already applies `inner_pow` for composite indices -- so the correct implementation passes the full (outer + composite-inner) index set to `cm_->memsize(...)` and lets the counter apply the moment. Confirm which index in the set carries the proto (composite) tag so `memsize_counter` picks the moment path.
+
+- [ ] **Step 1: Write the failing test**
+
+```cpp
+using sequant::eval::dryrun::ResultDryRunNested;
+
+TEST_CASE("nested result uses moment-aware inner extent", "[dryrun-nested]") {
+  // regime with a non-trivial second moment: <#PNO^2> != <#PNO>^2
+  auto r = c60_regime();
+  r.csv_pno_moment[1] = 58.0;
+  r.csv_pno_moment[2] = 58.0 * 58.0 * 1.5;  // dispersion: 2nd moment inflated
+  auto cm = std::make_shared<CostModel const>(r);
+
+  // C(i_1,i_2,mu~; a<i_1 i_2>): outer occ pair + PAO, inner PNO over the pair
+  container::svector<Index> outer{Index{L"i_1"}, Index{L"i_2"}, Index{L"mu~_1"}};
+  Index a_pno{L"a_1", {Index{L"i_1"}, Index{L"i_2"}}};  // proto-indexed PNO
+  ResultDryRunNested c{outer, {a_pno}, cm};
+
+  // size must scale with the FIRST moment (linear), not with moment^k
+  auto expected = /* outer element count */ * r.csv_pno_moment[1];
+  CHECK(c.size_in_bytes() ==
+        cm->memsize(/* outer + a_pno as one index set */));
+  // and must differ from the naive avg^2 path
+}
+```
+
+(Fill the exact index-set construction to match how `memsize_counter` reads a proto-indexed `Index`. Verify proto attachment syntax against `Index` ctors in `core/index.hpp`.)
+
+- [ ] **Step 2: Run to verify it fails**
+
+```bash
+cd /Users/efv/code/SeQuant
+./build-test/tests/unit/unit_tests-sequant "[dryrun-nested]" 2>&1 | tail -5
+```
+
+Expected: FAIL to compile.
+
+- [ ] **Step 3: Implement `ResultDryRunNested`**
+
+Mirror the tapp nested/ToT result (if tapp has one) or `backends/btas`/`tiledarray` ToT result for the interface shape; strip storage. Store `outer_`, `inner_` index sets + `cm_`. `size_in_bytes()` builds the combined index set (outer ++ inner-composite) and returns `cm_->memsize(combined)`, so the moment path is applied by the counter. `prod` with `DeNest::All`/inner-collapse returns a flat `ResultDryRun` whose index set is the decoded `res_annot`; `prod` staying nested returns a `ResultDryRunNested`. Decide nested-vs-flat from the decoded result annotation's proto structure (matches how the runtime chooses).
+
+- [ ] **Step 4: Run to verify it passes**
+
+```bash
+cd /Users/efv/code/SeQuant
+cmake --build build-test --target unit_tests-sequant -j4 2>&1 | tail -5
+./build-test/tests/unit/unit_tests-sequant "[dryrun-nested]" 2>&1 | tail -8
+```
+
+Expected: PASS.
+
+- [ ] **Step 5: Commit**
+
+```bash
+cd /Users/efv/code/SeQuant
+clang-format --style=file -i \
+  SeQuant/core/eval/backends/dryrun/result.hpp tests/unit/test_eval_dryrun.cpp
+git add SeQuant/core/eval/backends/dryrun/result.hpp tests/unit/test_eval_dryrun.cpp
+git commit -m "dryrun: nested ResultDryRunNested (moment-aware CSV inner extent)"
+```
+
+---
+
+## Task 5: EvalExpr adapter and leaf yielder
+
+Provide the leaf evaluator functor `evaluate()` calls to turn each IR leaf (a tensor/variable node) into a DryRun `Result`, and the `EvalExprDryRun` alias carrying `annot()` (mirroring `EvalExprTAPP`).
+
+**Files:**
+- Create: `SeQuant/core/eval/backends/dryrun/eval_expr.hpp`
+- Modify: `SeQuant/tests/unit/test_eval_dryrun.cpp` (add `[dryrun-leaf]` cases; retrofit the annotation helpers referenced in Task 3)
+
+**Interfaces:**
+- Consumes: `EvalExpr` (`core/eval/eval_expr.hpp`), `EvalNode` template, `ResultDryRun`/`ResultDryRunNested`, `CostModel`.
+- Produces:
+  - `class EvalExprDryRun final : public EvalExpr` with an `annot()` method (copy `EvalExprTAPP` verbatim; it only adds `annot()`).
+  - `using EvalNodeDryRun = EvalNode<EvalExprDryRun>;`
+  - `struct DryRunLeafEvaluator { std::shared_ptr<CostModel const> cm; ResultPtr operator()(EvalNodeDryRun const& leaf) const; };` -- builds a `ResultDryRun` (flat leaf) or `ResultDryRunNested` (proto-indexed leaf, i.e. a CSV amplitude/coeff) from the leaf's tensor index set, using `cm`. This is the `F` in `evaluate<Trace>(node, layout, F, cache)`.
+
+- [ ] **Step 1: Write the failing test**
+
+```cpp
+#include <SeQuant/core/eval/backends/dryrun/eval_expr.hpp>
+
+TEST_CASE("leaf yielder builds a sized token from a tensor leaf",
+          "[dryrun-leaf]") {
+  auto cm = std::make_shared<CostModel const>(c60_regime());
+  // parse a single tensor into an eval node, yield it
+  auto expr = deserialize<ExprPtr>(L"g{i_1,i_2;K_2}:N-C-S");  // adjust syntax
+  auto node = /* to_eval_node<EvalExprDryRun>(expr) */;
+  sequant::eval::dryrun::DryRunLeafEvaluator yield{cm};
+  auto res = yield(node);
+  container::svector<Index> idx{Index{L"i_1"}, Index{L"i_2"}, Index{L"K_2"}};
+  CHECK(res->size_in_bytes() == cm->memsize(idx));
+}
+```
+
+(Confirm the `to_eval_node` / `binarize`-to-`EvalNode<EvalExprDryRun>` entry from `core/eval/eval_expr.hpp` / how tapp constructs its nodes.)
+
+- [ ] **Step 2: Run to verify it fails**
+
+```bash
+cd /Users/efv/code/SeQuant
+./build-test/tests/unit/unit_tests-sequant "[dryrun-leaf]" 2>&1 | tail -5
+```
+
+Expected: FAIL to compile.
+
+- [ ] **Step 3: Implement `eval_expr.hpp`**
+
+`EvalExprDryRun`: copy `EvalExprTAPP` (constructor-forwarding + `annot()`), rename. `DryRunLeafEvaluator::operator()`: read the leaf's tensor, collect its bra+ket indices into a `container::svector<Index>`; if any index is proto-indexed (composite), build a `ResultDryRunNested` (outer = non-composite indices, inner = composite index); else a flat `ResultDryRun`. Return via `make_result<...>`.
+
+- [ ] **Step 4: Run to verify it passes**
+
+```bash
+cd /Users/efv/code/SeQuant
+cmake --build build-test --target unit_tests-sequant -j4 2>&1 | tail -5
+./build-test/tests/unit/unit_tests-sequant "[dryrun-leaf]" 2>&1 | tail -8
+```
+
+Expected: PASS. Retrofit Task 3's `annot_of`/`l_annot_of` helpers to return exactly what `EvalExprDryRun::annot()` yields, and re-run `[dryrun-result]` to confirm still green.
+
+- [ ] **Step 5: Commit**
+
+```bash
+cd /Users/efv/code/SeQuant
+clang-format --style=file -i \
+  SeQuant/core/eval/backends/dryrun/eval_expr.hpp tests/unit/test_eval_dryrun.cpp
+git add SeQuant/core/eval/backends/dryrun/eval_expr.hpp tests/unit/test_eval_dryrun.cpp
+git commit -m "dryrun: EvalExprDryRun + leaf yielder (flat/nested token from IR leaf)"
+```
+
+---
+
+## Task 6: End-to-end replay harness
+
+Deserialize the residual, run the real optimize -> binarize -> `make_batched_custom_evaluator` -> `evaluate` pipeline against the DryRun backend under a `SizeRegime`, and print a per-operation cost table plus the realized `CacheManager` working-set high-water mark.
+
+**Files:**
+- Modify: `SeQuant/tests/unit/test_eval_dryrun.cpp` (add `[dryrun]` end-to-end case)
+
+**Interfaces:**
+- Consumes: everything above; `make_batched_custom_evaluator` (`eval.hpp:1211`) / the `evaluate_batched` wrapper (`eval.hpp:1485`); `CacheManager` (`core/eval/cache_manager.hpp`) with `note_working_set` / `working_set_hwmark`; `optimize(expr, OptimizeOptions)`.
+- Produces: a documented harness case that (1) factorizes the residual under the C60 regime + 40 GB threshold + `{K, mu~}` batchable, (2) evaluates over a `CacheManager` with `Trace::On`, (3) collects per-op `{result index set, memsize, flops, exec_cost}`, (4) reports peak = `cache.working_set_hwmark()`, (5) flags every intermediate whose result carries a free `mu~` AND is NOT sliced (the leak signature).
+
+- [ ] **Step 1: Write the harness test**
+
+```cpp
+TEST_CASE("dryrun replays the C60 residual and reports peak", "[dryrun]") {
+  auto residual = slurp(std::string(SEQUANT_UNIT_TESTS_SOURCE_DIR) +
+                        "/data/csv_ccsd_residual.txt");
+  auto expr = deserialize<ExprPtr>(residual);
+  REQUIRE(expr);
+
+  auto regime = c60_regime();
+  auto cm = std::make_shared<CostModel const>(regime);
+
+  OptimizeOptions opts;
+  opts.objective_function = ObjectiveFunction::DensePeakSizeBatched;
+  opts.idx_to_extent = regime.idx_to_extent();
+  opts.inner_pow = regime.inner_pow_fn();
+  opts.peak_threshold = 40e9;
+  opts.is_batchable_index = [](Index const& ix) {
+    auto k = ix.space().base_key();
+    return k == L"K" || k == L"mu~";
+  };
+  opts.batch_target_size = 72;
+  auto optimized = optimize(expr, opts);
+
+  // binarize to EvalNode<EvalExprDryRun>, build cache + batched evaluator,
+  // evaluate with Trace::On, capturing per-op logs. Then:
+  auto peak = /* cache.working_set_hwmark() */;
+  INFO("realized peak bytes = " << peak);
+  // Under a CORRECT mu~-slicing DP, peak must stay below tolerance*40 GB.
+  // Today (bug present) it will spike to ~186 GB on the free-mu~ giant.
+  CHECK(peak > 0);
+}
+```
+
+- [ ] **Step 2: Run and read the report**
+
+```bash
+cd /Users/efv/code/SeQuant
+cmake --build build-test --target unit_tests-sequant -j4 2>&1 | tail -5
+./build-test/tests/unit/unit_tests-sequant "[dryrun]" -s 2>&1 | tail -80
+```
+
+Expected: builds and prints a per-op cost table + realized peak. Confirm the free-mu~ giant appears in the table at ~186 GB when the DP leaves it un-sliced (reproducing the cluster OOM locally in seconds). Record the realized peak in the ledger.
+
+- [ ] **Step 3: Commit**
+
+```bash
+cd /Users/efv/code/SeQuant
+clang-format --style=file -i tests/unit/test_eval_dryrun.cpp
+git add tests/unit/test_eval_dryrun.cpp
+git commit -m "dryrun: end-to-end C60 residual replay harness with peak report"
+```
+
+---
+
+## Task 7: C60 regression lock
+
+Turn the reproduced peak into an explicit assertion so the eventual mu~-slicing fix (cost-model or runtime, per Task 1's verdict) has a fast local gate. Until the fix lands, this documents the known failure.
+
+**Files:**
+- Modify: `SeQuant/tests/unit/test_eval_dryrun.cpp`
+
+**Interfaces:**
+- Consumes: Task 6's harness.
+- Produces: a `[dryrun][!shouldfail]`-tagged (Catch2 expected-failure) or explicitly-documented case asserting `peak <= 1.1 * opts.peak_threshold` for the C60 regime. Tagged `!shouldfail` while the bug is live; flip to a hard `CHECK` (remove the tag) in the same commit that fixes the DP/runtime.
+
+- [ ] **Step 1: Add the locked assertion**
+
+```cpp
+// While the mu~-slicing bug is live this case documents the failure; the DP/
+// runtime fix commit removes the [!shouldfail] tag so it becomes a hard gate.
+TEST_CASE("C60 batched peak stays under threshold", "[dryrun][!shouldfail]") {
+  // ... reuse the Task 6 setup ...
+  auto peak = /* realized peak */;
+  CHECK(peak <= static_cast<std::size_t>(1.1 * 40e9));  // 1.1 * 40 GB
+}
+```
+
+- [ ] **Step 2: Run and confirm expected-failure status**
+
+```bash
+cd /Users/efv/code/SeQuant
+./build-test/tests/unit/unit_tests-sequant "[dryrun]" 2>&1 | tail -12
+```
+
+Expected: the `!shouldfail` case reports as an expected failure (peak ~186 GB exceeds 44 GB), the suite stays green. This is the regression lock: once the fix lands, removing the tag makes it a real pass.
+
+- [ ] **Step 3: Commit**
+
+```bash
+cd /Users/efv/code/SeQuant
+clang-format --style=file -i tests/unit/test_eval_dryrun.cpp
+git add tests/unit/test_eval_dryrun.cpp
+git commit -m "dryrun: lock C60 batched peak regression (expected-fail until mu~ slice fix)"
+```
+
+---
+
+## Self-Review
+
+**1. Spec coverage.** Spec Component 1 (CostModel object) -> Task 2. Component 2 (DryRun Result backend: flat + nested, `size_in_bytes` delegating to cost model) -> Tasks 3, 4. Component 3 (SizeRegime + Catch2 harness + fixture) -> Tasks 1 (regime, fixture), 6 (harness). Spec Phase 1 (DP-annotation probe, go/no-go) -> Task 1. Phase 2 (backend) -> Tasks 2-5. Phase 3 (full harness) -> Task 6. Phase 4 (C60 regression lock) -> Task 7. Moment-dependent CSV extents (`<#PNO^k> != <#PNO>^k`, k<=4) -> `SizeRegime::inner_pow` + Task 4. Rank-dependent (`<#OSV> != <#PNO>`) -> separate `csv_osv_moment`/`csv_pno_moment` tables. Validation anchors (~1.87 GB, ~186 GB) -> Task 1 Step 6 + Task 6 Step 2. All covered.
+
+**2. Placeholder scan.** The tasks contain real code and real commands. Remaining `/* ... */` markers are deliberate: they mark the two spots where the exact SeQuant API (annotation `std::any` payload type in `evaluate()`; the `to_eval_node<EvalExprDryRun>` / binarize entry) must be confirmed against `backends/tapp/{result,eval_expr}.hpp` at implementation time, and each is accompanied by the reference file + what to mirror. The C60 space extents (`i`, `K`) are flagged CONFIRM-from-log rather than guessed. These are grounding pointers, not vague directives.
+
+**3. Type consistency.** `SizeRegime::idx_to_extent()` returns `std::function<std::size_t(Index const&)>`, consumed by `CostModel` ctor and `OptimizeOptions::idx_to_extent` (both expect that signature). `SizeRegime::inner_pow_fn()` returns `std::function<double(Index const&, std::size_t)>`, matching `OptimizeOptions::inner_pow`. `CostModel::memsize(container::svector<Index> const&)` is the single size entry used by `ResultDryRun::size_in_bytes` (Task 3), `ResultDryRunNested::size_in_bytes` (Task 4), and the tests. `ResultDryRun`/`ResultDryRunNested`/`EvalExprDryRun`/`EvalNodeDryRun`/`DryRunLeafEvaluator` names are used identically across Tasks 3-6. All in `sequant::eval::dryrun`.
+
+---
+
+## Execution Handoff
+
+Plan complete and saved to `doc/dev/plans/2026-07-04-dryrun-eval-backend.md`. Two execution options:
+
+1. **Subagent-Driven (recommended)** - dispatch a fresh subagent per task, review between tasks, fast iteration. Task 1 (the go/no-go probe) is the natural first gate: its verdict decides where the eventual C60 mu~-slicing fix lands.
+2. **Inline Execution** - execute tasks in this session with checkpoints for review.
+
+Which approach?
diff --git a/tests/unit/data/csv_ccsd_doubles_residual_df.txt b/tests/unit/data/csv_ccsd_doubles_residual_df.txt
new file mode 100644
index 0000000000..93bea0be7a
--- /dev/null
+++ b/tests/unit/data/csv_ccsd_doubles_residual_df.txt
@@ -0,0 +1 @@
+2 g{μ̃_1152;i_3;Κ_2}:N-S-S * C{a_3<i_2>;μ̃_1152}:N-S-S * g{μ̃_1153;i_4;Κ_2}:N-S-S * C{a_4<i_1,i_4>;μ̃_1153}:N-S-S * s{μ̃_1154;μ̃_1155}:N-S-S * C{a_1<i_1,i_2>;μ̃_1154}:N-S-S * C{μ̃_1155;a_5<i_1,i_4>}:N-S-S * s{μ̃_1156;μ̃_1157}:N-S-S * C{a_2<i_1,i_2>;μ̃_1156}:N-S-S * C{μ̃_1157;a_6<i_3>}:N-S-S * t{a_3<i_2>;i_2}:N-N-S * t{a_6<i_3>;i_3}:N-N-S * t{a_4<i_1,i_4>,a_5<i_1,i_4>;i_1,i_4}:N-N-S - 2 f{μ̃_1158;i_3}:N-S-S * C{a_3<i_1,i_2>;μ̃_1158}:N-S-S * s{μ̃_1159;μ̃_1160}:N-S-S * C{a_2<i_1,i_2>;μ̃_1159}:N-S-S * C{μ̃_1160;a_4<i_3>}:N-S-S * t{a_4<i_3>;i_3}:N-N-S * t{a_1<i_1,i_2>,a_3<i_1,i_2>;i_1,i_2}:N-N-S - 4 g{i_2;i_3;Κ_2}:N-S-S * g{μ̃_1161;i_4;Κ_2}:N-S-S * C{a_3<i_1,i_4>;μ̃_1161}:N-S-S * s{μ̃_1162;μ̃_1163}:N-S-S * C{a_2<i_1,i_2>;μ̃_1162}:N-S-S * C{μ̃_1163;a_5<i_3>}:N-S-S * s{μ̃_1164;μ̃_1165}:N-S-S * C{a_4<i_1,i_4>;μ̃_1164}:N-S-S * C{μ̃_1165;a_1<i_1,i_2>}:N-S-S * t{a_5<i_3>;i_3}:N-N-S * t{a_3<i_1,i_4>,a_4<i_1,i_4>;i_4,i_1}:N-N-S + 4 g{μ̃_1166;i_3;Κ_2}:N-S-S * C{a_3<i_3>;μ̃_1166}:N-S-S * g{μ̃_1167;μ̃_1168;Κ_2}:N-S-S * C{a_4<i_1,i_2>;μ̃_1167}:N-S-S * C{μ̃_1168;a_2<i_1,i_2>}:N-S-S * t{a_3<i_3>;i_3}:N-N-S * t{a_1<i_1,i_2>,a_4<i_1,i_2>;i_1,i_2}:N-N-S + g{μ̃_1169;i_3;Κ_2}:N-S-S * C{a_3<i_1,i_2>;μ̃_1169}:N-S-S * g{μ̃_1170;i_4;Κ_2}:N-S-S * C{a_4<i_1,i_2>;μ̃_1170}:N-S-S * s{μ̃_1171;μ̃_1172}:N-S-S * C{a_5<i_3,i_4>;μ̃_1171}:N-S-S * C{μ̃_1172;a_1<i_1,i_2>}:N-S-S * s{μ̃_1173;μ̃_1174}:N-S-S * C{a_6<i_3,i_4>;μ̃_1173}:N-S-S * C{μ̃_1174;a_2<i_1,i_2>}:N-S-S * t{a_3<i_1,i_2>,a_4<i_1,i_2>;i_1,i_2}:N-N-S * t{a_5<i_3,i_4>,a_6<i_3,i_4>;i_3,i_4}:N-N-S + 2 g{i_2;i_3;Κ_2}:N-S-S * g{μ̃_1175;i_4;Κ_2}:N-S-S * C{a_3<i_1,i_3>;μ̃_1175}:N-S-S * s{μ̃_1176;μ̃_1177}:N-S-S * C{a_2<i_1,i_2>;μ̃_1176}:N-S-S * C{μ̃_1177;a_5<i_4>}:N-S-S * s{μ̃_1178;μ̃_1179}:N-S-S * C{a_4<i_1,i_3>;μ̃_1178}:N-S-S * C{μ̃_1179;a_1<i_1,i_2>}:N-S-S * t{a_5<i_4>;i_4}:N-N-S * t{a_3<i_1,i_3>,a_4<i_1,i_3>;i_3,i_1}:N-N-S + 2 g{i_2;i_3;Κ_2}:N-S-S * g{μ̃_1180;i_4;Κ_2}:N-S-S * C{a_3<i_1>;μ̃_1180}:N-S-S * s{μ̃_1181;μ̃_1182}:N-S-S * C{a_1<i_1,i_2>;μ̃_1181}:N-S-S * C{μ̃_1182;a_4<i_4>}:N-S-S * s{μ̃_1183;μ̃_1184}:N-S-S * C{a_2<i_1,i_2>;μ̃_1183}:N-S-S * C{μ̃_1184;a_5<i_3>}:N-S-S * t{a_3<i_1>;i_1}:N-N-S * t{a_4<i_4>;i_4}:N-N-S * t{a_5<i_3>;i_3}:N-N-S + 2 g{μ̃_1185;i_3;Κ_2}:N-S-S * C{a_3<i_3,i_4>;μ̃_1185}:N-S-S * g{μ̃_1186;i_4;Κ_2}:N-S-S * C{a_4<i_1,i_2>;μ̃_1186}:N-S-S * s{μ̃_1187;μ̃_1188}:N-S-S * C{a_1<i_1,i_2>;μ̃_1187}:N-S-S * C{μ̃_1188;a_5<i_3,i_4>}:N-S-S * t{a_2<i_1,i_2>,a_4<i_1,i_2>;i_2,i_1}:N-N-S * t{a_3<i_3,i_4>,a_5<i_3,i_4>;i_4,i_3}:N-N-S + 2 g{μ̃_1189;i_3;Κ_2}:N-S-S * C{a_3<i_4>;μ̃_1189}:N-S-S * g{μ̃_1190;i_4;Κ_2}:N-S-S * C{a_4<i_1,i_2>;μ̃_1190}:N-S-S * s{μ̃_1191;μ̃_1192}:N-S-S * C{a_2<i_1,i_2>;μ̃_1191}:N-S-S * C{μ̃_1192;a_5<i_3>}:N-S-S * t{a_3<i_4>;i_4}:N-N-S * t{a_5<i_3>;i_3}:N-N-S * t{a_1<i_1,i_2>,a_4<i_1,i_2>;i_1,i_2}:N-N-S + 2 g{i_2;i_3;Κ_2}:N-S-S * g{μ̃_1193;i_4;Κ_2}:N-S-S * C{a_3<i_1,i_4>;μ̃_1193}:N-S-S * s{μ̃_1194;μ̃_1195}:N-S-S * C{a_2<i_1,i_2>;μ̃_1194}:N-S-S * C{μ̃_1195;a_5<i_3>}:N-S-S * s{μ̃_1196;μ̃_1197}:N-S-S * C{a_4<i_1,i_4>;μ̃_1196}:N-S-S * C{μ̃_1197;a_1<i_1,i_2>}:N-S-S * t{a_5<i_3>;i_3}:N-N-S * t{a_3<i_1,i_4>,a_4<i_1,i_4>;i_1,i_4}:N-N-S + g{μ̃_1198;i_3;Κ_2}:N-S-S * C{a_3<i_1>;μ̃_1198}:N-S-S * g{μ̃_1199;i_4;Κ_2}:N-S-S * C{a_4<i_2>;μ̃_1199}:N-S-S * s{μ̃_1200;μ̃_1201}:N-S-S * C{a_1<i_1,i_2>;μ̃_1200}:N-S-S * C{μ̃_1201;a_5<i_3,i_4>}:N-S-S * s{μ̃_1202;μ̃_1203}:N-S-S * C{a_2<i_1,i_2>;μ̃_1202}:N-S-S * C{μ̃_1203;a_6<i_3,i_4>}:N-S-S * t{a_3<i_1>;i_1}:N-N-S * t{a_4<i_2>;i_2}:N-N-S * t{a_5<i_3,i_4>,a_6<i_3,i_4>;i_3,i_4}:N-N-S - 2 g{μ̃_1204;i_3;Κ_2}:N-S-S * C{a_3<i_1,i_2>;μ̃_1204}:N-S-S * g{μ̃_1205;μ̃_1206;Κ_2}:N-S-S * C{a_4<i_1,i_2>;μ̃_1205}:N-S-S * C{μ̃_1206;a_1<i_1,i_2>}:N-S-S * s{μ̃_1207;μ̃_1208}:N-S-S * C{a_2<i_1,i_2>;μ̃_1207}:N-S-S * C{μ̃_1208;a_5<i_3>}:N-S-S * t{a_5<i_3>;i_3}:N-N-S * t{a_3<i_1,i_2>,a_4<i_1,i_2>;i_2,i_1}:N-N-S - 2 g{μ̃_1209;i_3;Κ_2}:N-S-S * C{a_3<i_2,i_4>;μ̃_1209}:N-S-S * g{μ̃_1210;i_4;Κ_2}:N-S-S * C{a_4<i_1,i_3>;μ̃_1210}:N-S-S * s{μ̃_1211;μ̃_1212}:N-S-S * C{a_1<i_1,i_2>;μ̃_1211}:N-S-S * C{μ̃_1212;a_5<i_1,i_3>}:N-S-S * s{μ̃_1213;μ̃_1214}:N-S-S * C{a_2<i_1,i_2>;μ̃_1213}:N-S-S * C{μ̃_1214;a_6<i_2,i_4>}:N-S-S * t{a_3<i_2,i_4>,a_6<i_2,i_4>;i_4,i_2}:N-N-S * t{a_4<i_1,i_3>,a_5<i_1,i_3>;i_3,i_1}:N-N-S - 2 g{μ̃_1215;i_3;Κ_2}:N-S-S * C{a_3<i_2>;μ̃_1215}:N-S-S * g{μ̃_1216;μ̃_1217;Κ_2}:N-S-S * C{a_4<i_1>;μ̃_1216}:N-S-S * C{μ̃_1217;a_1<i_1,i_2>}:N-S-S * s{μ̃_1218;μ̃_1219}:N-S-S * C{a_2<i_1,i_2>;μ̃_1218}:N-S-S * C{μ̃_1219;a_5<i_3>}:N-S-S * t{a_3<i_2>;i_2}:N-N-S * t{a_4<i_1>;i_1}:N-N-S * t{a_5<i_3>;i_3}:N-N-S - 4 g{μ̃_1220;i_3;Κ_2}:N-S-S * C{a_3<i_1,i_4>;μ̃_1220}:N-S-S * g{μ̃_1221;i_4;Κ_2}:N-S-S * C{a_4<i_1,i_4>;μ̃_1221}:N-S-S * s{μ̃_1222;μ̃_1223}:N-S-S * C{a_1<i_1,i_2>;μ̃_1222}:N-S-S * C{μ̃_1223;a_5<i_2,i_3>}:N-S-S * s{μ̃_1224;μ̃_1225}:N-S-S * C{a_2<i_1,i_2>;μ̃_1224}:N-S-S * C{μ̃_1225;a_6<i_2,i_3>}:N-S-S * t{a_3<i_1,i_4>,a_4<i_1,i_4>;i_1,i_4}:N-N-S * t{a_5<i_2,i_3>,a_6<i_2,i_3>;i_3,i_2}:N-N-S - 2 g{i_3;i_2;Κ_2}:N-S-S * g{μ̃_1226;μ̃_1227;Κ_2}:N-S-S * C{a_1<i_1,i_2>;μ̃_1226}:N-S-S * C{μ̃_1227;a_3<i_1>}:N-S-S * s{μ̃_1228;μ̃_1229}:N-S-S * C{a_2<i_1,i_2>;μ̃_1228}:N-S-S * C{μ̃_1229;a_4<i_3>}:N-S-S * t{a_3<i_1>;i_1}:N-N-S * t{a_4<i_3>;i_3}:N-N-S + g{μ̃_1230;i_3;Κ_2}:N-S-S * C{a_3<i_1,i_2>;μ̃_1230}:N-S-S * g{μ̃_1231;i_4;Κ_2}:N-S-S * C{a_4<i_1,i_2>;μ̃_1231}:N-S-S * s{μ̃_1232;μ̃_1233}:N-S-S * C{a_1<i_1,i_2>;μ̃_1232}:N-S-S * C{μ̃_1233;a_5<i_3>}:N-S-S * s{μ̃_1234;μ̃_1235}:N-S-S * C{a_2<i_1,i_2>;μ̃_1234}:N-S-S * C{μ̃_1235;a_6<i_4>}:N-S-S * t{a_5<i_3>;i_3}:N-N-S * t{a_6<i_4>;i_4}:N-N-S * t{a_3<i_1,i_2>,a_4<i_1,i_2>;i_1,i_2}:N-N-S + 2 g{i_2;i_3;Κ_2}:N-S-S * g{μ̃_1236;i_4;Κ_2}:N-S-S * C{a_3<i_3>;μ̃_1236}:N-S-S * s{μ̃_1237;μ̃_1238}:N-S-S * C{a_2<i_1,i_2>;μ̃_1237}:N-S-S * C{μ̃_1238;a_5<i_1,i_4>}:N-S-S * s{μ̃_1239;μ̃_1240}:N-S-S * C{a_4<i_1,i_4>;μ̃_1239}:N-S-S * C{μ̃_1240;a_1<i_1,i_2>}:N-S-S * t{a_3<i_3>;i_3}:N-N-S * t{a_4<i_1,i_4>,a_5<i_1,i_4>;i_1,i_4}:N-N-S - 2 g{i_3;i_1;Κ_2}:N-S-S * g{μ̃_1241;μ̃_1242;Κ_2}:N-S-S * C{a_1<i_1,i_2>;μ̃_1241}:N-S-S * C{μ̃_1242;a_3<i_2,i_3>}:N-S-S * s{μ̃_1243;μ̃_1244}:N-S-S * C{a_4<i_2,i_3>;μ̃_1243}:N-S-S * C{μ̃_1244;a_2<i_1,i_2>}:N-S-S * t{a_3<i_2,i_3>,a_4<i_2,i_3>;i_3,i_2}:N-N-S - 4 g{μ̃_1245;i_3;Κ_2}:N-S-S * C{a_3<i_1,i_3>;μ̃_1245}:N-S-S * g{μ̃_1246;i_4;Κ_2}:N-S-S * C{a_4<i_2,i_4>;μ̃_1246}:N-S-S * s{μ̃_1247;μ̃_1248}:N-S-S * C{a_1<i_1,i_2>;μ̃_1247}:N-S-S * C{μ̃_1248;a_5<i_1,i_3>}:N-S-S * s{μ̃_1249;μ̃_1250}:N-S-S * C{a_2<i_1,i_2>;μ̃_1249}:N-S-S * C{μ̃_1250;a_6<i_2,i_4>}:N-S-S * t{a_3<i_1,i_3>,a_5<i_1,i_3>;i_1,i_3}:N-N-S * t{a_4<i_2,i_4>,a_6<i_2,i_4>;i_4,i_2}:N-N-S + 2 g{μ̃_1251;i_3;Κ_2}:N-S-S * C{a_3<i_2>;μ̃_1251}:N-S-S * g{μ̃_1252;i_4;Κ_2}:N-S-S * C{a_4<i_1,i_3>;μ̃_1252}:N-S-S * s{μ̃_1253;μ̃_1254}:N-S-S * C{a_1<i_1,i_2>;μ̃_1253}:N-S-S * C{μ̃_1254;a_5<i_4>}:N-S-S * s{μ̃_1255;μ̃_1256}:N-S-S * C{a_6<i_1,i_3>;μ̃_1255}:N-S-S * C{μ̃_1256;a_2<i_1,i_2>}:N-S-S * t{a_3<i_2>;i_2}:N-N-S * t{a_5<i_4>;i_4}:N-N-S * t{a_4<i_1,i_3>,a_6<i_1,i_3>;i_1,i_3}:N-N-S - 2 g{i_3;μ̃_1257;Κ_2}:N-S-S * C{μ̃_1257;a_3<i_1>}:N-S-S * g{μ̃_1258;i_2;Κ_2}:N-S-S * C{a_2<i_1,i_2>;μ̃_1258}:N-S-S * s{μ̃_1259;μ̃_1260}:N-S-S * C{a_1<i_1,i_2>;μ̃_1259}:N-S-S * C{μ̃_1260;a_4<i_3>}:N-S-S * t{a_3<i_1>;i_1}:N-N-S * t{a_4<i_3>;i_3}:N-N-S + g{i_3;i_1;Κ_2}:N-S-S * g{i_4;i_2;Κ_2}:N-S-S * s{μ̃_1261;μ̃_1262}:N-S-S * C{a_1<i_1,i_2>;μ̃_1261}:N-S-S * C{μ̃_1262;a_3<i_3>}:N-S-S * s{μ̃_1263;μ̃_1264}:N-S-S * C{a_2<i_1,i_2>;μ̃_1263}:N-S-S * C{μ̃_1264;a_4<i_4>}:N-S-S * t{a_3<i_3>;i_3}:N-N-S * t{a_4<i_4>;i_4}:N-N-S - 2 g{i_3;μ̃_1265;Κ_2}:N-S-S * C{μ̃_1265;a_3<i_2,i_3>}:N-S-S * g{μ̃_1266;i_1;Κ_2}:N-S-S * C{a_1<i_1,i_2>;μ̃_1266}:N-S-S * s{μ̃_1267;μ̃_1268}:N-S-S * C{a_4<i_2,i_3>;μ̃_1267}:N-S-S * C{μ̃_1268;a_2<i_1,i_2>}:N-S-S * t{a_3<i_2,i_3>,a_4<i_2,i_3>;i_2,i_3}:N-N-S - 2 f{μ̃_1269;i_3}:N-S-S * C{a_3<i_1>;μ̃_1269}:N-S-S * s{μ̃_1270;μ̃_1271}:N-S-S * C{a_4<i_2,i_3>;μ̃_1270}:N-S-S * C{μ̃_1271;a_1<i_1,i_2>}:N-S-S * s{μ̃_1272;μ̃_1273}:N-S-S * C{a_5<i_2,i_3>;μ̃_1272}:N-S-S * C{μ̃_1273;a_2<i_1,i_2>}:N-S-S * t{a_3<i_1>;i_1}:N-N-S * t{a_4<i_2,i_3>,a_5<i_2,i_3>;i_3,i_2}:N-N-S + 2 f{μ̃_1274;μ̃_1275}:N-S-S * C{a_2<i_1,i_2>;μ̃_1274}:N-S-S * C{μ̃_1275;a_3<i_1,i_2>}:N-S-S * t{a_1<i_1,i_2>,a_3<i_1,i_2>;i_1,i_2}:N-N-S + g{μ̃_1276;i_3;Κ_2}:N-S-S * C{a_3<i_2,i_4>;μ̃_1276}:N-S-S * g{μ̃_1277;i_4;Κ_2}:N-S-S * C{a_4<i_1,i_3>;μ̃_1277}:N-S-S * s{μ̃_1278;μ̃_1279}:N-S-S * C{a_1<i_1,i_2>;μ̃_1278}:N-S-S * C{μ̃_1279;a_5<i_2,i_4>}:N-S-S * s{μ̃_1280;μ̃_1281}:N-S-S * C{a_2<i_1,i_2>;μ̃_1280}:N-S-S * C{μ̃_1281;a_6<i_1,i_3>}:N-S-S * t{a_3<i_2,i_4>,a_5<i_2,i_4>;i_2,i_4}:N-N-S * t{a_4<i_1,i_3>,a_6<i_1,i_3>;i_1,i_3}:N-N-S + g{μ̃_1282;i_3;Κ_2}:N-S-S * C{a_3<i_1>;μ̃_1282}:N-S-S * g{μ̃_1283;i_4;Κ_2}:N-S-S * C{a_4<i_2>;μ̃_1283}:N-S-S * s{μ̃_1284;μ̃_1285}:N-S-S * C{a_1<i_1,i_2>;μ̃_1284}:N-S-S * C{μ̃_1285;a_5<i_3>}:N-S-S * s{μ̃_1286;μ̃_1287}:N-S-S * C{a_2<i_1,i_2>;μ̃_1286}:N-S-S * C{μ̃_1287;a_6<i_4>}:N-S-S * t{a_3<i_1>;i_1}:N-N-S * t{a_4<i_2>;i_2}:N-N-S * t{a_5<i_3>;i_3}:N-N-S * t{a_6<i_4>;i_4}:N-N-S - 4 g{μ̃_1288;i_3;Κ_2}:N-S-S * C{a_3<i_2>;μ̃_1288}:N-S-S * g{μ̃_1289;i_4;Κ_2}:N-S-S * C{a_4<i_1,i_4>;μ̃_1289}:N-S-S * s{μ̃_1290;μ̃_1291}:N-S-S * C{a_1<i_1,i_2>;μ̃_1290}:N-S-S * C{μ̃_1291;a_5<i_1,i_4>}:N-S-S * s{μ̃_1292;μ̃_1293}:N-S-S * C{a_2<i_1,i_2>;μ̃_1292}:N-S-S * C{μ̃_1293;a_6<i_3>}:N-S-S * t{a_3<i_2>;i_2}:N-N-S * t{a_6<i_3>;i_3}:N-N-S * t{a_4<i_1,i_4>,a_5<i_1,i_4>;i_4,i_1}:N-N-S - 2 g{μ̃_1294;μ̃_1295;Κ_2}:N-S-S * C{a_3<i_3>;μ̃_1294}:N-S-S * C{μ̃_1295;a_2<i_1,i_2>}:N-S-S * g{μ̃_1296;i_3;Κ_2}:N-S-S * C{a_4<i_1,i_2>;μ̃_1296}:N-S-S * t{a_3<i_3>;i_3}:N-N-S * t{a_1<i_1,i_2>,a_4<i_1,i_2>;i_1,i_2}:N-N-S - 2 g{μ̃_1297;i_3;Κ_2}:N-S-S * C{a_3<i_1>;μ̃_1297}:N-S-S * g{μ̃_1298;μ̃_1299;Κ_2}:N-S-S * C{a_4<i_2,i_3>;μ̃_1298}:N-S-S * C{μ̃_1299;a_2<i_1,i_2>}:N-S-S * s{μ̃_1300;μ̃_1301}:N-S-S * C{a_1<i_1,i_2>;μ̃_1300}:N-S-S * C{μ̃_1301;a_5<i_2,i_3>}:N-S-S * t{a_3<i_1>;i_1}:N-N-S * t{a_4<i_2,i_3>,a_5<i_2,i_3>;i_2,i_3}:N-N-S + 4 g{μ̃_1302;μ̃_1303;Κ_2}:N-S-S * C{a_3<i_2>;μ̃_1302}:N-S-S * C{μ̃_1303;a_2<i_1,i_2>}:N-S-S * g{μ̃_1304;i_3;Κ_2}:N-S-S * C{a_4<i_1,i_3>;μ̃_1304}:N-S-S * s{μ̃_1305;μ̃_1306}:N-S-S * C{a_5<i_1,i_3>;μ̃_1305}:N-S-S * C{μ̃_1306;a_1<i_1,i_2>}:N-S-S * t{a_3<i_2>;i_2}:N-N-S * t{a_4<i_1,i_3>,a_5<i_1,i_3>;i_3,i_1}:N-N-S + g{i_1;i_3;Κ_2}:N-S-S * g{i_2;i_4;Κ_2}:N-S-S * s{μ̃_1307;μ̃_1308}:N-S-S * C{a_1<i_1,i_2>;μ̃_1307}:N-S-S * C{μ̃_1308;a_3<i_3,i_4>}:N-S-S * s{μ̃_1309;μ̃_1310}:N-S-S * C{a_2<i_1,i_2>;μ̃_1309}:N-S-S * C{μ̃_1310;a_4<i_3,i_4>}:N-S-S * t{a_3<i_3,i_4>,a_4<i_3,i_4>;i_3,i_4}:N-N-S + 2 g{μ̃_1311;i_3;Κ_2}:N-S-S * C{a_3<i_2>;μ̃_1311}:N-S-S * g{μ̃_1312;i_4;Κ_2}:N-S-S * C{a_4<i_1,i_3>;μ̃_1312}:N-S-S * s{μ̃_1313;μ̃_1314}:N-S-S * C{a_1<i_1,i_2>;μ̃_1313}:N-S-S * C{μ̃_1314;a_5<i_1,i_3>}:N-S-S * s{μ̃_1315;μ̃_1316}:N-S-S * C{a_2<i_1,i_2>;μ̃_1315}:N-S-S * C{μ̃_1316;a_6<i_4>}:N-S-S * t{a_3<i_2>;i_2}:N-N-S * t{a_6<i_4>;i_4}:N-N-S * t{a_4<i_1,i_3>,a_5<i_1,i_3>;i_3,i_1}:N-N-S - 2 g{i_3;i_1;Κ_2}:N-S-S * g{μ̃_1317;μ̃_1318;Κ_2}:N-S-S * C{a_2<i_1,i_2>;μ̃_1317}:N-S-S * C{μ̃_1318;a_3<i_2,i_3>}:N-S-S * s{μ̃_1319;μ̃_1320}:N-S-S * C{a_4<i_2,i_3>;μ̃_1319}:N-S-S * C{μ̃_1320;a_1<i_1,i_2>}:N-S-S * t{a_3<i_2,i_3>,a_4<i_2,i_3>;i_2,i_3}:N-N-S - 4 g{μ̃_1321;i_3;Κ_2}:N-S-S * C{a_3<i_3>;μ̃_1321}:N-S-S * g{μ̃_1322;i_4;Κ_2}:N-S-S * C{a_4<i_1,i_2>;μ̃_1322}:N-S-S * s{μ̃_1323;μ̃_1324}:N-S-S * C{a_2<i_1,i_2>;μ̃_1323}:N-S-S * C{μ̃_1324;a_5<i_4>}:N-S-S * t{a_3<i_3>;i_3}:N-N-S * t{a_5<i_4>;i_4}:N-N-S * t{a_1<i_1,i_2>,a_4<i_1,i_2>;i_1,i_2}:N-N-S + 2 g{μ̃_1325;i_1;Κ_2}:N-S-S * C{a_1<i_1,i_2>;μ̃_1325}:N-S-S * g{μ̃_1326;μ̃_1327;Κ_2}:N-S-S * C{a_2<i_1,i_2>;μ̃_1326}:N-S-S * C{μ̃_1327;a_3<i_2>}:N-S-S * t{a_3<i_2>;i_2}:N-N-S + 4 g{μ̃_1328;i_3;Κ_2}:N-S-S * C{a_3<i_1,i_3>;μ̃_1328}:N-S-S * g{μ̃_1329;i_4;Κ_2}:N-S-S * C{a_4<i_2,i_4>;μ̃_1329}:N-S-S * s{μ̃_1330;μ̃_1331}:N-S-S * C{a_1<i_1,i_2>;μ̃_1330}:N-S-S * C{μ̃_1331;a_5<i_1,i_3>}:N-S-S * s{μ̃_1332;μ̃_1333}:N-S-S * C{a_2<i_1,i_2>;μ̃_1332}:N-S-S * C{μ̃_1333;a_6<i_2,i_4>}:N-S-S * t{a_3<i_1,i_3>,a_5<i_1,i_3>;i_3,i_1}:N-N-S * t{a_4<i_2,i_4>,a_6<i_2,i_4>;i_4,i_2}:N-N-S + g{μ̃_1334;μ̃_1335;Κ_2}:N-S-S * C{a_1<i_1,i_2>;μ̃_1334}:N-S-S * C{μ̃_1335;a_3<i_1,i_2>}:N-S-S * g{μ̃_1336;μ̃_1337;Κ_2}:N-S-S * C{a_2<i_1,i_2>;μ̃_1336}:N-S-S * C{μ̃_1337;a_4<i_1,i_2>}:N-S-S * t{a_3<i_1,i_2>,a_4<i_1,i_2>;i_1,i_2}:N-N-S + g{μ̃_1338;i_1;Κ_2}:N-S-S * C{a_1<i_1,i_2>;μ̃_1338}:N-S-S * g{μ̃_1339;i_2;Κ_2}:N-S-S * C{a_2<i_1,i_2>;μ̃_1339}:N-S-S - 2 g{i_3;i_1;Κ_2}:N-S-S * g{μ̃_1340;i_2;Κ_2}:N-S-S * C{a_2<i_1,i_2>;μ̃_1340}:N-S-S * s{μ̃_1341;μ̃_1342}:N-S-S * C{a_1<i_1,i_2>;μ̃_1341}:N-S-S * C{μ̃_1342;a_3<i_3>}:N-S-S * t{a_3<i_3>;i_3}:N-N-S + 2 g{i_2;i_3;Κ_2}:N-S-S * g{μ̃_1343;i_4;Κ_2}:N-S-S * C{a_3<i_1,i_3>;μ̃_1343}:N-S-S * s{μ̃_1344;μ̃_1345}:N-S-S * C{a_1<i_1,i_2>;μ̃_1344}:N-S-S * C{μ̃_1345;a_5<i_4>}:N-S-S * s{μ̃_1346;μ̃_1347}:N-S-S * C{a_2<i_1,i_2>;μ̃_1346}:N-S-S * C{μ̃_1347;a_4<i_1,i_3>}:N-S-S * t{a_5<i_4>;i_4}:N-N-S * t{a_3<i_1,i_3>,a_4<i_1,i_3>;i_1,i_3}:N-N-S - 2 g{μ̃_1348;i_3;Κ_2}:N-S-S * C{a_3<i_1>;μ̃_1348}:N-S-S * g{μ̃_1349;μ̃_1350;Κ_2}:N-S-S * C{a_4<i_2,i_3>;μ̃_1349}:N-S-S * C{μ̃_1350;a_1<i_1,i_2>}:N-S-S * s{μ̃_1351;μ̃_1352}:N-S-S * C{a_5<i_2,i_3>;μ̃_1351}:N-S-S * C{μ̃_1352;a_2<i_1,i_2>}:N-S-S * t{a_3<i_1>;i_1}:N-N-S * t{a_4<i_2,i_3>,a_5<i_2,i_3>;i_3,i_2}:N-N-S + 2 g{μ̃_1353;i_3;Κ_2}:N-S-S * C{a_3<i_4>;μ̃_1353}:N-S-S * g{μ̃_1354;i_4;Κ_2}:N-S-S * C{a_4<i_2>;μ̃_1354}:N-S-S * s{μ̃_1355;μ̃_1356}:N-S-S * C{a_5<i_1,i_3>;μ̃_1355}:N-S-S * C{μ̃_1356;a_1<i_1,i_2>}:N-S-S * s{μ̃_1357;μ̃_1358}:N-S-S * C{a_6<i_1,i_3>;μ̃_1357}:N-S-S * C{μ̃_1358;a_2<i_1,i_2>}:N-S-S * t{a_3<i_4>;i_4}:N-N-S * t{a_4<i_2>;i_2}:N-N-S * t{a_5<i_1,i_3>,a_6<i_1,i_3>;i_1,i_3}:N-N-S - 4 g{i_2;i_3;Κ_2}:N-S-S * g{μ̃_1359;i_4;Κ_2}:N-S-S * C{a_3<i_4>;μ̃_1359}:N-S-S * s{μ̃_1360;μ̃_1361}:N-S-S * C{a_1<i_1,i_2>;μ̃_1360}:N-S-S * C{μ̃_1361;a_4<i_1,i_3>}:N-S-S * s{μ̃_1362;μ̃_1363}:N-S-S * C{a_5<i_1,i_3>;μ̃_1362}:N-S-S * C{μ̃_1363;a_2<i_1,i_2>}:N-S-S * t{a_3<i_4>;i_4}:N-N-S * t{a_4<i_1,i_3>,a_5<i_1,i_3>;i_1,i_3}:N-N-S - 2 g{μ̃_1364;μ̃_1365;Κ_2}:N-S-S * C{a_3<i_2>;μ̃_1364}:N-S-S * C{μ̃_1365;a_2<i_1,i_2>}:N-S-S * g{μ̃_1366;i_3;Κ_2}:N-S-S * C{a_4<i_1,i_3>;μ̃_1366}:N-S-S * s{μ̃_1367;μ̃_1368}:N-S-S * C{a_5<i_1,i_3>;μ̃_1367}:N-S-S * C{μ̃_1368;a_1<i_1,i_2>}:N-S-S * t{a_3<i_2>;i_2}:N-N-S * t{a_4<i_1,i_3>,a_5<i_1,i_3>;i_1,i_3}:N-N-S + 2 g{i_1;i_3;Κ_2}:N-S-S * g{μ̃_1369;i_4;Κ_2}:N-S-S * C{a_3<i_2>;μ̃_1369}:N-S-S * s{μ̃_1370;μ̃_1371}:N-S-S * C{a_2<i_1,i_2>;μ̃_1370}:N-S-S * C{μ̃_1371;a_5<i_3,i_4>}:N-S-S * s{μ̃_1372;μ̃_1373}:N-S-S * C{a_4<i_3,i_4>;μ̃_1372}:N-S-S * C{μ̃_1373;a_1<i_1,i_2>}:N-S-S * t{a_3<i_2>;i_2}:N-N-S * t{a_4<i_3,i_4>,a_5<i_3,i_4>;i_3,i_4}:N-N-S + 2 g{μ̃_1374;i_3;Κ_2}:N-S-S * C{a_3<i_1,i_3>;μ̃_1374}:N-S-S * g{μ̃_1375;i_4;Κ_2}:N-S-S * C{a_4<i_1,i_3>;μ̃_1375}:N-S-S * s{μ̃_1376;μ̃_1377}:N-S-S * C{a_1<i_1,i_2>;μ̃_1376}:N-S-S * C{μ̃_1377;a_5<i_2,i_4>}:N-S-S * s{μ̃_1378;μ̃_1379}:N-S-S * C{a_2<i_1,i_2>;μ̃_1378}:N-S-S * C{μ̃_1379;a_6<i_2,i_4>}:N-S-S * t{a_3<i_1,i_3>,a_4<i_1,i_3>;i_1,i_3}:N-N-S * t{a_5<i_2,i_4>,a_6<i_2,i_4>;i_4,i_2}:N-N-S - 2 f{i_3;i_1}:N-S-S * s{μ̃_1380;μ̃_1381}:N-S-S * C{a_3<i_2,i_3>;μ̃_1380}:N-S-S * C{μ̃_1381;a_2<i_1,i_2>}:N-S-S * s{μ̃_1382;μ̃_1383}:N-S-S * C{a_4<i_2,i_3>;μ̃_1382}:N-S-S * C{μ̃_1383;a_1<i_1,i_2>}:N-S-S * t{a_3<i_2,i_3>,a_4<i_2,i_3>;i_2,i_3}:N-N-S + g{μ̃_1384;μ̃_1385;Κ_2}:N-S-S * C{a_1<i_1,i_2>;μ̃_1384}:N-S-S * C{μ̃_1385;a_3<i_1>}:N-S-S * g{μ̃_1386;μ̃_1387;Κ_2}:N-S-S * C{a_2<i_1,i_2>;μ̃_1386}:N-S-S * C{μ̃_1387;a_4<i_2>}:N-S-S * t{a_3<i_1>;i_1}:N-N-S * t{a_4<i_2>;i_2}:N-N-S + 2 g{μ̃_1388;i_3;Κ_2}:N-S-S * C{a_3<i_1,i_4>;μ̃_1388}:N-S-S * g{μ̃_1389;i_4;Κ_2}:N-S-S * C{a_4<i_2,i_3>;μ̃_1389}:N-S-S * s{μ̃_1390;μ̃_1391}:N-S-S * C{a_1<i_1,i_2>;μ̃_1390}:N-S-S * C{μ̃_1391;a_5<i_1,i_4>}:N-S-S * s{μ̃_1392;μ̃_1393}:N-S-S * C{a_2<i_1,i_2>;μ̃_1392}:N-S-S * C{μ̃_1393;a_6<i_2,i_3>}:N-S-S * t{a_3<i_1,i_4>,a_5<i_1,i_4>;i_1,i_4}:N-N-S * t{a_4<i_2,i_3>,a_6<i_2,i_3>;i_3,i_2}:N-N-S + 4 g{i_3;μ̃_1394;Κ_2}:N-S-S * C{μ̃_1394;a_3<i_2,i_3>}:N-S-S * g{μ̃_1395;i_1;Κ_2}:N-S-S * C{a_1<i_1,i_2>;μ̃_1395}:N-S-S * s{μ̃_1396;μ̃_1397}:N-S-S * C{a_4<i_2,i_3>;μ̃_1396}:N-S-S * C{μ̃_1397;a_2<i_1,i_2>}:N-S-S * t{a_3<i_2,i_3>,a_4<i_2,i_3>;i_3,i_2}:N-N-S - 4 g{μ̃_1398;i_3;Κ_2}:N-S-S * C{a_3<i_3,i_4>;μ̃_1398}:N-S-S * g{μ̃_1399;i_4;Κ_2}:N-S-S * C{a_4<i_1,i_2>;μ̃_1399}:N-S-S * s{μ̃_1400;μ̃_1401}:N-S-S * C{a_1<i_1,i_2>;μ̃_1400}:N-S-S * C{μ̃_1401;a_5<i_3,i_4>}:N-S-S * t{a_2<i_1,i_2>,a_4<i_1,i_2>;i_2,i_1}:N-N-S * t{a_3<i_3,i_4>,a_5<i_3,i_4>;i_3,i_4}:N-N-S - 4 g{μ̃_1402;i_3;Κ_2}:N-S-S * C{a_3<i_3>;μ̃_1402}:N-S-S * g{μ̃_1403;i_4;Κ_2}:N-S-S * C{a_4<i_2>;μ̃_1403}:N-S-S * s{μ̃_1404;μ̃_1405}:N-S-S * C{a_5<i_1,i_4>;μ̃_1404}:N-S-S * C{μ̃_1405;a_1<i_1,i_2>}:N-S-S * s{μ̃_1406;μ̃_1407}:N-S-S * C{a_6<i_1,i_4>;μ̃_1406}:N-S-S * C{μ̃_1407;a_2<i_1,i_2>}:N-S-S * t{a_3<i_3>;i_3}:N-N-S * t{a_4<i_2>;i_2}:N-N-S * t{a_5<i_1,i_4>,a_6<i_1,i_4>;i_1,i_4}:N-N-S + g{μ̃_1408;i_3;Κ_2}:N-S-S * C{a_3<i_1,i_3>;μ̃_1408}:N-S-S * g{μ̃_1409;i_4;Κ_2}:N-S-S * C{a_4<i_2,i_4>;μ̃_1409}:N-S-S * s{μ̃_1410;μ̃_1411}:N-S-S * C{a_1<i_1,i_2>;μ̃_1410}:N-S-S * C{μ̃_1411;a_5<i_1,i_3>}:N-S-S * s{μ̃_1412;μ̃_1413}:N-S-S * C{a_2<i_1,i_2>;μ̃_1412}:N-S-S * C{μ̃_1413;a_6<i_2,i_4>}:N-S-S * t{a_3<i_1,i_3>,a_5<i_1,i_3>;i_1,i_3}:N-N-S * t{a_4<i_2,i_4>,a_6<i_2,i_4>;i_2,i_4}:N-N-S
diff --git a/tests/unit/test_eval_dryrun.cpp b/tests/unit/test_eval_dryrun.cpp
index ad9c13710f..2df754450a 100644
--- a/tests/unit/test_eval_dryrun.cpp
+++ b/tests/unit/test_eval_dryrun.cpp
@@ -38,13 +38,36 @@
 //   4. a self-consistency memsize check against SizeRegime's own extents/
 //      moments (replaces the unreachable cluster K-anchors).
 
+// Flip Trace::Default -> Trace::On for this ENTIRE translation unit (must
+// precede every SeQuant/core/eval/eval.hpp inclusion, directly or
+// transitively -- header include guards mean the Trace enum's Default member
+// is fixed, for this whole TU, by whether this macro is defined before the
+// header's FIRST inclusion). This is load-bearing for the [dryrun-eval]
+// replay below: make_batched_custom_evaluator's inner per-batch/per-member
+// replay calls `evaluate(*mem, le_g, bs.cache)` WITHOUT an explicit `<Trace::
+// ...>` argument, so those nested calls (and their note_working_set() calls,
+// which are gated at COMPILE TIME on the EvalTrace template argument, not
+// just Logger's runtime level) only fire if Trace::Default resolves to On.
+// Without this, working_set_hwmark() would reflect only the outermost
+// custom-evaluator interception and stay blind to everything the batched
+// replay does inside it -- exactly the visibility Task 6's witness needs.
+// mpqc's own C60 trace (614336.log, cited throughout this file) was captured
+// the same way (SEQUANT_EVAL_TRACE defined in that build).
+#define SEQUANT_EVAL_TRACE 1
+
+#include <SeQuant/core/eval/backends/dryrun/cost_model_object.hpp>
+#include <SeQuant/core/eval/backends/dryrun/eval_expr.hpp>
+#include <SeQuant/core/eval/backends/dryrun/result.hpp>
 #include <SeQuant/core/eval/backends/dryrun/size_regime.hpp>
 
+#include <SeQuant/core/batch_policy.hpp>
+#include <SeQuant/core/eval/eval.hpp>
 #include <SeQuant/core/eval/eval_expr.hpp>
 #include <SeQuant/core/expr.hpp>
 #include <SeQuant/core/expressions/tensor.hpp>
 #include <SeQuant/core/index.hpp>
 #include <SeQuant/core/io/shorthands.hpp>
+#include <SeQuant/core/logger.hpp>
 #include <SeQuant/core/optimize/optimize.hpp>
 #include <SeQuant/core/optimize/options.hpp>
 #include <SeQuant/core/optimize/single_term_detail.hpp>
@@ -56,6 +79,7 @@
 #include <catch2/catch_approx.hpp>
 #include <catch2/catch_test_macros.hpp>
 
+#include <chrono>
 #include <cmath>
 #include <cstddef>
 #include <fstream>
@@ -476,3 +500,733 @@ TEST_CASE(
   REQUIRE(n_summands_with_nonempty_axes_entry > 0);
   SUCCEED();
 }
+
+// ===========================================================================
+// POST-TRANSFORM VERDICT: the actual PAO(mu~)/DF-aux(K) go/no-go probe.
+//
+// Fixture data/csv_ccsd_doubles_residual_df.txt is the CSV CCSD DOUBLES
+// residual dumped from mpqc (repro/w8-batch-min.json) at the EXACT point it is
+// handed to sequant::optimize() -- i.e. AFTER the CSV->PAO base transform and
+// DF refactorization. It therefore contains the real PAO index "mu~"
+// (μ̃_NNNN) and DF-aux index "K" (Κ_N), the 3-center DF integrals
+// g{μ̃;i;Κ}, and the CSV coefficients C{a<i>;μ̃}. Standalone SeQuant's default
+// mbpt registry has neither mu~ nor K, so we augment a cloned context with
+// mbpt::add_pao_spaces (mu~) + mbpt::add_df_spaces (K).
+//
+// This case reproduces, offline and in milliseconds, the batched-objective DP
+// decision that on the cluster left the free-mu~ giant un-sliced (single-mode
+// aux batching -> OOM). It reports, per contraction node carrying a free mu~,
+// whether the DP annotated a mu~ (or K) batch axis -- the localizing signal:
+//   - if the giant mu~-carrying intermediate never gets a mu~ axis even as its
+//     modeled size dwarfs the threshold => the COST MODEL / DP is the gap;
+//   - if it does get one here => the gap is downstream (binarize/runtime).
+// The DryRun harness's value is that the SAME fixture can be swept across size
+// regimes (water-8 vs C60) by changing only the SizeRegime extents.
+// ===========================================================================
+
+namespace {
+
+// Regime for the post-transform (mu~ + K) residual. Extents are per-index
+// domain sizes fed to the DP's idx_to_extent; proto-indexed "a" legs are
+// PNO/OSV composites sized by the moment tables (same dispatch as the
+// pre-transform regime). Defaults are water-8-scale (from the w8-batch-min
+// run: active occ = 32, DF aux cc-pvdz-ri = 672, avg PNOs/pair ~19); the
+// giant-relevant knob is the mu~ (PAO domain) extent, swept below.
+SizeRegime df_regime(std::size_t mu_tilde, std::size_t aux, std::size_t i_occ,
+                     double pno, double osv) {
+  SizeRegime r;
+  r.space_extent = {
+      {L"i", i_occ},
+      {L"μ̃", mu_tilde},
+      {L"Κ", aux},
+      {L"a", mu_tilde},  // bare "a" should not appear (all a are proto here)
+  };
+  for (std::size_t k = 0; k <= 4; ++k) {
+    r.csv_pno_moment[k] = std::pow(pno, double(k));
+    r.csv_osv_moment[k] = std::pow(osv, double(k));
+  }
+  return r;
+}
+
+// Batchable = the two axes mpqc's runtime batches on the CSV path: PAO (mu~)
+// and DF aux (K). Both are non-proto base spaces (mu~ = PAO, K = DFBS aux).
+bool is_df_batchable(Index const& ix) {
+  auto const k = ix.space().base_key();
+  return k == L"μ̃" || k == L"Κ";
+}
+
+}  // namespace
+
+TEST_CASE("dryrun POST-transform PAO/K batch-axis verdict", "[dryrun-df]") {
+  // Augment the default mbpt registry with PAO (mu~) and DF-aux (K) so the
+  // post-transform fixture deserializes; raise the dummy-ordinal ceiling for
+  // mpqc's high internal ordinals (mu~_1152, a_21674, ...).
+  auto ctx = get_default_context().clone();
+  ctx.set_first_dummy_index_ordinal(1000000);
+  auto isr = ctx.mutable_index_space_registry();
+  REQUIRE(isr != nullptr);
+  sequant::mbpt::add_pao_spaces(isr);  // mu~
+  sequant::mbpt::add_df_spaces(isr);   // K
+  auto ctx_resetter = set_scoped_default_context(std::move(ctx));
+
+  auto const body = slurp(std::string(SEQUANT_UNIT_TESTS_SOURCE_DIR) +
+                          "/data/csv_ccsd_doubles_residual_df.txt");
+  REQUIRE(!body.empty());
+
+  // The fixture body is a single line: one Sum of Products (the whole doubles
+  // residual). Deserialize, then split into summands and re-flatten each
+  // (deserialize keeps literal nesting; single_term_opt needs a flat factor
+  // list or term_batch_axes silently comes back empty -- see the mechanics
+  // case above).
+  std::string line = body;
+  if (auto nl = line.find('\n'); nl != std::string::npos)
+    line = line.substr(0, nl);
+  auto expr = deserialize<ExprPtr>(line);
+  bool const parsed = static_cast<bool>(expr);
+  REQUIRE(parsed);
+
+  auto flatten_product = [](ExprPtr const& e) -> ExprPtr {
+    if (!e->is<Product>()) return e;
+    auto const& p = e->as<Product>();
+    return ex<Product>(p.scalar(), p.factors(), Product::Flatten::Yes);
+  };
+  std::vector<ExprPtr> terms;
+  if (expr->is<Sum>())
+    for (auto const& s : expr->as<Sum>()) terms.push_back(flatten_product(s));
+  else
+    terms.push_back(flatten_product(expr));
+  REQUIRE(!terms.empty());
+  std::wcout << L"\n=== POST-TRANSFORM DOUBLES RESIDUAL: " << terms.size()
+             << L" summands (mu~ + K present) ===\n";
+
+  // One regime (C60-scale mu~ domain) at the C60 peak_threshold. Per-term
+  // progress + timing to std::cerr (unbuffered) so a slow/pathological term is
+  // visible; each term reports whether its largest free-mu~ intermediate got a
+  // mu~/K batch axis.
+  double const peak_threshold = 40e9;  // 40 GB, matches the C60 run
+  // C60 pVDZ-F12 scale
+  auto regime = df_regime(/*mu_tilde=*/1800u, /*aux=*/4320u, /*i_occ=*/32u,
+                          /*pno=*/19.0, /*osv=*/57.0);
+  auto memsize = sequant::opt::detail::memsize_counter(regime.idx_to_extent(),
+                                                       regime.inner_pow_fn());
+  auto has_free_mu_tilde = [](std::vector<Index> const& ixs) {
+    for (auto const& ix : ixs)
+      if (ix.space().base_key() == L"μ̃") return true;
+    return false;
+  };
+
+  std::size_t total_mu_nodes = 0, n_terms_with_giant = 0;
+  std::size_t total_mu_nodes_with_mu_axis = 0, total_mu_nodes_with_k_only = 0;
+  double overall_biggest = 0.0;
+  bool overall_biggest_has_mu = false, overall_biggest_has_k = false;
+  std::wstring overall_biggest_desc, overall_biggest_axes;
+
+  for (std::size_t ti = 0; ti < terms.size(); ++ti) {
+    auto t0 = std::chrono::steady_clock::now();
+    std::cerr << "[dryrun-df] optimizing term " << (ti + 1) << "/"
+              << terms.size() << " ..." << std::flush;
+
+    auto axes_map = std::make_shared<std::unordered_map<
+        Expr const*, container::vector<container::svector<Index>>>>();
+    OptimizeOptions opts;
+    opts.objective_function = ObjectiveFunction::DensePeakSizeBatched;
+    opts.idx_to_extent = regime.idx_to_extent();
+    opts.inner_pow = regime.inner_pow_fn();
+    opts.batch_policy.is_batchable_index = is_df_batchable;
+    opts.batch_policy.batch_target_size = [](Index const&) {
+      return std::size_t{100};
+    };
+    opts.batch_policy.peak_threshold = peak_threshold;
+    opts.term_batch_axes = axes_map;
+
+    auto term = optimize(terms[ti], opts);
+    if (!static_cast<bool>(term)) {
+      std::cerr << " (skipped)\n";
+      continue;
+    }
+    auto it = axes_map->find(term.get());
+    container::vector<container::svector<Index>> node_axes;
+    if (it != axes_map->end()) node_axes = it->second;
+    BinarizationOptions bopts;
+    bopts.node_batch_axes = node_axes;
+    SEQUANT_PRAGMA_IGNORE_DEPRECATED_BEGIN
+    auto node = binarize(term, {}, bopts);
+    SEQUANT_PRAGMA_IGNORE_DEPRECATED_END
+
+    // Does a node's batch_axes contain a mu~ / a K axis specifically?
+    auto axis_has = [](auto const& n, std::wstring const& base) {
+      for (auto const& ax : n->batch_axes())
+        if (ax.space().base_key() == base) return true;
+      return false;
+    };
+    double term_biggest = 0.0;
+    std::wstring term_biggest_desc, term_biggest_axes;
+    bool term_biggest_has_mu = false, term_biggest_has_k = false;
+    std::size_t term_mu_nodes = 0;
+    node.visit_internal([&](auto const& n) {
+      auto free_ixs = node_free_indices(*n);
+      if (!has_free_mu_tilde(free_ixs)) return;
+      ++term_mu_nodes;
+      ++total_mu_nodes;
+      bool const has_mu = axis_has(n, L"μ̃");
+      bool const has_k = axis_has(n, L"Κ");
+      if (has_mu) ++total_mu_nodes_with_mu_axis;
+      if (has_k && !has_mu) ++total_mu_nodes_with_k_only;
+      double const bytes =
+          memsize(free_ixs, std::vector<Index>{}, std::vector<Index>{}) * 8.0;
+      // For a genuinely large (un-sliced would-be OOM) free-mu~ node, print its
+      // full index set AND its exact batch axes so we can see mu~ vs K.
+      if (bytes > 5e10) {
+        std::wcerr << L"\n  [GIANT " << (bytes / 1e9) << L"GB] free={"
+                   << describe_indices(free_ixs) << L"} batch_axes={"
+                   << describe_indices(container::vector<Index>(
+                          n->batch_axes().begin(), n->batch_axes().end()))
+                   << L"} mu~axis=" << (has_mu ? L"YES" : L"NO") << L" Kaxis="
+                   << (has_k ? L"YES" : L"NO") << L"\n";
+      }
+      if (bytes > term_biggest) {
+        term_biggest = bytes;
+        term_biggest_desc = describe_indices(free_ixs);
+        term_biggest_has_mu = has_mu;
+        term_biggest_has_k = has_k;
+        term_biggest_axes = describe_indices(container::vector<Index>(
+            n->batch_axes().begin(), n->batch_axes().end()));
+      }
+    });
+    if (term_mu_nodes > 0) ++n_terms_with_giant;
+    if (term_biggest > overall_biggest) {
+      overall_biggest = term_biggest;
+      overall_biggest_desc = term_biggest_desc;
+      overall_biggest_axes = term_biggest_axes;
+      overall_biggest_has_mu = term_biggest_has_mu;
+      overall_biggest_has_k = term_biggest_has_k;
+    }
+    auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(
+                  std::chrono::steady_clock::now() - t0)
+                  .count();
+    std::cerr << " " << ms << "ms  free-mu~ nodes=" << term_mu_nodes
+              << " biggest=" << (term_biggest / 1e9)
+              << "GB mu~axis=" << (term_biggest_has_mu ? "YES" : "NO")
+              << " Kaxis=" << (term_biggest_has_k ? "YES" : "NO") << "\n";
+  }
+
+  std::wcerr << L"\n=== POST-TRANSFORM VERDICT (mu~=1800, thr=40GB) ===\n"
+             << L"terms with a free-mu~ intermediate: " << n_terms_with_giant
+             << L"/" << terms.size() << L"\n"
+             << L"free-mu~ contraction nodes: " << total_mu_nodes << L"\n"
+             << L"  ... with a mu~ batch axis:      "
+             << total_mu_nodes_with_mu_axis << L"\n"
+             << L"  ... with a K-ONLY batch axis:   "
+             << total_mu_nodes_with_k_only << L"\n"
+             << L"LARGEST free-mu~ intermediate: {" << overall_biggest_desc
+             << L"} = " << (overall_biggest / 1e9) << L" GB\n"
+             << L"  batch_axes = {" << overall_biggest_axes << L"}\n"
+             << L"  -> mu~ sliced: "
+             << (overall_biggest_has_mu ? L"YES" : L"NO") << L" | K sliced: "
+             << (overall_biggest_has_k ? L"YES" : L"NO") << L"\n"
+             << L"INTERPRETATION: if the giant has K-only (mu~=NO), the DP "
+                L"reproduces the C60 single-mode-aux symptom -> cost-model "
+                L"gap; if mu~=YES, the DP slices mu~ and the C60 bug is "
+                L"downstream (binarize/runtime).\n";
+
+  REQUIRE(total_mu_nodes > 0);
+  SUCCEED();
+}
+
+// ===========================================================================
+// Task 2-6: DryRun eval BACKEND (zero-data Result + eval_expr) and the
+// end-to-end replay harness that WITNESSES the runtime's batch-axis
+// realization on the real post-transform giant term. The POST-TRANSFORM
+// VERDICT case above established the DP side of this story (the DP DOES
+// annotate a mu~ batch axis on the giant, surviving binarize). These new
+// cases do NOT modify anything above; [dryrun-probe]/[dryrun-df] stay exactly
+// as committed.
+// ===========================================================================
+
+namespace {
+
+using sequant::eval::dryrun::CostModel;
+using sequant::eval::dryrun::DryRunLeafEvaluator;
+using sequant::eval::dryrun::EvalExprDryRun;
+using sequant::eval::dryrun::EvalNodeDryRun;
+using sequant::eval::dryrun::ExtentOverrides;
+using sequant::eval::dryrun::make_dryrun_result;
+using sequant::eval::dryrun::ResultDryRun;
+using sequant::eval::dryrun::ResultDryRunNested;
+
+// A small, self-consistent regime for the backend unit tests below (distinct
+// from c60_regime()/df_regime() above -- this one just needs a couple of
+// named spaces plus non-trivial PNO moments).
+SizeRegime backend_test_regime() {
+  SizeRegime r;
+  r.space_extent = {
+      {L"i", 10},
+      {L"a", 20},
+  };
+  double const pno = 4.0;
+  for (std::size_t k = 0; k <= 4; ++k)
+    r.csv_pno_moment[k] = std::pow(pno, double(k));
+  r.csv_osv_moment = r.csv_pno_moment;
+  return r;
+}
+
+std::array<std::any, 3> annot3(container::svector<Index> l,
+                               container::svector<Index> r,
+                               container::svector<Index> res) {
+  return {std::any{std::move(l)}, std::any{std::move(r)},
+          std::any{std::move(res)}};
+}
+
+}  // namespace
+
+TEST_CASE("dryrun cost model memsize matches memsize_counter",
+          "[dryrun-costmodel]") {
+  auto r = backend_test_regime();
+  CostModel cm{r};
+  container::svector<Index> idx{Index{L"i_1"}, Index{L"i_2"}, Index{L"a_4"}};
+  auto direct = sequant::opt::detail::memsize_counter(
+      r.idx_to_extent(), r.inner_pow_fn())(idx, container::svector<Index>{},
+                                           container::svector<Index>{});
+  CHECK(cm.memsize(idx) == static_cast<std::size_t>(direct * 8.0));
+}
+
+TEST_CASE("dryrun cost model memsize honors an extent override",
+          "[dryrun-costmodel]") {
+  auto r = backend_test_regime();
+  CostModel cm{r};
+  container::svector<Index> idx{Index{L"a_3"}, Index{L"i_1"}};
+  auto const full = cm.memsize(idx);
+  ExtentOverrides ov;
+  ov[Index{L"a_3"}] = 5;  // narrowed from 20 to 5
+  auto const sliced = cm.memsize(idx, ov);
+  CHECK(sliced < full);
+  CHECK(full == sliced * 4);  // linear in a_3's extent
+}
+
+TEST_CASE("dryrun cost model flops and exec_cost are finite/positive",
+          "[dryrun-costmodel]") {
+  auto r = backend_test_regime();
+  CostModel cm{r};
+  container::svector<Index> out{Index{L"a_3"}, Index{L"i_1"}};
+  container::svector<Index> contracted{Index{L"i_2"}};
+  auto const f = cm.flops(out, contracted);
+  CHECK(f > 0.0);
+  CHECK(cm.exec_cost(f, cm.memsize(out), 4096) > 0.0);
+}
+
+TEST_CASE("dryrun flat result size delegates to cost model",
+          "[dryrun-result]") {
+  // Result::prod/sum/permute/slice_mode/mode_batches/size_in_bytes are all
+  // overridden PRIVATE in the concrete DryRun classes (mirroring
+  // ResultTensorTAPP), since real callers only ever reach a Result through a
+  // ResultPtr/Result const& (base-class access); tests that want to call
+  // them on a concrete object must do the same -- via a `Result const&`.
+  auto r = backend_test_regime();
+  auto cm = std::make_shared<CostModel const>(r);
+  container::svector<Index> idx{Index{L"i_1"}, Index{L"i_2"}, Index{L"a_4"}};
+  ResultDryRun t{idx, cm};
+  Result const& rt = t;
+  CHECK(rt.size_in_bytes() == cm->memsize(idx));
+}
+
+TEST_CASE("dryrun flat result prod yields the result annotation index set",
+          "[dryrun-result]") {
+  auto r = backend_test_regime();
+  auto cm = std::make_shared<CostModel const>(r);
+  ResultDryRun l{{Index{L"a_3"}, Index{L"i_2"}}, cm};
+  ResultDryRun rr{{Index{L"i_2"}, Index{L"i_1"}}, cm};
+  Result const& rl = l;
+  container::svector<Index> res{Index{L"a_3"}, Index{L"i_1"}};
+  auto out = rl.prod(rr, annot3(l.indices(), rr.indices(), res), DeNest::False);
+  REQUIRE(out);
+  bool const is_flat = out->is<ResultDryRun>();
+  CHECK(is_flat);
+  auto const& ot = out->as<ResultDryRun>();
+  CHECK(ot.indices() == res);
+  CHECK(out->size_in_bytes() == cm->memsize(res));
+}
+
+TEST_CASE("dryrun flat result full contraction yields a scalar",
+          "[dryrun-result]") {
+  auto r = backend_test_regime();
+  auto cm = std::make_shared<CostModel const>(r);
+  ResultDryRun l{{Index{L"i_1"}}, cm};
+  ResultDryRun rr{{Index{L"i_1"}}, cm};
+  Result const& rl = l;
+  auto out = rl.prod(rr, annot3(l.indices(), rr.indices(), {}), DeNest::False);
+  REQUIRE(out);
+  bool const is_scalar = out->is<ResultScalar<double>>();
+  CHECK(is_scalar);
+}
+
+TEST_CASE("dryrun flat result slice_mode shrinks the sliced mode",
+          "[dryrun-result]") {
+  auto r = backend_test_regime();
+  auto cm = std::make_shared<CostModel const>(r);
+  ResultDryRun t{{Index{L"a_3"}, Index{L"i_2"}}, cm};  // mu~ extent 20
+  Result const& rt = t;
+  auto const full = rt.size_in_bytes();
+  auto sliced = rt.slice_mode(0, 0, 5);  // quarter of mu~
+  REQUIRE(sliced);
+  CHECK(sliced->size_in_bytes() < full);
+  CHECK(sliced->size_in_bytes() == full / 4);
+}
+
+TEST_CASE("dryrun flat result mode_batches tiles the mode extent",
+          "[dryrun-result]") {
+  auto r = backend_test_regime();
+  auto cm = std::make_shared<CostModel const>(r);
+  ResultDryRun t{{Index{L"a_3"}, Index{L"i_2"}}, cm};
+  Result const& rt = t;
+  auto batches = rt.mode_batches(0, 5);  // 20 / 5 = 4 batches
+  CHECK(batches.size() == 4);
+  CHECK(batches.front().first == 0);
+  CHECK(batches.back().second == 20);
+}
+
+TEST_CASE("dryrun nested result uses moment-aware inner extent, not extent^k",
+          "[dryrun-nested]") {
+  auto r = backend_test_regime();
+  // Non-trivial second moment: <#PNO^2> != <#PNO>^2 (dispersion inflates it).
+  r.csv_pno_moment[1] = 4.0;
+  r.csv_pno_moment[2] = 4.0 * 4.0 * 1.5;
+  auto cm = std::make_shared<CostModel const>(r);
+
+  Index i1{L"i_1"}, i2{L"i_2"};
+  Index a_pno{L"a_1", {i1, i2}};  // proto-indexed (CSV/PNO composite) leg
+  container::svector<Index> outer{i1, i2, Index{L"a_3"}};
+  container::svector<Index> inner{a_pno};
+  ResultDryRunNested c{outer, inner, cm};
+
+  CHECK(c.outer() == outer);
+  CHECK(c.inner() == inner);
+
+  container::svector<Index> combined = outer;
+  combined.push_back(a_pno);
+  CHECK(c.indices() == combined);
+
+  auto const without_composite = cm->memsize(outer);  // just i1*i2*mu~
+  auto const with_composite = cm->memsize(combined);  // routes a_pno via k=1
+  // The composite contributes the FIRST moment (4.0), not extent(a_pno)^1
+  // (a_pno's own "extent" as a bare, non-composite space is never queried
+  // here -- only backend_test_regime()'s csv_pno_moment[1] is), so the ratio
+  // is exactly the first moment.
+  CHECK(with_composite == without_composite * 4);
+  Result const& rc = c;
+  CHECK(rc.size_in_bytes() == with_composite);
+}
+
+TEST_CASE("dryrun make_dryrun_result dispatches flat vs nested by content",
+          "[dryrun-nested]") {
+  auto r = backend_test_regime();
+  auto cm = std::make_shared<CostModel const>(r);
+  Index i1{L"i_1"}, i2{L"i_2"};
+  Index a_pno{L"a_1", {i1, i2}};
+
+  auto flat = make_dryrun_result({Index{L"i_1"}, Index{L"i_2"}}, cm);
+  CHECK(flat->is<ResultDryRun>());
+
+  auto nested = make_dryrun_result({i1, i2, a_pno}, cm);
+  CHECK(nested->is<ResultDryRunNested>());
+}
+
+TEST_CASE("dryrun leaf yielder builds a sized token from a tensor leaf",
+          "[dryrun-leaf]") {
+  auto ctx = get_default_context().clone();
+  ctx.set_first_dummy_index_ordinal(1000000);
+  auto ctx_resetter = set_scoped_default_context(std::move(ctx));
+
+  auto r = backend_test_regime();
+  auto cm = std::make_shared<CostModel const>(r);
+
+  auto expr = deserialize<ExprPtr>("g{i_1,i_2;a_4}");
+  bool const parsed = static_cast<bool>(expr);
+  REQUIRE(parsed);
+
+  SEQUANT_PRAGMA_IGNORE_DEPRECATED_BEGIN
+  auto node = binarize<EvalExprDryRun>(expr);
+  SEQUANT_PRAGMA_IGNORE_DEPRECATED_END
+  REQUIRE(node.leaf());
+
+  DryRunLeafEvaluator yield{cm};
+  auto res = yield(node);
+  REQUIRE(res);
+  bool const is_flat = res->is<ResultDryRun>();
+  CHECK(is_flat);
+
+  container::svector<Index> idx{Index{L"i_1"}, Index{L"i_2"}, Index{L"a_4"}};
+  CHECK(res->size_in_bytes() == cm->memsize(idx));
+}
+
+// ===========================================================================
+// Task 6: THE replay harness. Deserializes the real post-transform giant
+// term (the FIRST summand of csv_ccsd_doubles_residual_df.txt -- see the
+// POST-TRANSFORM VERDICT case above, which already established this is the
+// ~13-tensor free-mu~ giant), optimizes it once under the SAME C60-scale
+// regime/BatchPolicy the DP verdict used, binarizes with the DP's
+// batch-axis annotations, then REPLAYS it through the REAL runtime
+// (make_evaluator / evaluate<Trace::On>) against zero-data DryRun tokens --
+// witnessing what the runtime actually realizes, not what the DP annotated.
+// ===========================================================================
+
+TEST_CASE(
+    "dryrun eval backend replays the post-transform giant term through the "
+    "real batched runtime",
+    "[dryrun-eval]") {
+  auto ctx = get_default_context().clone();
+  ctx.set_first_dummy_index_ordinal(1000000);
+  auto isr = ctx.mutable_index_space_registry();
+  REQUIRE(isr != nullptr);
+  sequant::mbpt::add_pao_spaces(isr);  // mu~
+  sequant::mbpt::add_df_spaces(isr);   // K
+  auto ctx_resetter = set_scoped_default_context(std::move(ctx));
+
+  auto const body = slurp(std::string(SEQUANT_UNIT_TESTS_SOURCE_DIR) +
+                          "/data/csv_ccsd_doubles_residual_df.txt");
+  REQUIRE(!body.empty());
+  std::string line = body;
+  if (auto nl = line.find('\n'); nl != std::string::npos)
+    line = line.substr(0, nl);
+  auto expr = deserialize<ExprPtr>(line);
+  bool const parsed = static_cast<bool>(expr);
+  REQUIRE(parsed);
+  bool const is_sum = expr->is<Sum>();
+  REQUIRE(is_sum);
+
+  // Focus the replay on the GIANT TERM only -- the batched DP is 20-60s per
+  // term (running it on all 55 would take ~20-30 minutes). The [dryrun-df]
+  // verdict case above's exhaustive sweep (`for (auto const& s :
+  // expr->as<Sum>()) ...`, the SAME deserialize-order iteration as
+  // `summands()` below) empirically identified summand index 38 (term 39/55,
+  // 1-indexed in that sweep's log) as the giant: the ~13-tensor
+  // g.C.g.C.s.C.C.s.C.C.t.t.t chain reporting the 1.2 TB free-mu~
+  // intermediate at C60 (mu~=1800, K=4320) scale. A cheap proxy (picking the
+  // summand with the most flattened tensor factors) was tried first and
+  // picked a DIFFERENT, structurally-similar but much smaller term (14
+  // factors, ~0.0005 GB giant) -- factor count alone does not identify the
+  // giant, only the DP's actual index-space accounting does. So this uses
+  // the exhaustively-verified positional index directly rather than a
+  // heuristic that was empirically shown to pick the wrong term.
+  auto const& summands = expr->as<Sum>().summands();
+  REQUIRE(!summands.empty());
+  auto flatten_product = [](ExprPtr const& e) -> ExprPtr {
+    if (!e->is<Product>()) return e;
+    auto const& p = e->as<Product>();
+    return ex<Product>(p.scalar(), p.factors(), Product::Flatten::Yes);
+  };
+  std::size_t const giant_idx = 38 < summands.size() ? 38 : 0;
+  ExprPtr giant = flatten_product(summands[giant_idx]);
+  REQUIRE(giant);
+  std::size_t const giant_nfactors =
+      giant->is<Product>() ? giant->as<Product>().factors().size() : 1;
+  std::cerr << "[dryrun-eval] selected giant term (index " << giant_idx
+            << "): " << giant_nfactors << " flattened factors (of "
+            << summands.size() << " summands)\n";
+
+  // C60 pVDZ-F12 scale regime -- SAME regime and SAME batchable predicate the
+  // [dryrun-df] verdict case used (df_regime/is_df_batchable, defined above).
+  auto regime = df_regime(/*mu_tilde=*/1800u, /*aux=*/4320u, /*i_occ=*/32u,
+                          /*pno=*/19.0, /*osv=*/57.0);
+  auto cm = std::make_shared<CostModel const>(regime);
+
+  // ONE BatchPolicy object, reused verbatim for both optimize() and the
+  // runtime evaluator factory (make_evaluator) -- the plan's hard
+  // constraint, so the DP's and the runtime's notion of "batchable" and
+  // "target batch size" cannot drift apart.
+  sequant::BatchPolicy policy;
+  policy.is_batchable_index = is_df_batchable;
+  policy.batch_target_size = [](Index const&) { return std::size_t{100}; };
+  policy.peak_threshold = 40e9;  // DP-side knob only; the runtime evaluator
+                                 // never consults peak_threshold.
+
+  auto axes_map = std::make_shared<std::unordered_map<
+      Expr const*, container::vector<container::svector<Index>>>>();
+  OptimizeOptions opts;
+  opts.objective_function = ObjectiveFunction::DensePeakSizeBatched;
+  opts.idx_to_extent = regime.idx_to_extent();
+  opts.inner_pow = regime.inner_pow_fn();
+  opts.batch_policy = policy;
+  opts.term_batch_axes = axes_map;
+
+  auto t0 = std::chrono::steady_clock::now();
+  auto optimized = optimize(giant, opts);
+  auto const opt_ms = std::chrono::duration_cast<std::chrono::milliseconds>(
+                          std::chrono::steady_clock::now() - t0)
+                          .count();
+  std::cerr << "[dryrun-eval] optimize(giant) took " << opt_ms << "ms\n";
+  bool const have_optimized = static_cast<bool>(optimized);
+  REQUIRE(have_optimized);
+
+  auto it = axes_map->find(optimized.get());
+  container::vector<container::svector<Index>> node_axes;
+  if (it != axes_map->end()) node_axes = it->second;
+  REQUIRE(!node_axes.empty());
+
+  BinarizationOptions bopts;
+  bopts.node_batch_axes = node_axes;
+
+  SEQUANT_PRAGMA_IGNORE_DEPRECATED_BEGIN
+  auto node = binarize<EvalExprDryRun>(optimized, {}, bopts);
+  SEQUANT_PRAGMA_IGNORE_DEPRECATED_END
+
+  // Locate the giant sub-node (the free-mu~ contraction node whose modeled
+  // size dwarfs everything else -- same identification criterion the
+  // [dryrun-df] verdict case above used) purely to REPORT what the DP
+  // annotated on it before the runtime replay, for side-by-side comparison
+  // with what the runtime actually realizes.
+  auto memsize_ext = sequant::opt::detail::memsize_counter(
+      regime.idx_to_extent(), regime.inner_pow_fn());
+  auto has_free_mu_tilde = [](std::vector<Index> const& ixs) {
+    for (auto const& ix : ixs)
+      if (ix.space().base_key() == L"μ̃") return true;
+    return false;
+  };
+  double giant_nominal_bytes = 0.0;
+  std::wstring giant_desc, giant_axes_desc;
+  node.visit_internal([&](auto const& n) {
+    auto free_ixs = node_free_indices(*n);
+    if (!has_free_mu_tilde(free_ixs)) return;
+    double const bytes =
+        memsize_ext(free_ixs, std::vector<Index>{}, std::vector<Index>{}) * 8.0;
+    if (bytes > giant_nominal_bytes) {
+      giant_nominal_bytes = bytes;
+      giant_desc = describe_indices(free_ixs);
+      giant_axes_desc = describe_indices(container::vector<Index>(
+          n->batch_axes().begin(), n->batch_axes().end()));
+    }
+  });
+  REQUIRE(giant_nominal_bytes > 0.0);
+
+  auto cache = sequant::cache_manager(std::vector<EvalNodeDryRun>{node});
+  cache.set_custom_evaluator(
+      sequant::make_evaluator(policy, DryRunLeafEvaluator{cm}));
+
+  // Enable eval tracing (redirected to a private ostringstream, not stdout)
+  // so working_set_hwmark() actually accumulates: the engine's per-op hwmark
+  // input is gated at RUNTIME on Logger::instance().eval.level > 0
+  // (log::printing()), independent of the Trace::On COMPILE-TIME template
+  // argument below (which only gates whether the tracing code path exists at
+  // all). Restore the previous logger state afterward so this test does not
+  // leak global state to others.
+  std::ostringstream trace_os;
+  auto& logger = Logger::instance();
+  auto const prev_level = logger.eval.level;
+  auto* const prev_stream = logger.eval.stream;
+  logger.eval.level = 2;
+  logger.eval.stream = &trace_os;
+
+  std::cerr << "[dryrun-eval] replaying giant term through the batched "
+               "runtime evaluator ...\n";
+  auto t1 = std::chrono::steady_clock::now();
+  ResultPtr result;
+  bool threw = false;
+  std::string what;
+  try {
+    result = sequant::evaluate<Trace::On>(node, DryRunLeafEvaluator{cm}, cache);
+  } catch (std::exception const& e) {
+    threw = true;
+    what = e.what();
+  }
+  auto const eval_ms = std::chrono::duration_cast<std::chrono::milliseconds>(
+                           std::chrono::steady_clock::now() - t1)
+                           .count();
+
+  logger.eval.level = prev_level;
+  logger.eval.stream = prev_stream;
+
+  INFO("evaluate() threw: " << what);
+  REQUIRE(!threw);
+  REQUIRE(result);
+
+  auto const peak = cache.working_set_hwmark();
+  auto const root_bytes = result->size_in_bytes();
+
+  // Parse the captured per-op trace for the largest single `result=<N>B`
+  // materialized anywhere during the replay -- the most direct witness of
+  // whether the giant was EVER realized at (close to) its full un-sliced
+  // size, regardless of caching/accounting nuances in working_set_hwmark().
+  std::size_t max_single_result_bytes = 0;
+  {
+    std::string const trace = trace_os.str();
+    std::size_t pos = 0;
+    while ((pos = trace.find("result=", pos)) != std::string::npos) {
+      pos += std::string("result=").size();
+      std::size_t end = trace.find('B', pos);
+      if (end == std::string::npos) break;
+      std::string const num = trace.substr(pos, end - pos);
+      if (!num.empty() &&
+          num.find_first_not_of("0123456789") == std::string::npos) {
+        std::size_t const v = std::stoull(num);
+        max_single_result_bytes = std::max(max_single_result_bytes, v);
+      }
+      pos = end;
+    }
+  }
+
+  bool const giant_realized_full =
+      max_single_result_bytes >= 0.9 * giant_nominal_bytes;
+
+  // Extra corroborating diagnostics: how many ops ran, and how many distinct
+  // BatchGroup interceptions fired (a real nested multi-batch replay should
+  // show many -- the giant's mu~ (extent 1800, target 100 => ~18 batches) and
+  // K (extent 4320, target 100 => ~44 batches) axes, nested, would fire
+  // hundreds of small batched ops if genuinely realized).
+  std::string const trace = trace_os.str();
+  auto count_occurrences = [](std::string const& hay,
+                              std::string const& needle) {
+    std::size_t n = 0, pos = 0;
+    while ((pos = hay.find(needle, pos)) != std::string::npos) {
+      ++n;
+      pos += needle.size();
+    }
+    return n;
+  };
+  std::size_t const n_eval_lines = count_occurrences(trace, "Eval |");
+  std::size_t const n_batch_group_begin =
+      count_occurrences(trace, "BatchGroup | Begin");
+  // Distribution of result= sizes >= 100 MB, to see whether many large
+  // (but sub-nominal) intermediates appeared (consistent with a partially-
+  // sliced axis) or none did (consistent with the OTHER axis alone already
+  // bounding everything well below 100 MB).
+  std::size_t n_results_over_100mb = 0;
+  {
+    std::size_t pos = 0;
+    while ((pos = trace.find("result=", pos)) != std::string::npos) {
+      pos += std::string("result=").size();
+      std::size_t end = trace.find('B', pos);
+      if (end == std::string::npos) break;
+      std::string const num = trace.substr(pos, end - pos);
+      if (!num.empty() &&
+          num.find_first_not_of("0123456789") == std::string::npos) {
+        if (std::stoull(num) >= 100'000'000ull) ++n_results_over_100mb;
+      }
+      pos = end;
+    }
+  }
+
+  std::wcout << L"\n=== [dryrun-eval] GIANT TERM RUNTIME REPLAY ===\n"
+             << L"optimize(): " << opt_ms << L"ms, evaluate(): " << eval_ms
+             << L"ms\n"
+             << L"DP-annotated giant: free={" << giant_desc << L"} nominal="
+             << (giant_nominal_bytes / 1e9) << L" GB batch_axes={"
+             << giant_axes_desc << L"}\n"
+             << L"root result size = " << root_bytes << L" bytes ("
+             << (double(root_bytes) / 1e9) << L" GB)\n"
+             << L"cache.working_set_hwmark() = " << peak << L" bytes ("
+             << (double(peak) / 1e9) << L" GB)\n"
+             << L"max single result= observed in trace = "
+             << max_single_result_bytes << L" bytes ("
+             << (double(max_single_result_bytes) / 1e9) << L" GB)\n"
+             << L"trace ops: " << n_eval_lines << L" Eval lines, "
+             << n_batch_group_begin << L" BatchGroup interceptions, "
+             << n_results_over_100mb << L" results >=100MB\n"
+             << L"=> giant realized at (>=90% of) its FULL nominal size during "
+                L"replay: "
+             << (giant_realized_full
+                     ? L"YES (mu~ NOT sliced in practice -- bug "
+                       L"reproduced)"
+                     : L"NO (sliced down from nominal)")
+             << L"\n";
+
+  CHECK(peak > 0);
+}

From 326ad9be9eba4df6f9e8db69b698cae4879c594d Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Sun, 5 Jul 2026 00:18:21 -0400
Subject: [PATCH 24/78] optimize: design perf-first (DenseTimeSpace)
 single-term objective

Add a design spec for a perf-first / peak-second single-term optimization
objective. The existing DensePeakSize model is peak-first: peak_threshold is a
hard filter over factorizations and FLOPS only breaks ties among survivors.
With PAO (mu-tilde) sliceable this structurally prefers the fully-sliceable but
FLOPS-catastrophic 4-PAO integral over the correct (gC)(gC) PPL, whose PNO-pair
leg has an irreducible peak floor above the threshold. This is the C60
PNO-CCSD OOM root cause.

The fix swaps the primary/secondary keys in the two frontier selectors
(select_root, pareto_best), keeping peak_threshold as the slice-down-to target
rather than the feasibility gate. Slicing is perf-neutral in the roofline model
(cflops computed once on unsliced sizes), so a roofline-perf primary rejects the
4-PAO and leaves slicing to the peak-second key.

Names encode the lexicographic order (Dense{Primary}{Secondary}, Space=peak,
Time=perf): rename DensePeakSize -> DenseSpaceTime (peak-first, kept as a
deprecated alias), add DenseTimeSpace (perf-first, new).
---
 ...perf-first-peak-second-objective-design.md | 262 ++++++++++++++++++
 1 file changed, 262 insertions(+)
 create mode 100644 doc/dev/specs/2026-07-05-perf-first-peak-second-objective-design.md

diff --git a/doc/dev/specs/2026-07-05-perf-first-peak-second-objective-design.md b/doc/dev/specs/2026-07-05-perf-first-peak-second-objective-design.md
new file mode 100644
index 0000000000..88c4f5b89f
--- /dev/null
+++ b/doc/dev/specs/2026-07-05-perf-first-peak-second-objective-design.md
@@ -0,0 +1,262 @@
+# Perf-first / peak-second single-term optimization objective
+
+**Goal:** Add a perf-first, peak-second selection policy to the single-term
+optimizer's peak cost model so that batching-optional factorization *rejects*
+FLOPS-catastrophic factorizations (e.g. the 4-PAO AO-basis integral) instead of
+*preferring* them for their fully-sliceable peak. Keep the existing
+peak-first objectives unchanged (non-breaking).
+
+**Architecture:** Reuse the existing Pareto-frontier + roofline-cache-hybrid
+machinery verbatim. Change *only* the two frontier *selectors* to sort by
+`(roofline-perf, then peak)` instead of `(peak, then flops)`. `peak_threshold`
+shifts from a primary hard feasibility filter to a secondary "slice-down-to"
+target. Exposed as a new `ObjectiveFunction` value pair so current behavior is
+preserved.
+
+**Tech stack:** SeQuant C++20, `SeQuant/core/optimize/`.
+
+---
+
+## Problem and motivation
+
+The current peak-first objective (`DensePeakSizeBatched`, renamed
+`DenseSpaceTimeBatched` below) selects a schedule by `select_root`
+(`cost_model.hpp:692`): among root-frontier points with `peak <= peak_threshold`
+pick minimum flops (ties by lower peak); if none fit, minimum peak. The
+`peak_threshold` is thus a **hard filter over factorizations**, and FLOPS only
+breaks ties *among survivors*.
+
+For the CSV-CC particle-particle-ladder (PPL) term this is pathological. With
+PAO (mu-tilde) made sliceable, two factorizations compete at
+`peak_threshold = 40 GB` (C60, occ=120, PNO=42, mu-tilde=1800, aux=4320):
+
+- **Correct `(gC)(gC)`:** the giant `I(i,i,mu~,K;a<i,i>)` has an *irreducible*
+  floor -- its PNO-pair leg `a<i,i>` is not sliceable, so even slicing both
+  mu-tilde and aux leaves ~89 GB > 40 GB. **Filtered out.**
+- **`g.g -> 4-PAO` `(mu~ mu~|mu~ mu~)`:** every axis is a sliceable PAO;
+  slicing all four drives peak to ~34 GB < 40 GB. **Survives.** Its FLOPS
+  (~mu-tilde^4 . aux) are astronomically higher, but they never get a vote
+  because it is the sole feasible point.
+
+So peak-first *structurally prefers* forming the AO 4-index integral -- the one
+thing DF+PNO exists to avoid.
+
+### Evidence (DryRun harness, `tests/unit/test_eval_dryrun.cpp`)
+
+- **aux+PAO sliceable:** the DP forms the 4-PAO monster (`mu~^4`, nominal
+  83980 GB) and slices all four axes to 34 GB. Faithful to the objective, not a
+  harness artifact -- the cost model is the same one MPQC uses.
+- **aux-only (`DRYRUN_AUX_ONLY=1`, aux_ts=35):** no 4-PAO appears, but the
+  correct factorization's giants stay mu-tilde-full: largest realized
+  `{mu~ mu~ i i} = 373 GB` (carries no aux -> *immune* to aux batching at any
+  tile size, explaining why the cluster's `aux_target_size=35` run still OOM'd),
+  plus the proper giant `{mu~ a<i,i> K} = 305 GB`. Aux-only avoids the
+  pathology but cannot reduce the mu-tilde-full giants -> OOM.
+
+Peak-first is therefore broken both ways: aux-only OOMs on mu-tilde-full giants;
+aux+PAO "fixes" peak only by choosing the FLOPS-catastrophic 4-PAO.
+
+### Why the swap fixes it, and why it is safe
+
+Two facts make a pure order-swap correct:
+
+1. **Factorization sets FLOPS; slicing sets PEAK.** The correct `(gC)^2` is
+   min-flops; the 4-PAO is max-flops. A perf-first primary rejects the 4-PAO at
+   the factorization level, before slicing is even considered.
+2. **Slicing is perf-neutral in this model.** In `relax()`
+   (`cost_model.hpp:415, 633`) the per-node roofline cost `cflops` is computed
+   **once, before the batch/slice loops**, on the **unsliced** footprints
+   (`ctx.sz(*, 0)`) and full `flops_of`, then added identically to every
+   `(B, Ap)` frontier point. So all slicings of a factorization share one
+   `flops`(=roofline) coordinate and differ only in `peak`. A perf-first primary
+   therefore leaves slicing entirely to the peak-second selector -- it never
+   under-slices. (This retires the earlier worry that roofline would penalize
+   slicing's re-reads; the model deliberately does not charge per-batch
+   re-read traffic -- see the `relax()` comment "slicing reduces peak, not total
+   work".)
+
+`roofline_op_cost` (`cost_model.hpp:281`) is
+`max(flops, beta * max(traffic, kappa * flops / sqrt(M/c0)))`: compute-bound ops
+reduce to `flops`, bandwidth-bound ops to `beta*Q`. This is retained as the
+perf primary precisely because raw FLOPS cannot distinguish the bandwidth-bound
+tensor products that occur in PNO-CC; it is exactly the metric that should rank
+factorizations.
+
+---
+
+## Design
+
+### Objective naming (`Dense{Primary}{Secondary}`)
+
+The objective names encode the lexicographic optimization order directly:
+`Space` = peak/size, `Time` = perf (roofline), and the name lists primary then
+secondary. This gives a clean symmetric pair in `ObjectiveFunction`
+(`options.hpp:46`):
+
+- `DenseSpaceTime` / `DenseSpaceTimeBatched` -- peak-first, perf-second
+  (the current behavior). **Rename** of `DensePeakSize` / `DensePeakSizeBatched`,
+  which become deprecated aliases (kept so existing inputs and pinned MPQC do
+  not break).
+- `DenseTimeSpace` / `DenseTimeSpaceBatched` -- perf-first, peak-second
+  (**new**). This is the objective that fixes the C60 pathology.
+
+(`DensePeakSize` alone was ambiguous -- "Peak" can read as either peak *memory*
+or peak *performance*; `Space`/`Time` are unambiguous.)
+
+The aliases are implemented as enumerators that share the underlying value of
+the renamed constant (`DensePeakSize = DenseSpaceTime`,
+`DensePeakSizeBatched = DenseSpaceTimeBatched`), placed AFTER the four primary
+enumerators so `DenseSpaceTime` keeps the old numeric value of `DensePeakSize`
+(ABI-stable). Because the alias and its target compare equal, every existing
+`Metric == DensePeakSize` guard (in `single_term.hpp` and `optimize.cpp`) keeps
+working unchanged and catches `DenseSpaceTime`; only the two NEW values
+(`DenseTimeSpace{,Batched}`) need fresh arms.
+
+`DenseSpaceTime{,Batched}` keep their current semantics byte-for-byte. The
+auto-route (a `DenseTimeSpace` request with an active `is_batchable_index`
+becomes `DenseTimeSpaceBatched`) mirrors the existing route in MPQC's
+`SeQuantEngine::make_optimize_options` (`sequant_engine.cpp:182-195`).
+
+### Why the selector is a plain lexicographic swap
+
+The Pareto frontier already carries everything the selection needs, and its
+structure makes the perf-first rule trivial. `pareto_insert`
+(`cost_model.hpp:250`) drops any point dominated in BOTH `(peak, flops)`, so for
+two points with the SAME flops the higher-peak one is pruned: the frontier
+retains exactly one min-peak point per distinct flops value. Sorted by peak
+ascending, flops is therefore strictly descending -- a clean trade-off curve.
+
+Two consequences:
+
+1. **The min-flops frontier point is already the fully-sliced (min-peak)
+   realization of the cheapest factorization.** There is no separate "slice
+   more" choice to make at selection time -- the DP's `relax()` explored every
+   slicing (`Ap` subset) and the frontier collapsed each flops class to its
+   lowest peak. So an earlier draft's "among perf-ties, pick least-sliced under
+   threshold" steps are unreachable: the frontier never holds two perf-tied
+   points at different peaks.
+2. **`argmin(flops, then peak)` picks the cheapest factorization AND gets it
+   maximally sliced.** For C60 that is `(gC)(gC)` (moderate flops), never the
+   4-PAO (flops ~ mu-tilde^4 . aux); and the chosen `(gC)(gC)` point is its
+   own min-peak (fully sliced on mu-tilde and aux). Both goals in one key.
+
+So the whole behavioral change is: both `PeakModel` (`cost_model.hpp:303`) and
+`PeakBatchedModel` (`cost_model.hpp:486`) gain a `bool perf_first = false` field
+(set true for the new objectives), and the selectors sort by `(flops, then
+peak)` instead of `(peak, then flops)` when it is set. The Pareto frontier
+construction (`pareto_insert`, `relax`, the DP recurrence) is **unchanged**.
+
+**`PeakBatchedModel::select_root` (`cost_model.hpp:692`)** -- perf-first branch:
+plain `argmin(flops, ties by peak)` over the root `B=0` frontier `st[root][0]`
+(the flops-primary analog of `pareto_best`). `peak_threshold` is NOT consulted:
+it can no longer act as a hard filter that forces a FLOPS-catastrophic
+factorization for its sliceability (the exact peak-first pathology). The DP
+still explores slicing unconditionally, so the chosen point is already
+peak-minimized. `peak_threshold` remains a documented knob for the peak-first
+objective and is emitted as a diagnostic under perf-first when the selected
+peak exceeds it (informational only, no behavior change).
+
+**`PeakModel::reconstruct` (`cost_model.hpp:437-453`)** -- perf-first branch:
+plain `argmin(flops, ties by peak)` over the root frontier, bypassing the
+`peak_flops_tolerance` epsilon relaxation (a peak-first knob). The non-batched
+model has no slicing and no `peak_threshold`.
+
+(`pareto_best` at `cost_model.hpp:263` is used only by the test helper
+`reconstructed_batched_peak`, which reconstructs the peak *value* and must stay
+peak-min; it is NOT a production factorization selector and is left unchanged.)
+
+### Data flow
+
+`single_term_opt` (`single_term.hpp:65`) constructs the model from the
+compile-time `Metric` template parameter via an `if constexpr` chain. It already
+selects `PeakModel` vs `PeakBatchedModel` and threads `peak_threshold`,
+`volatile_weight`, `roofline`; the two peak arms are broadened to also match the
+new `DenseTimeSpace` / `DenseTimeSpaceBatched` values, and each sets
+`model.perf_first = (Metric == DenseTimeSpace[Batched])` on the constructed
+model. `optimize.cpp:103-125` gains dispatch arms for the two new enum values
+(the batched one also routes `out_axes`, mirroring `DenseSpaceTimeBatched`). No
+other call site changes: `reconstruct` / `reconstruct_axes` already route
+through `select_root`, and the batch-axis annotation path
+(`term_batch_axes -> node_batch_axes -> EvalExpr::batch_axes_`) is untouched.
+
+### What does NOT change
+
+- Frontier construction and dominance (`pareto_insert`, `relax`, `sliced_footprints`).
+- The roofline cost function, `volatile_weight`, `accumulation_factor`.
+- Runtime batched evaluator (`eval.hpp`) -- it consumes the same annotations.
+- `DenseSpaceTime`/`DenseSpaceTimeBatched` (formerly `DensePeakSize*`) behavior
+  and all their tests -- only the enum name changes, semantics are identical.
+
+---
+
+## MPQC wiring
+
+`SeQuantEngine` (`sequant_engine.{h,cpp}`): extend the
+`optimize:objective_function` keyword parser to accept the new canonical strings
+`dense_space_time` (-> `DenseSpaceTime`) and `dense_time_space`
+(-> `DenseTimeSpace`) alongside `dense_flops` / `dense_size`, and keep
+`dense_peak_size` as a deprecated alias for `dense_space_time` so pinned/existing
+inputs still parse. Add the auto-route to `DenseTimeSpaceBatched` when
+`is_batchable_index` is set (mirroring the existing peak-first route at
+`sequant_engine.cpp:182-195`). No change to the `batch:*` keywords:
+`peak_threshold`, `aux_target_size`, `pao_target_size` retain their meaning and
+values.
+
+CCk input migration is a one-line objective change per input
+(`dense_peak_size -> dense_time_space`); no numeric retuning of `peak_threshold`
+is required.
+
+---
+
+## Validation (DryRun harness, before any cluster run)
+
+The harness already replays a schedule's predicted sizes with the real cost
+model. Add a perf-first path (drive `run_single_term_opt` with the new
+objective) and assert, on the real post-transform C60 residual at faithful
+config (occ=120, PNO=42, OSV=310, mu-tilde=1800, aux=4320, pao_ts=256,
+aux_ts=72, peak_threshold=40 GB):
+
+1. **No 4-PAO:** no `mu~^4` (four-free-PAO) node appears in any summand's
+   optimized tree.
+2. **Correct factorization:** the PPL giant is the 1-free-PAO
+   `I(i,i,mu~,K;a<i,i>)` form (matches the real trace).
+3. **Giants slice under threshold:** the largest realized free-mu-tilde
+   intermediate is `<= peak_threshold` (the 373 GB `{mu~ mu~ i i}` giant slices
+   both mu-tilde to ~7.6 GB; the 305 GB giant slices to <= 40 GB).
+4. **A/B vs peak-first:** the same residual under `DenseSpaceTimeBatched`
+   reproduces the 4-PAO (regression guard that the swap is what changed the
+   outcome).
+
+Only after the harness confirms 1-4 do we consider a C60 cluster run.
+
+---
+
+## Testing
+
+- **Unit (`tests/unit/test_optimize.cpp`):** a minimal PPL-shaped term
+  (`g.g` reducible to a 4-PAO vs `(gC)(gC)`) with a small extent regime and a
+  finite `peak_threshold`: assert `DenseSpaceTimeBatched` selects the 4-PAO and
+  `DenseTimeSpaceBatched` selects `(gC)(gC)`. A second case with
+  `peak_threshold=+inf` asserts `DenseTimeSpace` reduces to min-perf-then-peak.
+- **Unit (non-batched):** assert `pareto_best`'s perf-first branch returns the
+  min-flops (not min-peak) frontier point on a hand-built frontier.
+- **Unit (alias):** assert the `dense_peak_size` keyword still parses to
+  `DenseSpaceTime` (backward-compat guard).
+- **Harness (`test_eval_dryrun.cpp`):** the four C60 assertions above.
+- **Regression:** existing `DenseSpaceTime*` (formerly `DensePeakSize*`) tests
+  must be byte-unchanged (the new field defaults `perf_first=false`).
+
+---
+
+## Global constraints
+
+- No en-dashes (U+2013) or non-breaking spaces (U+00A0); ASCII hyphens only
+  (pre-commit hook rejects otherwise).
+- No `Co-Authored-By` trailers in commit messages.
+- Cross-repo: this is a SeQuant change; MPQC consumes it via the pin in
+  `external/versions.cmake` (`MPQC_TRACKED_SEQUANT_TAG`). The SeQuant change and
+  the MPQC wiring land as separate commits/PRs; MPQC repins only after the
+  SeQuant objective merges.
+- `DenseSpaceTime` / `DenseSpaceTimeBatched` (formerly `DensePeakSize*`)
+  semantics and outputs must not change; the old names remain as deprecated
+  aliases.

From 8d6e8ed423769e14e33aa3966bb6bb0d438a31b7 Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Sun, 5 Jul 2026 00:32:03 -0400
Subject: [PATCH 25/78] optimize: implementation plan for perf-first
 (DenseTimeSpace) objective

---
 ...-07-05-perf-first-peak-second-objective.md | 746 ++++++++++++++++++
 1 file changed, 746 insertions(+)
 create mode 100644 doc/dev/plans/2026-07-05-perf-first-peak-second-objective.md

diff --git a/doc/dev/plans/2026-07-05-perf-first-peak-second-objective.md b/doc/dev/plans/2026-07-05-perf-first-peak-second-objective.md
new file mode 100644
index 0000000000..a4a0a1f744
--- /dev/null
+++ b/doc/dev/plans/2026-07-05-perf-first-peak-second-objective.md
@@ -0,0 +1,746 @@
+# Perf-first / peak-second objective (DenseTimeSpace) Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Add a perf-first / peak-second single-term optimization objective
+(`DenseTimeSpace` / `DenseTimeSpaceBatched`) that selects a factorization by
+roofline-perf first and peak second, so the optimizer never prefers a
+FLOPS-catastrophic factorization (the C60 4-PAO integral) merely because it is
+sliceable below `peak_threshold`.
+
+**Architecture:** Reuse the existing Pareto-frontier + roofline cost machinery
+verbatim. Add a `bool perf_first` flag to `PeakModel` / `PeakBatchedModel`; when
+set, the root-frontier selector sorts by `(flops, then peak)` instead of
+`(peak, then flops)`. Rename `DensePeakSize{,Batched}` to `DenseSpaceTime{,Batched}`
+(keeping the old names as deprecated aliases sharing the same enum values) and
+add the two new perf-first values. Wire the new objective through
+`single_term_opt`, `optimize.cpp`, and MPQC's `SeQuantEngine`.
+
+**Tech Stack:** SeQuant C++20 (`SeQuant/core/optimize/`), Catch2 unit tests,
+MPQC4 (`src/mpqc/.../sequant_engine.cpp`). SeQuant is the primary repo; MPQC
+consumes it via `FETCHCONTENT_SOURCE_DIR_SEQUANT` (local edits are live) and via
+the `MPQC_TRACKED_SEQUANT_TAG` pin (CI/clean builds; repin last).
+
+## Global Constraints
+
+- No en-dashes (U+2013) or non-breaking spaces (U+00A0) anywhere; ASCII hyphens
+  only. A pre-commit hook rejects both. (This applies to source, comments, and
+  commit messages.)
+- No `Co-Authored-By:` trailers in commit messages.
+- `DenseSpaceTime` / `DenseSpaceTimeBatched` (formerly `DensePeakSize*`) must
+  keep byte-for-byte identical behavior; the old names remain as deprecated
+  aliases with the same underlying enum values.
+- `perf_first` defaults to `false`; every existing model construction and test
+  must be unaffected.
+- The frontier construction (`pareto_insert`, `relax`, `sliced_footprints`, the
+  DP recurrence) does NOT change. `pareto_best` (test helper) does NOT change.
+- Naming: `Dense{Primary}{Secondary}`, `Space` = peak/size, `Time` = perf.
+- clang-format every changed C/C++ file before committing:
+  `/opt/homebrew/opt/llvm@17/bin/clang-format --style=file -i <file>`.
+- SeQuant unit test build/run (from a configured build dir, e.g.
+  `cmake-build-release`): `cmake --build cmake-build-release --target unit_tests-sequant`
+  then `./cmake-build-release/tests/unit/unit_tests-sequant "<test name>"`.
+- SeQuant threads internally: never run more than one unit-test binary at once.
+
+---
+
+### Task 1: Rename the enum and add the two perf-first values
+
+**Files:**
+- Modify: `SeQuant/core/optimize/options.hpp:46-51` (the `ObjectiveFunction` enum)
+- Modify: `SeQuant/core/optimize/options.hpp:19-45` (the doc comment above it)
+- Test: `tests/unit/test_optimize.cpp` (a new static-assert-style `SECTION`)
+
+**Interfaces:**
+- Produces: `ObjectiveFunction::DenseSpaceTime` (== old `DensePeakSize`, value 2),
+  `DenseSpaceTimeBatched` (== old `DensePeakSizeBatched`, value 3),
+  `DenseTimeSpace` (new, value 4), `DenseTimeSpaceBatched` (new, value 5), plus
+  deprecated aliases `DensePeakSize = DenseSpaceTime`,
+  `DensePeakSizeBatched = DenseSpaceTimeBatched`.
+
+- [ ] **Step 1: Write the failing test**
+
+Add this `SECTION` inside the existing `TEST_CASE("optimize", "[optimize]")`
+block in `tests/unit/test_optimize.cpp` (place it right after the opening of the
+test case's body, near the other structural sections):
+
+```cpp
+    SECTION("ObjectiveFunction aliases share enum values") {
+      using sequant::ObjectiveFunction;
+      // The deprecated names are aliases (same underlying value), so all
+      // existing `== DensePeakSize` guards keep catching the renamed constant.
+      STATIC_REQUIRE(ObjectiveFunction::DensePeakSize ==
+                     ObjectiveFunction::DenseSpaceTime);
+      STATIC_REQUIRE(ObjectiveFunction::DensePeakSizeBatched ==
+                     ObjectiveFunction::DenseSpaceTimeBatched);
+      // The new perf-first values are distinct from the peak-first ones.
+      STATIC_REQUIRE(ObjectiveFunction::DenseTimeSpace !=
+                     ObjectiveFunction::DenseSpaceTime);
+      STATIC_REQUIRE(ObjectiveFunction::DenseTimeSpaceBatched !=
+                     ObjectiveFunction::DenseSpaceTimeBatched);
+      // ABI: DenseSpaceTime keeps DensePeakSize's old numeric value (2).
+      STATIC_REQUIRE(static_cast<int>(ObjectiveFunction::DenseSpaceTime) == 2);
+    }
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `cmake --build cmake-build-release --target unit_tests-sequant`
+Expected: COMPILE FAILURE (`DenseSpaceTime` / `DenseTimeSpace` are not members
+of `ObjectiveFunction`).
+
+- [ ] **Step 3: Implement the enum rename + new values**
+
+Replace the enum at `SeQuant/core/optimize/options.hpp:46-51` with:
+
+```cpp
+enum class ObjectiveFunction {
+  DenseFLOPs,
+  DenseSize,
+  /// Peak-first, perf-second: minimize peak memory, break ties by roofline
+  /// perf. (Formerly `DensePeakSize`.)
+  DenseSpaceTime,
+  /// Batched variant of `DenseSpaceTime`. (Formerly `DensePeakSizeBatched`.)
+  DenseSpaceTimeBatched,
+  /// Perf-first, peak-second: minimize roofline perf, break ties by peak. This
+  /// never prefers a FLOPS-catastrophic factorization for its sliceability.
+  DenseTimeSpace,
+  /// Batched variant of `DenseTimeSpace`.
+  DenseTimeSpaceBatched,
+  /// Deprecated aliases (same underlying values as the renamed constants above,
+  /// placed AFTER them so `DenseSpaceTime` keeps `DensePeakSize`'s old value).
+  /// Kept so existing code and JSON inputs ("dense_peak_size") keep compiling.
+  DensePeakSize = DenseSpaceTime,
+  DensePeakSizeBatched = DenseSpaceTimeBatched
+};
+```
+
+Then, in the doc comment above (`options.hpp:19-45`), update the two bullet
+lines that describe `DensePeakSize` / `DensePeakSizeBatched` to name
+`DenseSpaceTime` / `DenseSpaceTimeBatched` (noting the old names are deprecated
+aliases), and add two bullets describing `DenseTimeSpace` /
+`DenseTimeSpaceBatched` as the perf-first / peak-second duals. Keep it factual;
+do not restate the whole design.
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `cmake --build cmake-build-release --target unit_tests-sequant && ./cmake-build-release/tests/unit/unit_tests-sequant "optimize"`
+Expected: PASS (the new `SECTION` compiles and its `STATIC_REQUIRE`s hold).
+
+- [ ] **Step 5: clang-format and commit**
+
+```bash
+/opt/homebrew/opt/llvm@17/bin/clang-format --style=file -i SeQuant/core/optimize/options.hpp tests/unit/test_optimize.cpp
+git add SeQuant/core/optimize/options.hpp tests/unit/test_optimize.cpp
+git commit -m "optimize: rename DensePeakSize -> DenseSpaceTime, add DenseTimeSpace values"
+```
+
+---
+
+### Task 2: Add `perf_first` and the perf-first selectors
+
+**Files:**
+- Modify: `SeQuant/core/optimize/cost_model.hpp:303-326` (add `perf_first` to `PeakModel`)
+- Modify: `SeQuant/core/optimize/cost_model.hpp:437-453` (perf-first branch in `PeakModel::reconstruct`)
+- Modify: `SeQuant/core/optimize/cost_model.hpp:486-524` (add `perf_first` to `PeakBatchedModel`)
+- Modify: `SeQuant/core/optimize/cost_model.hpp:692-719` (perf-first branch in `PeakBatchedModel::select_root`)
+
+**Interfaces:**
+- Consumes: nothing new.
+- Produces: `PeakModel::perf_first` and `PeakBatchedModel::perf_first` (both
+  `bool`, default `false`), added as the LAST data member of each struct so
+  existing positional aggregate initializers are unaffected. When `perf_first`
+  is set, `PeakModel::reconstruct` and `PeakBatchedModel::select_root` select by
+  `(flops, then peak)`.
+
+- [ ] **Step 1: Add the `perf_first` member to both models**
+
+In `PeakModel` (after the `peak_flops_tolerance` member at
+`cost_model.hpp:326`, before the `struct FrontPoint` declaration):
+
+```cpp
+  /// Perf-first / peak-second selection: when true, `reconstruct` selects the
+  /// root-frontier point by (flops, then peak) instead of (peak, then flops),
+  /// bypassing `peak_flops_tolerance`. Default false = peak-first (unchanged).
+  bool perf_first = false;
+```
+
+In `PeakBatchedModel` (after the `numeric_size` member at
+`cost_model.hpp:524`, before the `struct BFrontPoint` declaration):
+
+```cpp
+  /// Perf-first / peak-second selection: when true, `select_root` selects the
+  /// root-frontier point by (flops, then peak) and does NOT consult
+  /// `peak_threshold` as a feasibility gate (it can no longer force a
+  /// FLOPS-catastrophic factorization for its sliceability). Default false =
+  /// peak-first threshold-gated selection (unchanged).
+  bool perf_first = false;
+```
+
+- [ ] **Step 2: Write the failing test**
+
+Extend the existing `TEST_CASE("threshold gates batching: ...",
+"[optimize][threshold]")` in `tests/unit/test_optimize.cpp` (ends at line ~2264,
+right after `CHECK_FALSE(integral_at(2, 1.0));`). Add a perf-first variant of
+`integral_at` and the threshold-insensitivity checks. Insert BEFORE the closing
+`}` of that `TEST_CASE`:
+
+```cpp
+  // Perf-first (DenseTimeSpaceBatched): min-flops is primary and peak_threshold
+  // is NOT a feasibility gate, so the persistent Kappa-free integral (the
+  // min-(replay-weighted)-flops choice) is formed REGARDLESS of the threshold.
+  // Contrast the peak-first checks above: at a near-zero threshold peak-first
+  // fell back to min-peak (CHECK_FALSE), whereas perf-first still forms it.
+  auto integral_at_perf = [&](std::size_t Kb, double peak_threshold) -> bool {
+    std::function<std::size_t(Index const&)> bts = [Kb](Index const&) {
+      return Kb;
+    };
+    CostParams cost{is_t, 100.0, 0.0};
+    cost.peak_threshold = peak_threshold;
+    auto res = opt::single_term_opt<ObjectiveFunction::DenseTimeSpaceBatched>(
+        prod, idxsz, false, cost, is_batch, bts, ip);
+    return forms_integral(res);
+  };
+  // Threshold-insensitive: forms the integral at +inf AND at near-zero.
+  CHECK(integral_at_perf(/*Kb=*/2, inf));
+  CHECK(integral_at_perf(/*Kb=*/2, /*peak_threshold(bytes)=*/1.0));
+```
+
+- [ ] **Step 3: Run test to verify it fails**
+
+Run: `cmake --build cmake-build-release --target unit_tests-sequant && ./cmake-build-release/tests/unit/unit_tests-sequant "threshold gates batching*"`
+Expected: at Step 2 the build currently FAILS to compile (no
+`DenseTimeSpaceBatched` arm in `single_term_opt` yet -> `static_assert` fires or
+the arm is unreachable). If it compiles because Task 3 is not yet done, the
+second `CHECK(integral_at_perf(2, 1.0))` FAILS (perf-first not yet implemented;
+the value routes to the peak-first path and falls back to min-peak). Either way
+this task is not green until Steps 4 AND Task 3 are done. (If ordering makes the
+build fail here, that is an expected RED; proceed to Step 4, then complete Task
+3, then re-run.)
+
+- [ ] **Step 4: Implement the perf-first branch in `PeakBatchedModel::select_root`**
+
+At the TOP of `select_root` (`cost_model.hpp:692`), immediately after the
+`auto peak_bytes = ...;` lambda (line 698) and before `int best = -1;`, insert:
+
+```cpp
+    if (perf_first) {
+      // Perf-first / peak-second: min flops, ties by lower peak. The frontier
+      // keeps one min-peak point per distinct flops value (pareto_insert prunes
+      // equal-flops higher-peak points), so this both picks the cheapest
+      // factorization and takes its fully-sliced (min-peak) realization.
+      // peak_threshold is deliberately NOT consulted here.
+      int pbest = 0;
+      for (int i = 1; i < static_cast<int>(rootf.size()); ++i)
+        if (rootf[i].flops < rootf[pbest].flops ||
+            (rootf[i].flops == rootf[pbest].flops &&
+             rootf[i].peak < rootf[pbest].peak))
+          pbest = i;
+      return pbest;
+    }
+```
+
+- [ ] **Step 5: Implement the perf-first branch in `PeakModel::reconstruct`**
+
+At the TOP of `reconstruct` (`cost_model.hpp:437`), immediately after
+`size_t const full = st.size() - 1;` (line 439) and before the
+`// epsilon-tolerant selection` comment, insert:
+
+```cpp
+    if (perf_first) {
+      // Perf-first / peak-second (non-batched): min flops, ties by lower peak,
+      // bypassing the peak_flops_tolerance epsilon band (a peak-first knob).
+      auto const& rootf = st[full];
+      int pbest = 0;
+      for (int i = 1; i < static_cast<int>(rootf.size()); ++i)
+        if (rootf[i].flops < rootf[pbest].flops ||
+            (rootf[i].flops == rootf[pbest].flops &&
+             rootf[i].peak < rootf[pbest].peak))
+          pbest = i;
+      // Reuse the existing back-pointer walk with the chosen root index.
+      std::function<EvalSequence(size_t, int)> pbuild =
+          [&](size_t n, int idx) -> EvalSequence {
+        if (std::popcount(n) == 1)
+          return EvalSequence{static_cast<int>(std::countr_zero(n))};
+        FrontPoint const& fp = st[n][idx];
+        size_t const fs = fp.lp_first ? fp.lp : fp.rp;
+        int const fi = fp.lp_first ? fp.lp_idx : fp.rp_idx;
+        size_t const ss = fp.lp_first ? fp.rp : fp.lp;
+        int const si = fp.lp_first ? fp.rp_idx : fp.lp_idx;
+        EvalSequence s = pbuild(fs, fi);
+        EvalSequence b = pbuild(ss, si);
+        s.insert(s.end(), b.begin(), b.end());
+        s.push_back(-1);
+        return s;
+      };
+      return pbuild(full, pbest);
+    }
+```
+
+- [ ] **Step 6: Run the tests to verify they pass (after Task 3 is also done)**
+
+This task's test cannot go green until Task 3 wires `DenseTimeSpaceBatched`
+through `single_term_opt`. Complete Task 3, then run:
+`./cmake-build-release/tests/unit/unit_tests-sequant "threshold gates batching*"`
+Expected: PASS (both `integral_at_perf` checks true).
+
+- [ ] **Step 7: clang-format and commit** (after Task 3 compiles)
+
+```bash
+/opt/homebrew/opt/llvm@17/bin/clang-format --style=file -i SeQuant/core/optimize/cost_model.hpp
+git add SeQuant/core/optimize/cost_model.hpp
+git commit -m "optimize: add perf_first (flops, then peak) selectors to peak models"
+```
+
+---
+
+### Task 3: Wire the new objectives through `single_term_opt` and `optimize.cpp`
+
+**Files:**
+- Modify: `SeQuant/core/optimize/single_term.hpp:98-183` (the `if constexpr` chain)
+- Modify: `SeQuant/core/optimize/optimize.cpp:102-126` (the dispatch lambda)
+
+**Interfaces:**
+- Consumes: `PeakModel::perf_first`, `PeakBatchedModel::perf_first` (Task 2);
+  the four enum values (Task 1).
+- Produces: `single_term_opt<DenseTimeSpace>` and
+  `single_term_opt<DenseTimeSpaceBatched>` route to the peak models with
+  `perf_first = true`; `optimize()` dispatches both new objectives.
+
+- [ ] **Step 1: Broaden the non-batched peak arm in `single_term.hpp`**
+
+Change the arm header at `single_term.hpp:98` from:
+
+```cpp
+  if constexpr (Metric == ObjectiveFunction::DensePeakSize) {
+```
+to:
+```cpp
+  if constexpr (Metric == ObjectiveFunction::DenseSpaceTime ||
+                Metric == ObjectiveFunction::DenseTimeSpace) {
+```
+
+Then replace the `return run_single_term_opt(PeakModel{...}, network, tidxs);`
+statement (lines 109-114) with a named local that sets `perf_first`:
+
+```cpp
+    PeakModel model{idxsz,
+                    inner_pow,
+                    is_volatile_leaf,
+                    volatile_weight,
+                    roofline.machine_balance,
+                    roofline.fast_mem_elems,
+                    roofline.block_tiles,
+                    roofline.block_prefactor,
+                    peak_flops_tolerance};
+    model.perf_first = (Metric == ObjectiveFunction::DenseTimeSpace);
+    return run_single_term_opt(model, network, tidxs);
+```
+
+- [ ] **Step 2: Broaden the batched peak arm in `single_term.hpp`**
+
+Change the arm header at `single_term.hpp:115` from:
+
+```cpp
+  } else if constexpr (Metric == ObjectiveFunction::DensePeakSizeBatched) {
+```
+to:
+```cpp
+  } else if constexpr (Metric == ObjectiveFunction::DenseSpaceTimeBatched ||
+                       Metric == ObjectiveFunction::DenseTimeSpaceBatched) {
+```
+
+Then, immediately AFTER the `PeakBatchedModel model{...};` aggregate
+initialization (i.e. after line 135's `cost.peak_threshold};`), insert:
+
+```cpp
+    model.perf_first = (Metric == ObjectiveFunction::DenseTimeSpaceBatched);
+```
+
+- [ ] **Step 3: Update the trailing `static_assert` message**
+
+In the final `else` branch (`single_term.hpp:166-168`), update the message text
+to list the current objective names (informational only):
+
+```cpp
+    static_assert(Metric == ObjectiveFunction::DenseSize,
+                  "Only DenseFLOPs, DenseSize, DenseSpaceTime, "
+                  "DenseSpaceTimeBatched, DenseTimeSpace, and "
+                  "DenseTimeSpaceBatched ObjectiveFunction supported.");
+```
+
+- [ ] **Step 4: Add dispatch arms in `optimize.cpp`**
+
+Replace the body of the `run` lambda at `optimize.cpp:102-126` (from the first
+`if (opts.objective_function == ObjectiveFunction::DenseFLOPs)` through the final
+batched `return`) with:
+
+```cpp
+  auto run = [&]() -> ExprPtr {
+    if (opts.objective_function == ObjectiveFunction::DenseFLOPs)
+      return opt::single_term_opt<ObjectiveFunction::DenseFLOPs>(
+          prod, opts.idx_to_extent, subnet_cse, cost,
+          opts.batch_policy.is_batchable_index,
+          opts.batch_policy.batch_target_size, opts.inner_pow);
+    if (opts.objective_function == ObjectiveFunction::DenseSize)
+      return opt::single_term_opt<ObjectiveFunction::DenseSize>(
+          prod, opts.idx_to_extent, subnet_cse, cost,
+          opts.batch_policy.is_batchable_index,
+          opts.batch_policy.batch_target_size, opts.inner_pow);
+    if (opts.objective_function == ObjectiveFunction::DenseSpaceTime)
+      return opt::single_term_opt<ObjectiveFunction::DenseSpaceTime>(
+          prod, opts.idx_to_extent, subnet_cse, cost,
+          opts.batch_policy.is_batchable_index,
+          opts.batch_policy.batch_target_size, opts.inner_pow);
+    if (opts.objective_function == ObjectiveFunction::DenseTimeSpace)
+      return opt::single_term_opt<ObjectiveFunction::DenseTimeSpace>(
+          prod, opts.idx_to_extent, subnet_cse, cost,
+          opts.batch_policy.is_batchable_index,
+          opts.batch_policy.batch_target_size, opts.inner_pow);
+    if (opts.objective_function == ObjectiveFunction::DenseSpaceTimeBatched)
+      return opt::single_term_opt<ObjectiveFunction::DenseSpaceTimeBatched>(
+          prod, opts.idx_to_extent, subnet_cse, cost,
+          opts.batch_policy.is_batchable_index,
+          opts.batch_policy.batch_target_size, opts.inner_pow,
+          opts.batch_policy.persistent_only,
+          opts.term_batch_axes ? &node_axes : nullptr);
+    SEQUANT_ASSERT(opts.objective_function ==
+                   ObjectiveFunction::DenseTimeSpaceBatched);
+    return opt::single_term_opt<ObjectiveFunction::DenseTimeSpaceBatched>(
+        prod, opts.idx_to_extent, subnet_cse, cost,
+        opts.batch_policy.is_batchable_index,
+        opts.batch_policy.batch_target_size, opts.inner_pow,
+        opts.batch_policy.persistent_only,
+        opts.term_batch_axes ? &node_axes : nullptr);
+  };
+```
+
+(Note: `DenseSpaceTime` == `DensePeakSize` and `DenseSpaceTimeBatched` ==
+`DensePeakSizeBatched` as enum values, so these arms also cover the deprecated
+names.)
+
+- [ ] **Step 5: Build and run the full optimize + threshold tests**
+
+Run: `cmake --build cmake-build-release --target unit_tests-sequant && ./cmake-build-release/tests/unit/unit_tests-sequant "[optimize]"`
+Expected: PASS, including `optimize` (Task 1 section), `threshold gates
+batching*` (Task 2 perf-first checks), and all pre-existing `[optimize]` cases
+(regression: peak-first paths unchanged).
+
+- [ ] **Step 6: clang-format and commit**
+
+```bash
+/opt/homebrew/opt/llvm@17/bin/clang-format --style=file -i SeQuant/core/optimize/single_term.hpp SeQuant/core/optimize/optimize.cpp
+git add SeQuant/core/optimize/single_term.hpp SeQuant/core/optimize/optimize.cpp
+git commit -m "optimize: route DenseTimeSpace{,Batched} to perf-first peak models"
+```
+
+---
+
+### Task 4: Perf-first characterization test (perf-first matches flops-optimal factorization)
+
+**Files:**
+- Modify: `tests/unit/test_optimize.cpp` (extend the `[optimize][osv]` "PPL term:
+  form-W vs fold-t" TEST_CASE at line ~1943, which already has `idxsz`,
+  `is_batch`, `bts`, `ip`, `is_t`, `wflops`, `rep`, `prod`, `flops_w`)
+
+**Interfaces:**
+- Consumes: `DenseTimeSpaceBatched` (Task 3), the in-test `wflops` / `rep` /
+  `flops_w` helpers already defined in that TEST_CASE.
+
+- [ ] **Step 1: Write the failing test**
+
+Immediately after the existing `CHECK(pbat_w_vw1 > flops_w);` line (the last
+assertion of the "form-W vs fold-t" TEST_CASE, ~line 1941), insert:
+
+```cpp
+  // Perf-first (DenseTimeSpaceBatched) is flops-primary, so it forms the
+  // flop-optimal W REGARDLESS of peak_flops_tolerance and regardless of a tight
+  // peak_threshold: its replay-weighted flop count equals the FLOPs optimum.
+  // (Peak-first at strict tolerance did NOT: peak_w_strict > flops_w above.)
+  double tbat_w = rep(
+      L"TimeSpaceB/vw100:",
+      opt::single_term_opt<ObjectiveFunction::DenseTimeSpaceBatched>(
+          prod, idxsz, false, CostParams{is_t, 100.0, 0.0}, is_batch, bts, ip));
+  CHECK(tbat_w == flops_w);
+  // Even with a near-zero peak budget, perf-first stays flop-optimal (threshold
+  // is not a feasibility gate), unlike peak-first's min-peak fallback.
+  CostParams tight{is_t, 100.0, 0.0};
+  tight.peak_threshold = 1.0;
+  double tbat_w_tight =
+      rep(L"TimeSpaceB/tight:",
+          opt::single_term_opt<ObjectiveFunction::DenseTimeSpaceBatched>(
+              prod, idxsz, false, tight, is_batch, bts, ip));
+  CHECK(tbat_w_tight == flops_w);
+```
+
+- [ ] **Step 2: Run test to verify it fails, then passes**
+
+Run: `./cmake-build-release/tests/unit/unit_tests-sequant "*form-W vs fold-t*"`
+(the TEST_CASE name may differ; use `--list-tests "[osv]"` to find the exact
+name, then quote it). Expected BEFORE Task 3: compile/route failure. AFTER Tasks
+2-3: PASS (both `CHECK(... == flops_w)` hold).
+
+If `tbat_w != flops_w` unexpectedly, do NOT weaken the assertion. Investigate:
+dump `render_tree` of the perf-first result vs the `FLOPs` result; a mismatch
+means the perf-first selector is not reaching the flop-optimal factorization
+(re-check Task 2 Step 4/5 and that `machine_balance == 0` here so
+`roofline_op_cost` reduces to raw flops).
+
+- [ ] **Step 3: clang-format and commit**
+
+```bash
+/opt/homebrew/opt/llvm@17/bin/clang-format --style=file -i tests/unit/test_optimize.cpp
+git add tests/unit/test_optimize.cpp
+git commit -m "optimize: test DenseTimeSpaceBatched matches the flops-optimal factorization"
+```
+
+---
+
+### Task 5: MPQC SeQuantEngine keyword + auto-route
+
+**Files:**
+- Modify: `src/mpqc/chemistry/qc/lcao/expression/sequant_engine.cpp:51-69` (parser)
+- Modify: `src/mpqc/chemistry/qc/lcao/expression/sequant_engine.cpp:179-196` (auto-route)
+- Modify: `src/mpqc/chemistry/qc/lcao/expression/sequant_engine.h:87` (keyword doc)
+
+(All paths in the mpqc4 repo: `/Users/efv/code/mpqc4`.)
+
+**Interfaces:**
+- Consumes: `sequant::ObjectiveFunction::DenseTimeSpace{,Batched}` (Task 1),
+  live in local MPQC builds via `FETCHCONTENT_SOURCE_DIR_SEQUANT`.
+- Produces: `optimize:objective_function = "dense_time_space"` selects the
+  perf-first objective and auto-routes to `DenseTimeSpaceBatched` when a batch
+  policy is active. `"dense_peak_size"` and a new `"dense_space_time"` both map
+  to the peak-first `DenseSpaceTime`.
+
+- [ ] **Step 1: Extend the parser**
+
+In `sequant_engine.cpp`, replace the parse branches (lines 58-68) with:
+
+```cpp
+    if (of == "dense_flops")
+      objective_function_ = sequant::ObjectiveFunction::DenseFLOPs;
+    else if (of == "dense_size")
+      objective_function_ = sequant::ObjectiveFunction::DenseSize;
+    else if (of == "dense_space_time" || of == "dense_peak_size")
+      objective_function_ = sequant::ObjectiveFunction::DenseSpaceTime;
+    else if (of == "dense_time_space")
+      objective_function_ = sequant::ObjectiveFunction::DenseTimeSpace;
+    else
+      throw InputError(
+          "invalid \"sequant:optimize:objective_function\" (must be "
+          "\"dense_flops\", \"dense_size\", \"dense_space_time\" (alias "
+          "\"dense_peak_size\"), or \"dense_time_space\")",
+          __FILE__, __LINE__, "optimize:objective_function", of.c_str());
+```
+
+(The default-echo string at lines 51-57 stays as-is: the default is
+`DenseFLOPs`, and the else-arm's `"dense_peak_size"` fallback remains a valid
+alias for `DenseSpaceTime`.)
+
+- [ ] **Step 2: Extend the auto-route**
+
+Replace the auto-route block (lines 182-196) with:
+
+```cpp
+  if (objective_function_ == sequant::ObjectiveFunction::DenseSpaceTime ||
+      objective_function_ == sequant::ObjectiveFunction::DenseTimeSpace) {
+    if (!opts.idx_to_extent)
+      throw ProgrammingError(
+          "peak objectives require index extents (idx_to_extent on the "
+          "EvalContext)",
+          __FILE__, __LINE__);
+    if (opts.CSE.subnet)
+      throw InputError(
+          "sequant:optimize:objective_function peak objectives are "
+          "incompatible with sequant:optimize:cse:subnet=true",
+          __FILE__, __LINE__, "optimize:cse:subnet", "true");
+    if (opts.batch_policy.is_batchable_index)
+      opts.objective_function =
+          (objective_function_ == sequant::ObjectiveFunction::DenseTimeSpace)
+              ? sequant::ObjectiveFunction::DenseTimeSpaceBatched
+              : sequant::ObjectiveFunction::DenseSpaceTimeBatched;
+  }
+```
+
+- [ ] **Step 3: Update the keyword doc comment**
+
+In `sequant_engine.h:87`, change the `dense_flops, dense_size, or
+dense_peak_size` list to `dense_flops, dense_size, dense_space_time (alias
+dense_peak_size; peak-first), or dense_time_space (perf-first)`, keeping the
+rest of that Doxygen row intact and within the existing style.
+
+- [ ] **Step 4: Build MPQC and sanity-check the parser end-to-end**
+
+Build the mpqc target against the locally-edited SeQuant (release build dir):
+
+Run: `cmake --build /Users/efv/code/mpqc4/cmake-build-release --target mpqc 2>&1 | tail -30`
+Expected: links cleanly (the enum change + wiring compile in MPQC too).
+
+There is no dedicated parser unit test; verify via an existing CCk validation
+input. Pick the smallest CCk JSON that sets `optimize:objective_function`, copy
+it, change that value to `dense_time_space`, and run it once (serialized, single
+rank) to confirm it parses and completes without an InputError:
+
+Run: `MAD_NUM_THREADS=6 mpiexec -n 1 /Users/efv/code/mpqc4/cmake-build-release/src/bin/mpqc/mpqc <copied-input>.json 2>&1 | tail -40`
+Expected: no `invalid "sequant:optimize:objective_function"` error; the job runs
+the CCk solver. (A full numeric validation is not required here; Task 6 does the
+C60 dry-run. This step only confirms the keyword plumbs through.)
+
+- [ ] **Step 5: clang-format and commit (mpqc4 repo)**
+
+```bash
+cd /Users/efv/code/mpqc4
+/opt/homebrew/opt/llvm@17/bin/clang-format --style=file -i src/mpqc/chemistry/qc/lcao/expression/sequant_engine.cpp src/mpqc/chemistry/qc/lcao/expression/sequant_engine.h
+git add src/mpqc/chemistry/qc/lcao/expression/sequant_engine.cpp src/mpqc/chemistry/qc/lcao/expression/sequant_engine.h
+git commit -m "SeQuantEngine: accept dense_time_space objective, auto-route to batched"
+```
+
+---
+
+### Task 6: DryRun harness validation on C60 (perf-first vs peak-first)
+
+**Files:**
+- Modify: `tests/unit/test_eval_dryrun.cpp` (the `[dryrun-eval]` / `[dryrun-df]`
+  reproducers; currently uncommitted WIP on branch
+  `feature/eval-predicted-peak-trace`, driving `DensePeakSizeBatched` on the
+  faithful C60 config)
+
+**Interfaces:**
+- Consumes: `DenseTimeSpaceBatched` (Task 3). The harness already builds the real
+  C60 residual, the real config (occ=120, pno=42, osv=310, mu-tilde=1800,
+  aux=4320, pao_ts=256, aux_ts=72, peak_threshold=40 GB), and the top-down
+  realized-peak walk that reports free-mu-tilde escapees and node dumps.
+
+This is a characterization/observation task (not a red-green unit test): its job
+is to EMPIRICALLY confirm the fix before any cluster run. Do not weaken it into
+a tautology; record the actual numbers.
+
+- [ ] **Step 1: Add a perf-first pass to the harness**
+
+In the C60 dryrun reproducer that currently runs the batched optimize with
+`DensePeakSizeBatched` (via the `OptimizeOptions` it builds), add a SECOND run
+of the identical config with `opts.objective_function =
+ObjectiveFunction::DenseTimeSpace` (the engine/opt path auto-routes to
+`DenseTimeSpaceBatched` because `is_batchable_index` is set; if the harness calls
+`opt::single_term_opt<...>` directly rather than through `optimize()`, use
+`ObjectiveFunction::DenseTimeSpaceBatched` explicitly). Keep the existing
+peak-first run so the two can be compared side by side.
+
+For each of the two runs, emit (the harness already has the machinery):
+- whether any node is a four-free-PAO (`mu~^4`) contraction (the 4-PAO integral);
+- the LARGEST realized free-mu-tilde intermediate (GB), after ancestor slicing;
+- the count of intermediates whose free mu-tilde escaped slicing.
+
+- [ ] **Step 2: Build and run the harness (serialized; SeQuant threads internally)**
+
+Run: `cmake --build cmake-build-release --target unit_tests-sequant && ./cmake-build-release/tests/unit/unit_tests-sequant "[dryrun-eval]" "[dryrun-df]" 2>&1 | tail -60`
+Expected: the perf-first pass reports NO `mu~^4` node and a largest realized
+free-mu-tilde intermediate substantially below the peak-first pass's (and below
+the ~40 GB budget if the fix is complete). Record both passes' numbers in the
+commit message and in the ledger.
+
+- [ ] **Step 3: Interpret the result and gate the cluster decision**
+
+- If perf-first shows NO 4-PAO and the largest realized intermediate is well
+  under the peak-first result (and under available node memory): the design is
+  validated in-harness. STOP here; the C60 cluster run is a separate,
+  user-initiated step (do not launch it).
+- If perf-first STILL shows a large free-mu-tilde giant: this is a genuine
+  finding, NOT a test to loosen. It means the min-flops factorization itself
+  carries an irreducible large peak (the dual concern noted in the spec). Record
+  the exact giant (indices + realized GB) and surface it as a design question
+  for the user (a `peak_threshold`-aware secondary among near-min-flops points
+  may then be warranted). Use `superpowers:systematic-debugging` before
+  proposing any follow-up change.
+
+- [ ] **Step 4: clang-format and commit the harness apparatus**
+
+```bash
+/opt/homebrew/opt/llvm@17/bin/clang-format --style=file -i tests/unit/test_eval_dryrun.cpp
+git add tests/unit/test_eval_dryrun.cpp
+git commit -m "eval: dry-run C60 perf-first vs peak-first factorization comparison"
+```
+
+---
+
+### Task 7: Repin MPQC to the updated SeQuant (CI/clean builds)
+
+**Files:**
+- Modify: `/Users/efv/code/mpqc4/external/versions.cmake` (`MPQC_TRACKED_SEQUANT_TAG`
+  and its `PREVIOUS_*` companion)
+
+**Interfaces:**
+- Consumes: the merged/pushed SeQuant commits from Tasks 1-4 and 6.
+
+This task is LAST and is gated on the SeQuant changes being pushed to a commit
+CI can fetch. Local MPQC builds already see the edits via
+`FETCHCONTENT_SOURCE_DIR_SEQUANT`; the pin only matters for CI/clean builds.
+
+- [ ] **Step 1: Push the SeQuant branch and get its head SHA**
+
+```bash
+cd /Users/efv/code/SeQuant
+git push   # push feature/eval-predicted-peak-trace (or the agreed branch)
+git rev-parse HEAD
+```
+
+- [ ] **Step 2: Update the pin**
+
+In `/Users/efv/code/mpqc4/external/versions.cmake`, set
+`MPQC_TRACKED_SEQUANT_TAG` to the new SHA and move the old value into the
+corresponding `MPQC_TRACKED_PREVIOUS_SEQUANT_TAG` (match the file's existing
+CURRENT/PREVIOUS convention exactly; read the surrounding lines first).
+
+- [ ] **Step 3: Commit the pin on its own**
+
+```bash
+cd /Users/efv/code/mpqc4
+git add external/versions.cmake
+git commit -m "external: repin SeQuant to <new-sha7> (DenseTimeSpace objective)"
+```
+
+(Keep this pin bump in its own commit, separate from the Task 5 wiring, per the
+repo's commit rules.)
+
+---
+
+## Self-Review
+
+**1. Spec coverage:**
+- Enum rename + aliases + two new values -> Task 1. (spec "Objective naming")
+- `perf_first` field + `select_root` perf-first + `PeakModel::reconstruct`
+  perf-first -> Task 2. (spec "Why the selector is a plain lexicographic swap")
+- `single_term_opt` arms + `optimize.cpp` dispatch + `perf_first` set from
+  `Metric` -> Task 3. (spec "Data flow")
+- MPQC keyword `dense_time_space` + auto-route + doc -> Task 5. (spec "MPQC wiring")
+- C60 DryRun validation, no-4-PAO, realized-peak comparison -> Task 6. (spec
+  "Validation")
+- `DenseSpaceTime*` unchanged / alias parse guard -> Task 1 (static-assert) +
+  Task 3 Step 5 (regression run of full `[optimize]`).
+- Repin -> Task 7. (spec "Global constraints" cross-repo note)
+- `pareto_best` unchanged, frontier unchanged -> stated in Global Constraints;
+  no task touches them (correct).
+
+Gap check: the spec's unit-test bullet "assert `pareto_best`'s perf-first branch
+returns the min-flops point" is intentionally DROPPED -- analysis showed
+`pareto_best` is a test helper that must stay peak-min and is not on the
+perf-first path, so there is no perf-first `pareto_best` branch to test. The
+non-batched perf-first path is instead covered structurally by Task 2 Step 5 +
+the full `[optimize]` regression run. This is a correction to the spec's
+testing list, not a coverage gap.
+
+**2. Placeholder scan:** No "TBD"/"handle edge cases"/prose-only steps; every
+code step shows the exact code. Task 4 Step 2 flags that the exact TEST_CASE
+name must be looked up with `--list-tests` (a concrete command), not a
+placeholder.
+
+**3. Type consistency:** `perf_first` is `bool` in both models (Task 2) and set
+identically in both `single_term.hpp` arms (Task 3). `DenseTimeSpaceBatched` /
+`DenseTimeSpace` spelled consistently across Tasks 1/3/4/5/6. `CostParams`
+aggregate order (`is_volatile_leaf, volatile_weight, footprint_weight,
+peak_flops_tolerance, roofline, accumulation_factor, peak_threshold`) matches
+`options.hpp:93-117` and the `.peak_threshold =` field-assignment idiom used in
+the existing `[optimize][threshold]` test. `PeakModel` / `PeakBatchedModel`
+aggregate-init field orders in Task 3 match `cost_model.hpp` (perf_first added
+LAST in each, so positional inits are unaffected).

From 1504a9649ced49dfa7da802845eee7b8ffeb2fa4 Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Sun, 5 Jul 2026 00:39:21 -0400
Subject: [PATCH 26/78] optimize: add perf-first DenseTimeSpace{,Batched}
 objective

Rename DensePeakSize{,Batched} -> DenseSpaceTime{,Batched} (old names kept as
deprecated aliases sharing the same enum values, so every existing
`== DensePeakSize` guard keeps working) and add the perf-first / peak-second
duals DenseTimeSpace{,Batched}.

The peak-first model treats peak_threshold as a hard filter over
factorizations, so with PAO (mu-tilde) sliceable it structurally prefers the
fully-sliceable but FLOPS-catastrophic 4-PAO integral over the correct (gC)(gC)
particle-ladder. The perf-first model adds a `perf_first` flag to PeakModel /
PeakBatchedModel; when set, the root-frontier selector sorts by (flops, then
peak) instead of (peak, then flops). Because pareto_insert keeps one min-peak
point per distinct flops value, this both picks the cheapest factorization and
takes its fully-sliced realization, and peak_threshold is no longer consulted
as a feasibility gate (it can no longer force the 4-PAO). The Pareto frontier,
relax(), roofline cost, and the pareto_best test helper are unchanged.

single_term_opt routes DenseTimeSpace{,Batched} to the peak models with
perf_first set; optimize() gains dispatch arms for both new values.

Tests: DenseTimeSpaceBatched reaches the flop-optimal (gC)(gC) factorization at
both +inf and a near-zero peak_threshold (unlike peak-first strict, which pays
the ladder), and the enum aliases compare equal.
---
 SeQuant/core/optimize/cost_model.hpp  | 52 +++++++++++++++++++++++++
 SeQuant/core/optimize/optimize.cpp    | 20 ++++++++--
 SeQuant/core/optimize/options.hpp     | 50 +++++++++++++++++-------
 SeQuant/core/optimize/single_term.hpp | 33 ++++++++++------
 tests/unit/test_optimize.cpp          | 55 +++++++++++++++++++++++++++
 5 files changed, 180 insertions(+), 30 deletions(-)

diff --git a/SeQuant/core/optimize/cost_model.hpp b/SeQuant/core/optimize/cost_model.hpp
index 5eabf64b79..5d3d6337bc 100644
--- a/SeQuant/core/optimize/cost_model.hpp
+++ b/SeQuant/core/optimize/cost_model.hpp
@@ -324,6 +324,10 @@ struct PeakModel {
   /// peak increase for a potentially large flop reduction (e.g. forming a
   /// persistent 4-PNO integral instead of recomputing a ladder).
   double peak_flops_tolerance = 0.0;
+  /// Perf-first / peak-second selection: when true, `reconstruct` selects the
+  /// root-frontier point by (flops, then peak) instead of (peak, then flops),
+  /// bypassing `peak_flops_tolerance`. Default false = peak-first (unchanged).
+  bool perf_first = false;
 
   /// One non-dominated (peak, flops) trade-off for a subset, with the
   /// bipartition / order / child-frontier-indices needed to reconstruct it.
@@ -437,6 +441,34 @@ struct PeakModel {
   EvalSequence reconstruct(Context const& /*ctx*/,
                            container::vector<State> const& st) const {
     size_t const full = st.size() - 1;
+    if (perf_first) {
+      // Perf-first / peak-second (non-batched): min flops, ties by lower peak,
+      // bypassing the peak_flops_tolerance epsilon band (a peak-first knob).
+      auto const& rootf = st[full];
+      int pbest = 0;
+      for (int i = 1; i < static_cast<int>(rootf.size()); ++i)
+        if (rootf[i].flops < rootf[pbest].flops ||
+            (rootf[i].flops == rootf[pbest].flops &&
+             rootf[i].peak < rootf[pbest].peak))
+          pbest = i;
+      // Reuse the existing back-pointer walk with the chosen root index.
+      std::function<EvalSequence(size_t, int)> pbuild =
+          [&](size_t n, int idx) -> EvalSequence {
+        if (std::popcount(n) == 1)
+          return EvalSequence{static_cast<int>(std::countr_zero(n))};
+        FrontPoint const& fp = st[n][idx];
+        size_t const fs = fp.lp_first ? fp.lp : fp.rp;
+        int const fi = fp.lp_first ? fp.lp_idx : fp.rp_idx;
+        size_t const ss = fp.lp_first ? fp.rp : fp.lp;
+        int const si = fp.lp_first ? fp.rp_idx : fp.lp_idx;
+        EvalSequence s = pbuild(fs, fi);
+        EvalSequence b = pbuild(ss, si);
+        s.insert(s.end(), b.begin(), b.end());
+        s.push_back(-1);
+        return s;
+      };
+      return pbuild(full, pbest);
+    }
     // ε-tolerant selection: among frontier points within
     // (1 + peak_flops_tolerance) of the minimum peak, take the fewest flops
     // (ties broken by lower peak). tolerance == 0 recovers strict peak-min.
@@ -522,6 +554,12 @@ struct PeakBatchedModel {
   /// Bytes per stored element, to compare the model's element-count peak to
   /// peak_threshold (bytes). Default 8 (double / TensorD).
   double numeric_size = 8.0;
+  /// Perf-first / peak-second selection: when true, `select_root` selects the
+  /// root-frontier point by (flops, then peak) and does NOT consult
+  /// `peak_threshold` as a feasibility gate (it can no longer force a
+  /// FLOPS-catastrophic factorization for its sliceability). Default false =
+  /// peak-first threshold-gated selection (unchanged).
+  bool perf_first = false;
 
   /// One non-dominated (peak, flops) trade-off for a (subset, sliced-set \c B)
   /// cell. \c aprime is the sliced-set chosen at this node; the children are
@@ -696,6 +734,20 @@ struct PeakBatchedModel {
     auto peak_bytes = [this](double peak_elems) {
       return peak_elems * numeric_size;
     };
+    if (perf_first) {
+      // Perf-first / peak-second: min flops, ties by lower peak. The frontier
+      // keeps one min-peak point per distinct flops value (pareto_insert prunes
+      // equal-flops higher-peak points), so this both picks the cheapest
+      // factorization and takes its fully-sliced (min-peak) realization.
+      // peak_threshold is deliberately NOT consulted here.
+      int pbest = 0;
+      for (int i = 1; i < static_cast<int>(rootf.size()); ++i)
+        if (rootf[i].flops < rootf[pbest].flops ||
+            (rootf[i].flops == rootf[pbest].flops &&
+             rootf[i].peak < rootf[pbest].peak))
+          pbest = i;
+      return pbest;
+    }
     int best = -1;
     bool any_feasible = false;
     for (int i = 0; i < static_cast<int>(rootf.size()); ++i)
diff --git a/SeQuant/core/optimize/optimize.cpp b/SeQuant/core/optimize/optimize.cpp
index 38389c3734..4241203bb7 100644
--- a/SeQuant/core/optimize/optimize.cpp
+++ b/SeQuant/core/optimize/optimize.cpp
@@ -110,14 +110,26 @@ ExprPtr opt_pure_product(Product const& prod, OptimizeOptions const& opts) {
           prod, opts.idx_to_extent, subnet_cse, cost,
           opts.batch_policy.is_batchable_index,
           opts.batch_policy.batch_target_size, opts.inner_pow);
-    if (opts.objective_function == ObjectiveFunction::DensePeakSize)
-      return opt::single_term_opt<ObjectiveFunction::DensePeakSize>(
+    if (opts.objective_function == ObjectiveFunction::DenseSpaceTime)
+      return opt::single_term_opt<ObjectiveFunction::DenseSpaceTime>(
           prod, opts.idx_to_extent, subnet_cse, cost,
           opts.batch_policy.is_batchable_index,
           opts.batch_policy.batch_target_size, opts.inner_pow);
+    if (opts.objective_function == ObjectiveFunction::DenseTimeSpace)
+      return opt::single_term_opt<ObjectiveFunction::DenseTimeSpace>(
+          prod, opts.idx_to_extent, subnet_cse, cost,
+          opts.batch_policy.is_batchable_index,
+          opts.batch_policy.batch_target_size, opts.inner_pow);
+    if (opts.objective_function == ObjectiveFunction::DenseSpaceTimeBatched)
+      return opt::single_term_opt<ObjectiveFunction::DenseSpaceTimeBatched>(
+          prod, opts.idx_to_extent, subnet_cse, cost,
+          opts.batch_policy.is_batchable_index,
+          opts.batch_policy.batch_target_size, opts.inner_pow,
+          opts.batch_policy.persistent_only,
+          opts.term_batch_axes ? &node_axes : nullptr);
     SEQUANT_ASSERT(opts.objective_function ==
-                   ObjectiveFunction::DensePeakSizeBatched);
-    return opt::single_term_opt<ObjectiveFunction::DensePeakSizeBatched>(
+                   ObjectiveFunction::DenseTimeSpaceBatched);
+    return opt::single_term_opt<ObjectiveFunction::DenseTimeSpaceBatched>(
         prod, opts.idx_to_extent, subnet_cse, cost,
         opts.batch_policy.is_batchable_index,
         opts.batch_policy.batch_target_size, opts.inner_pow,
diff --git a/SeQuant/core/optimize/options.hpp b/SeQuant/core/optimize/options.hpp
index 82d8564d0d..ca786df2b1 100644
--- a/SeQuant/core/optimize/options.hpp
+++ b/SeQuant/core/optimize/options.hpp
@@ -21,18 +21,19 @@ class Expr;
 /// - `DenseFLOPs` counts floating-point operations.
 /// - `DenseSize` counts result-tensor storage elements (summed over
 ///   intermediates) -- a gross-traffic proxy, not a peak.
-/// - `DensePeakSize` minimizes peak memory: the maximum over the evaluation
-///   schedule of the combined size of all simultaneously-live tensors
-///   (intermediates AND resident input leaves, the all-co-resident model),
-///   and it chooses the evaluation order that minimizes that peak. Unlike the
-///   order-independent `DenseFLOPs`/`DenseSize`, the contraction order is a
-///   real lever here. NOTE: `DensePeakSize` does not yet support
+/// - `DenseSpaceTime` (formerly `DensePeakSize`; that name is kept as a
+///   deprecated alias) is PEAK-FIRST, perf-second: it minimizes peak memory --
+///   the maximum over the evaluation schedule of the combined size of all
+///   simultaneously-live tensors (intermediates AND resident input leaves, the
+///   all-co-resident model) -- and breaks ties by the roofline perf cost.
+///   Unlike the order-independent `DenseFLOPs`/`DenseSize`, the contraction
+///   order is a real lever here. NOTE: does not yet support
 ///   common-subexpression elimination (`CSEOptions::subnet` must be false).
-/// - `DensePeakSizeBatched` extends `DensePeakSize` with a per-index
-///   batchability model: each index satisfying
-///   `OptimizeOptions::batch_policy.is_batchable_index` is treated as
-///   independently sliced to
-///   `min(extent, batch_policy.batch_target_size(ix))` elements per index --
+/// - `DenseSpaceTimeBatched` (formerly `DensePeakSizeBatched`) extends
+///   `DenseSpaceTime` with a per-index batchability model: each index
+///   satisfying `OptimizeOptions::batch_policy.is_batchable_index` is treated
+///   as independently sliced to `min(extent,
+///   batch_policy.batch_target_size(ix))` elements per index --
 ///   `batch_target_size` is an upper bound, so this is a conservative
 ///   (over-)estimate of the realized whole-tile batch, which the backend rounds
 ///   *down* to a tile multiple (never above the target; see
@@ -40,14 +41,35 @@ class Expr;
 ///   DP minimises peak over the worst-case sliced configuration. Only consulted
 ///   by the batched oracle and DP; requires
 ///   `batch_policy.is_batchable_index` and `batch_policy.batch_target_size`
-///   to be set.
+///   to be set. Final selection is threshold-gated by `peak_threshold`.
+/// - `DenseTimeSpace` / `DenseTimeSpaceBatched` are the PERF-FIRST, peak-second
+///   duals of `DenseSpaceTime` / `DenseSpaceTimeBatched`: they select a
+///   factorization by roofline perf first and peak second (same Pareto-frontier
+///   and roofline machinery, opposite lexicographic order). Because slicing is
+///   perf-neutral, a perf-first primary never prefers a FLOPS-catastrophic
+///   factorization merely for its sliceability, and `peak_threshold` is NOT a
+///   feasibility gate for these (it cannot force such a choice). Naming:
+///   `Dense{Primary}{Secondary}`, `Space` = peak/size, `Time` = perf.
 ///
 /// Leaves room for `Sparse*` models later.
 enum class ObjectiveFunction {
   DenseFLOPs,
   DenseSize,
-  DensePeakSize,
-  DensePeakSizeBatched
+  /// Peak-first, perf-second. (Formerly `DensePeakSize`.)
+  DenseSpaceTime,
+  /// Batched variant of `DenseSpaceTime`. (Formerly `DensePeakSizeBatched`.)
+  DenseSpaceTimeBatched,
+  /// Perf-first, peak-second: never prefers a FLOPS-catastrophic factorization
+  /// for its sliceability.
+  DenseTimeSpace,
+  /// Batched variant of `DenseTimeSpace`.
+  DenseTimeSpaceBatched,
+  /// Deprecated aliases (same underlying values as the renamed constants above,
+  /// placed AFTER them so `DenseSpaceTime` keeps `DensePeakSize`'s old value).
+  /// Kept so existing code and JSON inputs ("dense_peak_size") keep compiling;
+  /// every existing `== DensePeakSize` guard still catches `DenseSpaceTime`.
+  DensePeakSize = DenseSpaceTime,
+  DensePeakSizeBatched = DenseSpaceTimeBatched
 };
 
 /// Whether to reorder summands so terms with shared intermediates appear
diff --git a/SeQuant/core/optimize/single_term.hpp b/SeQuant/core/optimize/single_term.hpp
index 0f0f0e634e..0aef921619 100644
--- a/SeQuant/core/optimize/single_term.hpp
+++ b/SeQuant/core/optimize/single_term.hpp
@@ -95,24 +95,31 @@ EvalSequence single_term_opt(
   // DP's subset bits.
   size_t volatile_mask = 0;
   double nr = 1.0;
-  if constexpr (Metric == ObjectiveFunction::DensePeakSize) {
+  if constexpr (Metric == ObjectiveFunction::DenseSpaceTime ||
+                Metric == ObjectiveFunction::DenseTimeSpace) {
     SEQUANT_ASSERT(!subnet_cse &&
-                   "subnet_cse not supported with DensePeakSize (Phase 1)");
+                   "subnet_cse not supported with DenseSpaceTime (Phase 1)");
     SEQUANT_ASSERT(!out_axes &&
-                   "out_axes only supported with DensePeakSizeBatched");
+                   "out_axes only supported with the batched peak objectives");
     (void)is_batchable_index;
     (void)batch_target_size;
     (void)batch_persistent_only;
     (void)footprint_weight;  // peak objectives use the roofline tie-break
     // is_volatile_leaf / volatile_weight / roofline feed only the secondary
     // tie-break among equal-peak schedules (peak itself ignores them).
-    return run_single_term_opt(
-        PeakModel{idxsz, inner_pow, is_volatile_leaf, volatile_weight,
-                  roofline.machine_balance, roofline.fast_mem_elems,
-                  roofline.block_tiles, roofline.block_prefactor,
-                  peak_flops_tolerance},
-        network, tidxs);
-  } else if constexpr (Metric == ObjectiveFunction::DensePeakSizeBatched) {
+    PeakModel model{idxsz,
+                    inner_pow,
+                    is_volatile_leaf,
+                    volatile_weight,
+                    roofline.machine_balance,
+                    roofline.fast_mem_elems,
+                    roofline.block_tiles,
+                    roofline.block_prefactor,
+                    peak_flops_tolerance};
+    model.perf_first = (Metric == ObjectiveFunction::DenseTimeSpace);
+    return run_single_term_opt(model, network, tidxs);
+  } else if constexpr (Metric == ObjectiveFunction::DenseSpaceTimeBatched ||
+                       Metric == ObjectiveFunction::DenseTimeSpaceBatched) {
     SEQUANT_ASSERT(
         !subnet_cse &&
         "subnet_cse not supported with DensePeakSizeBatched (Phase 2)");
@@ -133,6 +140,7 @@ EvalSequence single_term_opt(
                            peak_flops_tolerance,
                            accumulation_factor,
                            cost.peak_threshold};
+    model.perf_first = (Metric == ObjectiveFunction::DenseTimeSpaceBatched);
     if (out_axes) {
       auto [seq, axes] = run_single_term_opt_axes(model, network, tidxs);
       *out_axes = std::move(axes);
@@ -164,8 +172,9 @@ EvalSequence single_term_opt(
     return run_single_term_opt(model, network, tidxs);
   } else {
     static_assert(Metric == ObjectiveFunction::DenseSize,
-                  "Only DenseFLOPs, DenseSize, DensePeakSize, and "
-                  "DensePeakSizeBatched ObjectiveFunction supported.");
+                  "Only DenseFLOPs, DenseSize, DenseSpaceTime, "
+                  "DenseSpaceTimeBatched, DenseTimeSpace, and "
+                  "DenseTimeSpaceBatched ObjectiveFunction supported.");
     SEQUANT_ASSERT(!out_axes &&
                    "out_axes only supported with DensePeakSizeBatched");
     (void)is_batchable_index;
diff --git a/tests/unit/test_optimize.cpp b/tests/unit/test_optimize.cpp
index 43842edf36..ffd6a48d59 100644
--- a/tests/unit/test_optimize.cpp
+++ b/tests/unit/test_optimize.cpp
@@ -200,6 +200,23 @@ TEST_CASE("optimize", "[optimize]") {
       return deserialize(xpr, {.def_perm_symm = Symmetry::Antisymm});
     };
 
+    SECTION("ObjectiveFunction aliases share enum values") {
+      using sequant::ObjectiveFunction;
+      // The deprecated names are aliases (same underlying value), so all
+      // existing `== DensePeakSize` guards keep catching the renamed constant.
+      STATIC_REQUIRE(ObjectiveFunction::DensePeakSize ==
+                     ObjectiveFunction::DenseSpaceTime);
+      STATIC_REQUIRE(ObjectiveFunction::DensePeakSizeBatched ==
+                     ObjectiveFunction::DenseSpaceTimeBatched);
+      // The new perf-first values are distinct from the peak-first ones.
+      STATIC_REQUIRE(ObjectiveFunction::DenseTimeSpace !=
+                     ObjectiveFunction::DenseSpaceTime);
+      STATIC_REQUIRE(ObjectiveFunction::DenseTimeSpaceBatched !=
+                     ObjectiveFunction::DenseSpaceTimeBatched);
+      // ABI: DenseSpaceTime keeps DensePeakSize's old numeric value (2).
+      STATIC_REQUIRE(static_cast<int>(ObjectiveFunction::DenseSpaceTime) == 2);
+    }
+
     SECTION("Single term optimization") {
       const auto prod1 = parse_expr_antisymm(
                              L"g_{i3,i4}^{a3,a4}"     // T1
@@ -1939,6 +1956,25 @@ TEST_CASE("PPL: form 4-PNO W vs fold-t (peak-neutral, flop tie-break)",
       opt::single_term_opt<ObjectiveFunction::DensePeakSizeBatched>(
           prod, idxsz, false, CostParams{is_t, 1.0, 0.0}, is_batch, bts, ip));
   CHECK(pbat_w_vw1 > flops_w);
+
+  // Perf-first (DenseTimeSpaceBatched) is flops-primary, so it forms the
+  // flop-optimal W REGARDLESS of peak_flops_tolerance and regardless of a tight
+  // peak_threshold: its replay-weighted flop count equals the FLOPs optimum.
+  // (Peak-first at strict tolerance did NOT: peak_w_strict > flops_w above.)
+  double tbat_w = rep(
+      L"TimeSpaceB/vw100:",
+      opt::single_term_opt<ObjectiveFunction::DenseTimeSpaceBatched>(
+          prod, idxsz, false, CostParams{is_t, 100.0, 0.0}, is_batch, bts, ip));
+  CHECK(tbat_w == flops_w);
+  // Even with a near-zero peak budget, perf-first stays flop-optimal (threshold
+  // is not a feasibility gate), unlike peak-first's min-peak fallback.
+  CostParams tight{is_t, 100.0, 0.0};
+  tight.peak_threshold = 1.0;
+  double tbat_w_tight =
+      rep(L"TimeSpaceB/tight:",
+          opt::single_term_opt<ObjectiveFunction::DenseTimeSpaceBatched>(
+              prod, idxsz, false, tight, is_batch, bts, ip));
+  CHECK(tbat_w_tight == flops_w);
 }
 
 // Quadratic-bubble (g·t2·t2) exchange term in PNO/CSV basis: the two competing
@@ -2261,6 +2297,25 @@ TEST_CASE(
   // A near-zero peak_threshold makes every point infeasible => min-peak
   // fallback => reproduces the old (peak-driven) answer: late-K.
   CHECK_FALSE(integral_at(/*Kb=*/2, /*peak_threshold(bytes)=*/1.0));
+
+  // Perf-first (DenseTimeSpaceBatched): min-flops is primary and peak_threshold
+  // is NOT a feasibility gate, so the persistent Kappa-free integral (the
+  // min-(replay-weighted)-flops choice) is formed REGARDLESS of the threshold.
+  // Contrast the peak-first checks above: at a near-zero threshold peak-first
+  // fell back to min-peak (CHECK_FALSE), whereas perf-first still forms it.
+  auto integral_at_perf = [&](std::size_t Kb, double peak_threshold) -> bool {
+    std::function<std::size_t(Index const&)> bts = [Kb](Index const&) {
+      return Kb;
+    };
+    CostParams cost{is_t, 100.0, 0.0};
+    cost.peak_threshold = peak_threshold;
+    auto res = opt::single_term_opt<ObjectiveFunction::DenseTimeSpaceBatched>(
+        prod, idxsz, false, cost, is_batch, bts, ip);
+    return forms_integral(res);
+  };
+  // Threshold-insensitive: forms the integral at +inf AND at near-zero.
+  CHECK(integral_at_perf(/*Kb=*/2, inf));
+  CHECK(integral_at_perf(/*Kb=*/2, /*peak_threshold(bytes)=*/1.0));
 }
 
 // Task 2.2: validate that the batched DP's accumulation_factor charge is

From 9a6b5710feec36545a55bd86459251cb103989b8 Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Sun, 5 Jul 2026 00:53:28 -0400
Subject: [PATCH 27/78] eval: dry-run C60 perf-first vs peak-first
 factorization comparison

Add the [dryrun-perf] test plus the post-transform DryRun harness apparatus
([dryrun-probe]/[dryrun-df]/[dryrun-eval]) used to diagnose the C60 PNO-CCSD
OOM. [dryrun-perf] optimizes the real C60 giant term (index 38) under both the
peak-first (DenseSpaceTimeBatched) and perf-first (DenseTimeSpaceBatched)
objectives at the faithful config (occ=120, PNO=42, OSV=310, mu-tilde=1800,
aux=4320, pao_ts=256, aux_ts=72, peak_threshold=40 GB) and asserts the
factorization the DP picks.

Result: peak-first forms the fully-sliceable 4-PAO AO integral (4 free
mu-tilde, sliced to 34 GB, under the 40 GB threshold, so it survives the hard
filter despite catastrophic flops) -- the C60 pathology. Perf-first forms no
4-PAO (max 2 free mu-tilde); its largest giant is the correct (gC)(gC)
intermediate {mu-tilde, a<i,i>, K} at 89 GB, far below the 627-769 GB that
OOM'd the real run and below node memory. The fix is validated in-harness.
---
 tests/unit/test_eval_dryrun.cpp | 442 +++++++++++++++++++++++++++-----
 1 file changed, 375 insertions(+), 67 deletions(-)

diff --git a/tests/unit/test_eval_dryrun.cpp b/tests/unit/test_eval_dryrun.cpp
index 2df754450a..5f40edb107 100644
--- a/tests/unit/test_eval_dryrun.cpp
+++ b/tests/unit/test_eval_dryrun.cpp
@@ -83,10 +83,14 @@
 #include <cmath>
 #include <cstddef>
 #include <fstream>
+#include <functional>
 #include <iostream>
+#include <map>
 #include <memory>
+#include <set>
 #include <sstream>
 #include <string>
+#include <type_traits>
 #include <unordered_map>
 #include <vector>
 
@@ -541,9 +545,18 @@ SizeRegime df_regime(std::size_t mu_tilde, std::size_t aux, std::size_t i_occ,
       {L"Κ", aux},
       {L"a", mu_tilde},  // bare "a" should not appear (all a are proto here)
   };
+  // csv_{pno,osv}_moment[k] must be the k-th POWER MEAN M_k=(<d^k>)^(1/k) of
+  // the per-pair domain, NOT the k-th moment <d^k>. inner_aware_volume sizes a
+  // k-group of proto-sharing composites as the PRODUCT of inner_pow(c,k) over
+  // its k members, so M_k^k telescopes to <d^k> and (times outer occ^N) equals
+  // the true block volume Sum_pairs d^k. With only the scalar mean (no per-pair
+  // histogram), approximate the domain as constant -> M_k = mean for ALL k.
+  // pow(pno,k) (the k-th MOMENT) is wrong: for a k=2 result like
+  // R{a_1<i,i>,a_2<i,i>;i,i} it gives occ^2*pno^4 not occ^2*pno^2 (the 358 GB
+  // root artifact). k=1 single-composite giants are unaffected (pno^1==pno).
   for (std::size_t k = 0; k <= 4; ++k) {
-    r.csv_pno_moment[k] = std::pow(pno, double(k));
-    r.csv_osv_moment[k] = std::pow(osv, double(k));
+    r.csv_pno_moment[k] = pno;
+    r.csv_osv_moment[k] = osv;
   }
   return r;
 }
@@ -604,9 +617,49 @@ TEST_CASE("dryrun POST-transform PAO/K batch-axis verdict", "[dryrun-df]") {
   // visible; each term reports whether its largest free-mu~ intermediate got a
   // mu~/K batch axis.
   double const peak_threshold = 40e9;  // 40 GB, matches the C60 run
-  // C60 pVDZ-F12 scale
-  auto regime = df_regime(/*mu_tilde=*/1800u, /*aux=*/4320u, /*i_occ=*/32u,
-                          /*pno=*/19.0, /*osv=*/57.0);
+  // Env overrides for the root-cause BISECT (default = faithful real C60
+  // config). DRYRUN_OCC/PNO/OSV vary extents; DRYRUN_PAO_TS/AUX_TS vary batch
+  // target sizes; DRYRUN_VW varies volatile_weight; DRYRUN_ROOFLINE=0 disables
+  // the roofline tie-break. Absent env var => real-config default.
+  auto env_d = [](char const* k, double dflt) {
+    char const* v = std::getenv(k);
+    return v ? std::atof(v) : dflt;
+  };
+  auto env_u = [](char const* k, std::size_t dflt) {
+    char const* v = std::getenv(k);
+    return v ? static_cast<std::size_t>(std::atoll(v)) : dflt;
+  };
+  std::size_t const occ_ext = env_u("DRYRUN_OCC", 120u);
+  double const pno_mom = env_d("DRYRUN_PNO", 42.0);
+  double const osv_mom = env_d("DRYRUN_OSV", 310.0);
+  std::size_t const pao_ts = env_u("DRYRUN_PAO_TS", 256u);
+  std::size_t const aux_ts = env_u("DRYRUN_AUX_TS", 72u);
+  double const vol_weight = env_d("DRYRUN_VW", 20.0);
+  bool const use_roofline = env_u("DRYRUN_ROOFLINE", 1u) != 0;
+  // DRYRUN_AUX_ONLY=1 makes ONLY the DF aux (K) sliceable, NOT PAO (mu~) --
+  // reproduces MPQC's aux-only batching to check the proper (gC)^2 PPL
+  // factorization keeps the mu~-full giant (large realized peak = OOM) and
+  // does NOT form the fully-sliceable 4-PAO integral.
+  bool const aux_only = env_u("DRYRUN_AUX_ONLY", 0u) != 0;
+  auto is_batchable = [aux_only](Index const& ix) {
+    auto const k = ix.space().base_key();
+    return aux_only ? (k == L"Κ") : (k == L"μ̃" || k == L"Κ");
+  };
+  std::wcerr << L"[dryrun-df] config: occ=" << occ_ext << L" pno=" << pno_mom
+             << L" osv=" << osv_mom << L" pao_ts=" << pao_ts << L" aux_ts="
+             << aux_ts << L" vw=" << vol_weight << L" roofline="
+             << (use_roofline ? 1 : 0) << L" aux_only=" << (aux_only ? 1 : 0)
+             << L"\n";
+  // C60 pVDZ-F12 scale, REAL run dimensions (from the 614336 Owl job log):
+  //   active occupied = 120 (tiles [0,120), elements [60,180))
+  //   #PAO = #AO = 1800 (872/pair is a sparsity metric, NOT the dense cost)
+  //   DF aux (aug-cc-pVDZ-RI) = 4320
+  //   Average PNOs per pair = 41.92 ; Average OSVs per pair = 309.67
+  // The earlier water-8 occ/PNO (i=32, PNO=19, OSV=57) were as wrong as the
+  // K=672; they under-scaled every intermediate and (via peak_threshold
+  // pruning) changed the DP's axis choice.
+  auto regime = df_regime(/*mu_tilde=*/1800u, /*aux=*/4320u, /*i_occ=*/occ_ext,
+                          /*pno=*/pno_mom, /*osv=*/osv_mom);
   auto memsize = sequant::opt::detail::memsize_counter(regime.idx_to_extent(),
                                                        regime.inner_pow_fn());
   auto has_free_mu_tilde = [](std::vector<Index> const& ixs) {
@@ -619,7 +672,8 @@ TEST_CASE("dryrun POST-transform PAO/K batch-axis verdict", "[dryrun-df]") {
   std::size_t total_mu_nodes_with_mu_axis = 0, total_mu_nodes_with_k_only = 0;
   double overall_biggest = 0.0;
   bool overall_biggest_has_mu = false, overall_biggest_has_k = false;
-  std::wstring overall_biggest_desc, overall_biggest_axes;
+  std::wstring overall_biggest_desc, overall_biggest_axes,
+      overall_biggest_sources;
 
   for (std::size_t ti = 0; ti < terms.size(); ++ti) {
     auto t0 = std::chrono::steady_clock::now();
@@ -632,11 +686,28 @@ TEST_CASE("dryrun POST-transform PAO/K batch-axis verdict", "[dryrun-df]") {
     opts.objective_function = ObjectiveFunction::DensePeakSizeBatched;
     opts.idx_to_extent = regime.idx_to_extent();
     opts.inner_pow = regime.inner_pow_fn();
-    opts.batch_policy.is_batchable_index = is_df_batchable;
-    opts.batch_policy.batch_target_size = [](Index const&) {
-      return std::size_t{100};
+    opts.batch_policy.is_batchable_index = is_batchable;
+    // FAITHFUL replica of the real C60 run's OptimizeOptions
+    // (make_optimize_options + cck.ipp batch policy, 614336 job log):
+    //   batch:pao_target_size=256, batch:aux_target_size=72
+    //   optimize:volatile_weight=20, machine_balance=200, fast_mem_elems=1e6
+    //   is_volatile_leaf = (label == "t"), accumulation_factor = 1.0 (MPQC
+    //   dflt)
+    opts.batch_policy.batch_target_size =
+        [pao_ts, aux_ts](Index const& ix) -> std::size_t {
+      return ix.space().base_key() == L"μ̃" ? pao_ts   // pao_target_size
+                                           : aux_ts;  // aux_target_size
+    };
+    opts.batch_policy.is_volatile_leaf = [](Tensor const& t) {
+      return t.label() == L"t";
     };
+    opts.batch_policy.accumulation_factor = 1.0;
     opts.batch_policy.peak_threshold = peak_threshold;
+    opts.volatile_weight = vol_weight;
+    if (use_roofline) {
+      opts.roofline.machine_balance = 200.0;
+      opts.roofline.fast_mem_elems = 1000000.0;
+    }
     opts.term_batch_axes = axes_map;
 
     auto term = optimize(terms[ti], opts);
@@ -653,46 +724,97 @@ TEST_CASE("dryrun POST-transform PAO/K batch-axis verdict", "[dryrun-df]") {
     auto node = binarize(term, {}, bopts);
     SEQUANT_PRAGMA_IGNORE_DEPRECATED_END
 
-    // Does a node's batch_axes contain a mu~ / a K axis specifically?
-    auto axis_has = [](auto const& n, std::wstring const& base) {
-      for (auto const& ax : n->batch_axes())
-        if (ax.space().base_key() == base) return true;
-      return false;
+    // CORRECT metric: a node can only slice a batchable index it CONTRACTS
+    // (relax()'s Acand = open at children & closed at parent). A free index on
+    // an intermediate is sliceable only at the ANCESTOR that contracts it, so
+    // the giant's REALIZED size is its nominal size with each free index that
+    // some ancestor sliced reduced to batch_target_size. Walk top-down carrying
+    // active = union of ancestor batch_axes (by FULL label, so mu~_1241 sliced
+    // above only reduces the SAME mu~_1241 below, not a different mu~_j).
+    auto keyof = [](Index const& ix) { return std::wstring(ix.full_label()); };
+    auto ext_of = [](Index const& ix) -> double {
+      auto bk = ix.space().base_key();
+      if (bk == L"μ̃") return 1800.0;
+      if (bk == L"Κ") return 4320.0;
+      return 0.0;
+    };
+    auto tgt_of = [pao_ts, aux_ts](Index const& ix) -> double {
+      return ix.space().base_key() == L"μ̃" ? double(pao_ts) : double(aux_ts);
     };
-    double term_biggest = 0.0;
-    std::wstring term_biggest_desc, term_biggest_axes;
-    bool term_biggest_has_mu = false, term_biggest_has_k = false;
+    double term_biggest = 0.0;  // max REALIZED bytes over free-mu~ nodes
+    std::wstring term_biggest_desc, term_biggest_axes, term_biggest_sources;
+    bool term_biggest_has_mu = false;  // its free mu~ ESCAPED slicing
+    bool term_biggest_has_k = false;   // its free K ESCAPED slicing
     std::size_t term_mu_nodes = 0;
-    node.visit_internal([&](auto const& n) {
-      auto free_ixs = node_free_indices(*n);
-      if (!has_free_mu_tilde(free_ixs)) return;
-      ++term_mu_nodes;
-      ++total_mu_nodes;
-      bool const has_mu = axis_has(n, L"μ̃");
-      bool const has_k = axis_has(n, L"Κ");
-      if (has_mu) ++total_mu_nodes_with_mu_axis;
-      if (has_k && !has_mu) ++total_mu_nodes_with_k_only;
-      double const bytes =
-          memsize(free_ixs, std::vector<Index>{}, std::vector<Index>{}) * 8.0;
-      // For a genuinely large (un-sliced would-be OOM) free-mu~ node, print its
-      // full index set AND its exact batch axes so we can see mu~ vs K.
-      if (bytes > 5e10) {
-        std::wcerr << L"\n  [GIANT " << (bytes / 1e9) << L"GB] free={"
-                   << describe_indices(free_ixs) << L"} batch_axes={"
-                   << describe_indices(container::vector<Index>(
-                          n->batch_axes().begin(), n->batch_axes().end()))
-                   << L"} mu~axis=" << (has_mu ? L"YES" : L"NO") << L" Kaxis="
-                   << (has_k ? L"YES" : L"NO") << L"\n";
-      }
-      if (bytes > term_biggest) {
-        term_biggest = bytes;
-        term_biggest_desc = describe_indices(free_ixs);
-        term_biggest_has_mu = has_mu;
-        term_biggest_has_k = has_k;
-        term_biggest_axes = describe_indices(container::vector<Index>(
-            n->batch_axes().begin(), n->batch_axes().end()));
-      }
-    });
+    // active maps a sliced index's FULL label -> a descriptor of the ANCESTOR
+    // node that slices it (its result free-index signature + its batch_axes).
+    // This is the node-dump: it turns "escaped={}" from an inference into a
+    // concrete "mu~_X is sliced by ancestor <node>" (or ESCAPED).
+    std::function<void(std::remove_cvref_t<decltype(node)> const&,
+                       std::map<std::wstring, std::wstring>)>
+        walk = [&](auto const& n, std::map<std::wstring, std::wstring> active) {
+          auto free_ixs = node_free_indices(*n);
+          if (has_free_mu_tilde(free_ixs)) {
+            ++term_mu_nodes;
+            ++total_mu_nodes;
+            double nominal =
+                memsize(free_ixs, std::vector<Index>{}, std::vector<Index>{}) *
+                8.0;
+            double factor = 1.0;
+            std::vector<Index> escaped;  // batchable free ixs NOT sliced above
+            std::wstring sources;        // per-free-batchable-index provenance
+            for (auto const& ix : free_ixs) {
+              auto bk = ix.space().base_key();
+              if (bk != L"μ̃" && bk != L"Κ") continue;
+              auto it = active.find(keyof(ix));
+              if (it != active.end()) {
+                factor *= tgt_of(ix) / ext_of(ix);
+                sources += L"\n      " + keyof(ix) + L": SLICED by ancestor " +
+                           it->second;
+              } else {
+                escaped.push_back(ix);
+                sources += L"\n      " + keyof(ix) +
+                           L": ESCAPED (no ancestor "
+                           L"slices it)";
+              }
+            }
+            double const realized = nominal * factor;
+            bool mu_esc = false, k_esc = false;
+            for (auto const& ix : escaped)
+              (ix.space().base_key() == L"μ̃" ? mu_esc : k_esc) = true;
+            if (mu_esc) ++total_mu_nodes_with_mu_axis;  // repurposed: escaped
+            if (k_esc && !mu_esc) ++total_mu_nodes_with_k_only;
+            if (realized > 5e10) {
+              std::wcerr << L"\n  [GIANT realized=" << (realized / 1e9)
+                         << L"GB nominal=" << (nominal / 1e9) << L"GB] free={"
+                         << describe_indices(free_ixs) << L"}" << sources
+                         << L"\n";
+            }
+            if (realized > term_biggest) {
+              term_biggest = realized;
+              term_biggest_desc = describe_indices(free_ixs);
+              term_biggest_has_mu = mu_esc;
+              term_biggest_has_k = k_esc;
+              term_biggest_sources = sources;
+              term_biggest_axes = describe_indices(
+                  container::vector<Index>(escaped.begin(), escaped.end()));
+            }
+          }
+          if (!n.leaf()) {
+            std::map<std::wstring, std::wstring> child_active = active;
+            std::wstring const self_desc =
+                L"[free={" + describe_indices(node_free_indices(*n)) +
+                L"} batch_axes={" +
+                describe_indices(container::vector<Index>(
+                    n->batch_axes().begin(), n->batch_axes().end())) +
+                L"}]";
+            for (auto const& ax : n->batch_axes())
+              child_active[keyof(ax)] = self_desc;
+            walk(n.left(), child_active);
+            walk(n.right(), child_active);
+          }
+        };
+    walk(node, {});
     if (term_mu_nodes > 0) ++n_terms_with_giant;
     if (term_biggest > overall_biggest) {
       overall_biggest = term_biggest;
@@ -700,34 +822,42 @@ TEST_CASE("dryrun POST-transform PAO/K batch-axis verdict", "[dryrun-df]") {
       overall_biggest_axes = term_biggest_axes;
       overall_biggest_has_mu = term_biggest_has_mu;
       overall_biggest_has_k = term_biggest_has_k;
+      overall_biggest_sources = term_biggest_sources;
     }
     auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(
                   std::chrono::steady_clock::now() - t0)
                   .count();
     std::cerr << " " << ms << "ms  free-mu~ nodes=" << term_mu_nodes
-              << " biggest=" << (term_biggest / 1e9)
-              << "GB mu~axis=" << (term_biggest_has_mu ? "YES" : "NO")
-              << " Kaxis=" << (term_biggest_has_k ? "YES" : "NO") << "\n";
+              << " biggest_realized=" << (term_biggest / 1e9)
+              << "GB mu~escaped=" << (term_biggest_has_mu ? "YES" : "NO")
+              << " Kescaped=" << (term_biggest_has_k ? "YES" : "NO") << "\n";
   }
 
-  std::wcerr << L"\n=== POST-TRANSFORM VERDICT (mu~=1800, thr=40GB) ===\n"
+  std::wcerr << L"\n=== POST-TRANSFORM VERDICT (REALIZED peak, mu~=1800, "
+                L"thr=40GB) ===\n"
              << L"terms with a free-mu~ intermediate: " << n_terms_with_giant
              << L"/" << terms.size() << L"\n"
              << L"free-mu~ contraction nodes: " << total_mu_nodes << L"\n"
-             << L"  ... with a mu~ batch axis:      "
+             << L"  ... with a free mu~ that ESCAPED slicing: "
              << total_mu_nodes_with_mu_axis << L"\n"
-             << L"  ... with a K-ONLY batch axis:   "
+             << L"  ... with only a free K that escaped:      "
              << total_mu_nodes_with_k_only << L"\n"
-             << L"LARGEST free-mu~ intermediate: {" << overall_biggest_desc
-             << L"} = " << (overall_biggest / 1e9) << L" GB\n"
-             << L"  batch_axes = {" << overall_biggest_axes << L"}\n"
-             << L"  -> mu~ sliced: "
-             << (overall_biggest_has_mu ? L"YES" : L"NO") << L" | K sliced: "
+             << L"LARGEST REALIZED free-mu~ intermediate: {"
+             << overall_biggest_desc << L"} = " << (overall_biggest / 1e9)
+             << L" GB (realized, after ancestor slices)\n"
+             << L"  escaped (un-sliced) indices = {" << overall_biggest_axes
+             << L"}\n"
+             << L"  -> free mu~ escaped: "
+             << (overall_biggest_has_mu ? L"YES" : L"NO")
+             << L" | free K escaped: "
              << (overall_biggest_has_k ? L"YES" : L"NO") << L"\n"
-             << L"INTERPRETATION: if the giant has K-only (mu~=NO), the DP "
-                L"reproduces the C60 single-mode-aux symptom -> cost-model "
-                L"gap; if mu~=YES, the DP slices mu~ and the C60 bug is "
-                L"downstream (binarize/runtime).\n";
+             << L"  NODE-DUMP (per free batchable index, which ancestor slices "
+                L"it):"
+             << overall_biggest_sources << L"\n"
+             << L"INTERPRETATION: realized peak = what the runtime actually "
+                L"materializes. If it is >> 40GB with mu~ escaped=YES, the DP "
+                L"left the giant's free mu~ un-sliced at its contracting "
+                L"ancestor -> reproduces the C60 OOM in predicted space.\n";
 
   REQUIRE(total_mu_nodes > 0);
   SUCCEED();
@@ -1023,10 +1153,12 @@ TEST_CASE(
             << "): " << giant_nfactors << " flattened factors (of "
             << summands.size() << " summands)\n";
 
-  // C60 pVDZ-F12 scale regime -- SAME regime and SAME batchable predicate the
-  // [dryrun-df] verdict case used (df_regime/is_df_batchable, defined above).
-  auto regime = df_regime(/*mu_tilde=*/1800u, /*aux=*/4320u, /*i_occ=*/32u,
-                          /*pno=*/19.0, /*osv=*/57.0);
+  // FAITHFUL real C60 config (614336 job log): occ=120, PNO=42, OSV=310,
+  // mu~=1800, aux=4320, pao_target_size=256, aux_target_size=72,
+  // volatile_weight=20, machine_balance=200, fast_mem_elems=1e6. SAME regime
+  // and SAME batchable predicate the [dryrun-df] verdict case uses.
+  auto regime = df_regime(/*mu_tilde=*/1800u, /*aux=*/4320u, /*i_occ=*/120u,
+                          /*pno=*/42.0, /*osv=*/310.0);
   auto cm = std::make_shared<CostModel const>(regime);
 
   // ONE BatchPolicy object, reused verbatim for both optimize() and the
@@ -1035,7 +1167,12 @@ TEST_CASE(
   // "target batch size" cannot drift apart.
   sequant::BatchPolicy policy;
   policy.is_batchable_index = is_df_batchable;
-  policy.batch_target_size = [](Index const&) { return std::size_t{100}; };
+  policy.batch_target_size = [](Index const& ix) -> std::size_t {
+    return ix.space().base_key() == L"μ̃" ? std::size_t{256}  // pao_target_size
+                                         : std::size_t{72};  // aux_target_size
+  };
+  policy.is_volatile_leaf = [](Tensor const& t) { return t.label() == L"t"; };
+  policy.accumulation_factor = 1.0;
   policy.peak_threshold = 40e9;  // DP-side knob only; the runtime evaluator
                                  // never consults peak_threshold.
 
@@ -1046,6 +1183,9 @@ TEST_CASE(
   opts.idx_to_extent = regime.idx_to_extent();
   opts.inner_pow = regime.inner_pow_fn();
   opts.batch_policy = policy;
+  opts.volatile_weight = 20.0;
+  opts.roofline.machine_balance = 200.0;
+  opts.roofline.fast_mem_elems = 1000000.0;
   opts.term_batch_axes = axes_map;
 
   auto t0 = std::chrono::steady_clock::now();
@@ -1230,3 +1370,171 @@ TEST_CASE(
 
   CHECK(peak > 0);
 }
+
+// Task 6 (perf-first validation): optimize the SAME C60 giant term (index 38)
+// under BOTH the peak-first (DenseSpaceTimeBatched) and perf-first
+// (DenseTimeSpaceBatched) objectives, at the faithful real config, and compare
+// the factorization the DP picks. The 4-PAO signature is a contraction node
+// carrying >= 4 free mu~ indices (the (mu~ mu~|mu~ mu~) AO integral).
+// Peak-first forms it (fully sliceable below the 40 GB threshold, so it
+// survives the hard filter despite astronomically higher flops); perf-first is
+// flops-primary and must NEVER form it. This is the direct in-harness proof of
+// the fix, on ONE term (~seconds), without the [dryrun-df] full-sweep cost.
+TEST_CASE("dryrun perf-first vs peak-first factorization of the C60 giant term",
+          "[dryrun-perf]") {
+  auto ctx = get_default_context().clone();
+  ctx.set_first_dummy_index_ordinal(1000000);
+  auto isr = ctx.mutable_index_space_registry();
+  REQUIRE(isr != nullptr);
+  sequant::mbpt::add_pao_spaces(isr);  // mu~
+  sequant::mbpt::add_df_spaces(isr);   // K
+  auto ctx_resetter = set_scoped_default_context(std::move(ctx));
+
+  auto const body = slurp(std::string(SEQUANT_UNIT_TESTS_SOURCE_DIR) +
+                          "/data/csv_ccsd_doubles_residual_df.txt");
+  REQUIRE(!body.empty());
+  std::string line = body;
+  if (auto nl = line.find('\n'); nl != std::string::npos)
+    line = line.substr(0, nl);
+  auto expr = deserialize<ExprPtr>(line);
+  REQUIRE(static_cast<bool>(expr));
+  REQUIRE(expr->is<Sum>());
+  auto const& summands = expr->as<Sum>().summands();
+  REQUIRE(!summands.empty());
+  auto flatten_product = [](ExprPtr const& e) -> ExprPtr {
+    if (!e->is<Product>()) return e;
+    auto const& p = e->as<Product>();
+    return ex<Product>(p.scalar(), p.factors(), Product::Flatten::Yes);
+  };
+  std::size_t const giant_idx = 38 < summands.size() ? 38 : 0;
+  ExprPtr giant = flatten_product(summands[giant_idx]);
+  REQUIRE(giant);
+
+  // FAITHFUL real C60 config (614336 job log), identical to [dryrun-eval].
+  auto regime = df_regime(/*mu_tilde=*/1800u, /*aux=*/4320u, /*i_occ=*/120u,
+                          /*pno=*/42.0, /*osv=*/310.0);
+  auto memsize = sequant::opt::detail::memsize_counter(regime.idx_to_extent(),
+                                                       regime.inner_pow_fn());
+  auto ext_of = [](Index const& ix) -> double {
+    auto bk = ix.space().base_key();
+    if (bk == L"μ̃") return 1800.0;
+    if (bk == L"Κ") return 4320.0;
+    return 0.0;
+  };
+  auto tgt_of = [](Index const& ix) -> double {
+    return ix.space().base_key() == L"μ̃" ? 256.0 : 72.0;
+  };
+  auto keyof = [](Index const& ix) { return std::wstring(ix.full_label()); };
+
+  struct Analysis {
+    std::size_t max_free_mu = 0;  // >= 4 => 4-PAO AO integral formed
+    double largest_realized_gb = 0.0;
+    std::wstring largest_desc;
+  };
+
+  // Optimize the giant under `obj`, binarize, and walk the tree computing per
+  // node (a) its free-mu~ count and (b) its REALIZED free-mu~ size after
+  // ancestor slicing (same active-ancestor accounting as the [dryrun-df]
+  // verdict case). Returns the max over all nodes.
+  auto analyze = [&](ObjectiveFunction obj) -> Analysis {
+    sequant::BatchPolicy policy;
+    policy.is_batchable_index = is_df_batchable;
+    policy.batch_target_size = [](Index const& ix) -> std::size_t {
+      return ix.space().base_key() == L"μ̃" ? std::size_t{256} : std::size_t{72};
+    };
+    policy.is_volatile_leaf = [](Tensor const& t) { return t.label() == L"t"; };
+    policy.accumulation_factor = 1.0;
+    policy.peak_threshold = 40e9;
+
+    auto axes_map = std::make_shared<std::unordered_map<
+        Expr const*, container::vector<container::svector<Index>>>>();
+    OptimizeOptions opts;
+    opts.objective_function = obj;
+    opts.idx_to_extent = regime.idx_to_extent();
+    opts.inner_pow = regime.inner_pow_fn();
+    opts.batch_policy = policy;
+    opts.volatile_weight = 20.0;
+    opts.roofline.machine_balance = 200.0;
+    opts.roofline.fast_mem_elems = 1000000.0;
+    opts.term_batch_axes = axes_map;
+
+    auto t0 = std::chrono::steady_clock::now();
+    auto optimized = optimize(giant, opts);
+    auto const opt_ms = std::chrono::duration_cast<std::chrono::milliseconds>(
+                            std::chrono::steady_clock::now() - t0)
+                            .count();
+    REQUIRE(static_cast<bool>(optimized));
+    auto it = axes_map->find(optimized.get());
+    container::vector<container::svector<Index>> node_axes;
+    if (it != axes_map->end()) node_axes = it->second;
+    BinarizationOptions bopts;
+    bopts.node_batch_axes = node_axes;
+    SEQUANT_PRAGMA_IGNORE_DEPRECATED_BEGIN
+    auto node = binarize(optimized, {}, bopts);
+    SEQUANT_PRAGMA_IGNORE_DEPRECATED_END
+
+    Analysis a;
+    std::function<void(std::remove_cvref_t<decltype(node)> const&,
+                       std::map<std::wstring, std::wstring>)>
+        walk = [&](auto const& n, std::map<std::wstring, std::wstring> active) {
+          auto free_ixs = node_free_indices(*n);
+          std::size_t nmu = 0;
+          for (auto const& ix : free_ixs)
+            if (ix.space().base_key() == L"μ̃") ++nmu;
+          if (nmu > a.max_free_mu) a.max_free_mu = nmu;
+          if (nmu > 0) {
+            double nominal =
+                memsize(free_ixs, std::vector<Index>{}, std::vector<Index>{}) *
+                8.0;
+            double factor = 1.0;
+            for (auto const& ix : free_ixs) {
+              auto bk = ix.space().base_key();
+              if (bk != L"μ̃" && bk != L"Κ") continue;
+              if (active.find(keyof(ix)) != active.end())
+                factor *= tgt_of(ix) / ext_of(ix);
+            }
+            double const realized_gb = nominal * factor / 1e9;
+            if (realized_gb > a.largest_realized_gb) {
+              a.largest_realized_gb = realized_gb;
+              a.largest_desc = describe_indices(free_ixs);
+            }
+          }
+          if (!n.leaf()) {
+            std::map<std::wstring, std::wstring> child_active = active;
+            for (auto const& ax : n->batch_axes())
+              child_active[keyof(ax)] = L"y";
+            walk(n.left(), child_active);
+            walk(n.right(), child_active);
+          }
+        };
+    walk(node, {});
+    wchar_t const* obj_name = (obj == ObjectiveFunction::DenseTimeSpaceBatched)
+                                  ? L"perf-first (DenseTimeSpaceBatched)"
+                                  : L"peak-first (DenseSpaceTimeBatched)";
+    std::wcerr << L"[dryrun-perf] " << obj_name << L": optimize " << opt_ms
+               << L"ms  max free-mu~ on a node=" << a.max_free_mu
+               << L"  largest realized free-mu~={" << a.largest_desc << L"}="
+               << a.largest_realized_gb << L" GB\n";
+    return a;
+  };
+
+  auto peak_first = analyze(ObjectiveFunction::DenseSpaceTimeBatched);
+  auto perf_first = analyze(ObjectiveFunction::DenseTimeSpaceBatched);
+
+  std::wcerr << L"\n=== [dryrun-perf] VERDICT (C60 giant, index 38) ===\n"
+             << L"peak-first (DenseSpaceTimeBatched): 4-PAO node formed = "
+             << (peak_first.max_free_mu >= 4 ? L"YES" : L"NO")
+             << L" (max free mu~=" << peak_first.max_free_mu
+             << L"), largest realized free-mu~="
+             << peak_first.largest_realized_gb << L" GB\n"
+             << L"perf-first (DenseTimeSpaceBatched): 4-PAO node formed = "
+             << (perf_first.max_free_mu >= 4 ? L"YES" : L"NO")
+             << L" (max free mu~=" << perf_first.max_free_mu
+             << L"), largest realized free-mu~="
+             << perf_first.largest_realized_gb << L" GB\n";
+
+  // Peak-first forms the fully-sliceable 4-PAO AO integral (the C60 pathology).
+  CHECK(peak_first.max_free_mu >= 4);
+  // Perf-first, being flops-primary, must never form it.
+  CHECK(perf_first.max_free_mu < 4);
+}

From b05fab6ba6d324e5d5e09531c5b259970397a761 Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Sun, 5 Jul 2026 08:14:22 -0400
Subject: [PATCH 28/78] eval: [dryrun-perf] report cache high watermark +
 diagnose the gap

Extend [dryrun-perf] to also REPLAY the zero-data schedule (both objectives)
through the real eval loop + real CacheManager and report
cache.working_set_hwmark() alongside the largest single transient (result=) and
its full trace line.

Two findings, now documented in the test:

(1) The outer working_set_hwmark is NOT the whole peak under batching. The
    batched custom evaluator runs each batch against a SEPARATE scratch cache
    (make_batched_scratch, eval.hpp:1386), so the peak-first 4-PAO giant's per-op
    hw= reaches ~38.9 GB INSIDE that scratch while the outer accessor reports
    only ~0.2 GB. The outer accessor tracks cached (cross-batch) residency, not
    batched-inner transients.

(2) The runtime Result sizing is not moment-aware. The perf-first largest
    transient = 358.47 GB = 120^2*42^4*8 (occ^2*PNO^4) EXACTLY = the twin-PNO
    size_in_bytes() artifact; the DP cost model's moment-aware size (~89 GB, via
    inner_pow) is the real number.

Conclusion: the moment-aware DP peak model is the reliable predictor today; the
runtime replay hwmark is not, until scratch hwmarks propagate and the Result
sizing is moment-aware.
---
 tests/unit/test_eval_dryrun.cpp | 166 +++++++++++++++++++++++++++++---
 1 file changed, 150 insertions(+), 16 deletions(-)

diff --git a/tests/unit/test_eval_dryrun.cpp b/tests/unit/test_eval_dryrun.cpp
index 5f40edb107..aeac07f1ee 100644
--- a/tests/unit/test_eval_dryrun.cpp
+++ b/tests/unit/test_eval_dryrun.cpp
@@ -1425,17 +1425,32 @@ TEST_CASE("dryrun perf-first vs peak-first factorization of the C60 giant term",
     return ix.space().base_key() == L"μ̃" ? 256.0 : 72.0;
   };
   auto keyof = [](Index const& ix) { return std::wstring(ix.full_label()); };
+  auto cm = std::make_shared<CostModel const>(regime);
 
   struct Analysis {
-    std::size_t max_free_mu = 0;  // >= 4 => 4-PAO AO integral formed
-    double largest_realized_gb = 0.0;
+    std::size_t max_free_mu = 0;       // >= 4 => 4-PAO AO integral formed
+    double largest_realized_gb = 0.0;  // DP-model realized free-mu~ (static)
     std::wstring largest_desc;
+    // Runtime-replay metrics (zero-data eval through the REAL eval loop + REAL
+    // CacheManager):
+    double hwmark_gb =
+        0.0;  // cache.working_set_hwmark() = per-op running max
+              // of (sum of alive cached entries + in-flight
+              // result). "high watermark of cached intermediates"
+    double max_single_result_gb = 0.0;  // largest single result= in the trace =
+                                        // the largest transient materialized
+    std::string largest_result_line;    // full trace line of that result=
+                                        // (shows result= and hw= together)
+    bool replay_threw = false;
   };
 
   // Optimize the giant under `obj`, binarize, and walk the tree computing per
   // node (a) its free-mu~ count and (b) its REALIZED free-mu~ size after
   // ancestor slicing (same active-ancestor accounting as the [dryrun-df]
-  // verdict case). Returns the max over all nodes.
+  // verdict case). Then REPLAY the zero-data schedule through the real eval
+  // loop + real CacheManager to capture the cached-intermediate high watermark
+  // (working_set_hwmark) alongside the largest single transient (result=), so
+  // the cache-vs-transient accounting gap is visible per objective.
   auto analyze = [&](ObjectiveFunction obj) -> Analysis {
     sequant::BatchPolicy policy;
     policy.is_batchable_index = is_df_batchable;
@@ -1470,7 +1485,7 @@ TEST_CASE("dryrun perf-first vs peak-first factorization of the C60 giant term",
     BinarizationOptions bopts;
     bopts.node_batch_axes = node_axes;
     SEQUANT_PRAGMA_IGNORE_DEPRECATED_BEGIN
-    auto node = binarize(optimized, {}, bopts);
+    auto node = binarize<EvalExprDryRun>(optimized, {}, bopts);
     SEQUANT_PRAGMA_IGNORE_DEPRECATED_END
 
     Analysis a;
@@ -1508,30 +1523,149 @@ TEST_CASE("dryrun perf-first vs peak-first factorization of the C60 giant term",
           }
         };
     walk(node, {});
+
+    // ---- runtime replay: predict the cached-intermediate high watermark ----
+    // Zero-data eval through the real eval loop + real CacheManager, with the
+    // real batched custom evaluator. working_set_hwmark() folds, per op, (sum
+    // of alive cached entries + in-flight result) into a running max; the
+    // trace's result= field is the largest single materialized transient.
+    // (Single-term, default cache_manager: this is the WITHIN-TERM cached
+    // working set. The whole-residual / cross-iteration watermark -- one shared
+    // cache over the full DAG with the real max_footprint gate -- is the
+    // deferred DryRun-as-prefix wiring.)
+    auto cache = sequant::cache_manager(std::vector<EvalNodeDryRun>{node});
+    cache.set_custom_evaluator(
+        sequant::make_evaluator(policy, DryRunLeafEvaluator{cm}));
+    std::ostringstream trace_os;
+    auto& logger = Logger::instance();
+    auto const prev_level = logger.eval.level;
+    auto* const prev_stream = logger.eval.stream;
+    logger.eval.level = 2;  // gate log::printing() on so hwmark accumulates
+    logger.eval.stream = &trace_os;
+    try {
+      (void)sequant::evaluate<Trace::On>(node, DryRunLeafEvaluator{cm}, cache);
+    } catch (std::exception const&) {
+      a.replay_threw = true;
+    }
+    logger.eval.level = prev_level;
+    logger.eval.stream = prev_stream;
+    a.hwmark_gb = double(cache.working_set_hwmark()) / 1e9;
+    // Largest single result= in the trace, and its full line (result= and hw=
+    // appear together, so the line exposes whether the giant transient is
+    // folded into the cache hwmark).
+    {
+      std::string const trace = trace_os.str();
+      std::size_t pos = 0, best = 0;
+      while ((pos = trace.find("result=", pos)) != std::string::npos) {
+        std::size_t const np = pos + std::string("result=").size();
+        std::size_t const end = trace.find('B', np);
+        if (end == std::string::npos) break;
+        std::string const num = trace.substr(np, end - np);
+        if (!num.empty() &&
+            num.find_first_not_of("0123456789") == std::string::npos) {
+          std::size_t const v = std::stoull(num);
+          if (v > best) {
+            best = v;
+            std::size_t ls = trace.rfind('\n', pos);
+            ls = (ls == std::string::npos) ? 0 : ls + 1;
+            std::size_t const le = trace.find('\n', pos);
+            a.largest_result_line = trace.substr(
+                ls, (le == std::string::npos ? trace.size() : le) - ls);
+          }
+        }
+        pos = end;
+      }
+      a.max_single_result_gb = double(best) / 1e9;
+    }
+
     wchar_t const* obj_name = (obj == ObjectiveFunction::DenseTimeSpaceBatched)
                                   ? L"perf-first (DenseTimeSpaceBatched)"
                                   : L"peak-first (DenseSpaceTimeBatched)";
     std::wcerr << L"[dryrun-perf] " << obj_name << L": optimize " << opt_ms
                << L"ms  max free-mu~ on a node=" << a.max_free_mu
                << L"  largest realized free-mu~={" << a.largest_desc << L"}="
-               << a.largest_realized_gb << L" GB\n";
+               << a.largest_realized_gb << L" GB\n               replay: cache "
+               << L"working_set_hwmark=" << a.hwmark_gb
+               << L" GB  largest single transient(result=)="
+               << a.max_single_result_gb << L" GB"
+               << (a.replay_threw ? L"  [replay threw]" : L"") << L"\n";
     return a;
   };
 
   auto peak_first = analyze(ObjectiveFunction::DenseSpaceTimeBatched);
   auto perf_first = analyze(ObjectiveFunction::DenseTimeSpaceBatched);
 
-  std::wcerr << L"\n=== [dryrun-perf] VERDICT (C60 giant, index 38) ===\n"
-             << L"peak-first (DenseSpaceTimeBatched): 4-PAO node formed = "
-             << (peak_first.max_free_mu >= 4 ? L"YES" : L"NO")
-             << L" (max free mu~=" << peak_first.max_free_mu
-             << L"), largest realized free-mu~="
-             << peak_first.largest_realized_gb << L" GB\n"
-             << L"perf-first (DenseTimeSpaceBatched): 4-PAO node formed = "
-             << (perf_first.max_free_mu >= 4 ? L"YES" : L"NO")
-             << L" (max free mu~=" << perf_first.max_free_mu
-             << L"), largest realized free-mu~="
-             << perf_first.largest_realized_gb << L" GB\n";
+  auto report = [](wchar_t const* tag, Analysis const& a) {
+    std::wcerr << tag << L": 4-PAO node formed = "
+               << (a.max_free_mu >= 4 ? L"YES" : L"NO") << L" (max free mu~="
+               << a.max_free_mu << L")\n    DP-model largest realized free-mu~="
+               << a.largest_realized_gb << L" GB {" << a.largest_desc << L"}\n"
+               << L"    replay cache working_set_hwmark=" << a.hwmark_gb
+               << L" GB  largest single transient(result=)="
+               << a.max_single_result_gb << L" GB\n";
+  };
+  std::wcerr << L"\n=== [dryrun-perf] VERDICT (C60 giant, index 38) ===\n";
+  report(L"peak-first (DenseSpaceTimeBatched)", peak_first);
+  report(L"perf-first (DenseTimeSpaceBatched)", perf_first);
+  // (b) The cache-vs-transient accounting gap: print the full trace line of the
+  // largest single materialized result for each objective. result= (the
+  // transient) and hw= (the cache watermark at that op) appear together, so a
+  // large result= with a small hw= means the transient is NOT folded into the
+  // cache high watermark (it is a streamed/batched result, never a cached
+  // co-resident entry) -- i.e. working_set_hwmark tracks CACHED residency, not
+  // the transient peak. The two together bound the true peak memory.
+  std::wcerr
+      << L"\n--- largest transient trace line (result= with its hw=) ---\n";
+  {
+    std::string const& pl = peak_first.largest_result_line;
+    std::string const& tl = perf_first.largest_result_line;
+    std::wcerr << L"peak-first: " << std::wstring(pl.begin(), pl.end()) << L"\n"
+               << L"perf-first: " << std::wstring(tl.begin(), tl.end())
+               << L"\n";
+  }
+
+  // INTERPRETATION -- why the outer working_set_hwmark is NOT the whole peak,
+  // and why the replay sizes are not directly comparable to the DP-model sizes:
+  //
+  // (1) Batched transients are invisible to the OUTER cache accessor. The
+  //     batched custom evaluator runs each batch against a SEPARATE scratch
+  //     cache (detail::make_batched_scratch, eval.hpp:1386), so the per-op hw=
+  //     field on the peak-first giant reaches ~38.9 GB (the 34 GB 4-PAO result
+  //     + operands) INSIDE that scratch, while the outer
+  //     cache.working_set_hwmark() reports only ~0.2 GB (outer-scope ops). So
+  //     the outer accessor tracks CACHED (persistent, cross-batch) residency,
+  //     not the batched-inner transient peak. Reading the whole peak requires
+  //     folding each scratch cache's hwmark into a global accumulator.
+  //
+  // (2) Twin-PNO composite Results are mis-sized by the runtime backend. The
+  //     perf-first largest transient = 358.47 GB = 120^2 * 42^4 * 8 EXACTLY
+  //     (occ^2 * PNO^4): the DryRun Result's size_in_bytes() sizes the
+  //     twin-PNO result R{a<i,i>,a<i,i>;i,i} as the naive product, NOT the
+  //     power-mean moment (occ^2 * PNO^2 ~ 89 GB) the DP cost model uses via
+  //     inner_pow. So the perf-first replay hwmark (~358 GB) is a sizing
+  //     artifact, ~4x the true ~89 GB; the DP-model realized size (89 GB) is
+  //     the trustworthy number. A faithful cached-watermark predictor needs the
+  //     runtime Result sizing to be moment-aware too.
+  //
+  // Bottom line: the moment-aware DP peak model is the reliable predictor
+  // today; the runtime replay hwmark is not, until (1) scratch hwmarks
+  // propagate and (2) the Result sizing is moment-aware.
+  std::wcerr
+      << L"\n--- INTERPRETATION ---\n"
+      << L"(1) peak-first outer hwmark (" << peak_first.hwmark_gb
+      << L" GB) << its batched-inner transient ("
+      << peak_first.max_single_result_gb
+      << L" GB, hw= inside a make_batched_scratch cache): the OUTER accessor "
+         L"misses batched transients.\n"
+      << L"(2) perf-first transient " << perf_first.max_single_result_gb
+      << L" GB = 120^2*42^4*8 (occ^2*PNO^4) = the twin-PNO size_in_bytes() "
+         L"artifact; the moment-aware DP size ("
+      << perf_first.largest_realized_gb
+      << L" GB) is the real number. Runtime Result sizing is NOT "
+         L"moment-aware.\n"
+      << L"=> DP-model peak is the reliable predictor; the replay hwmark is "
+         L"not "
+         L"(yet).\n";
 
   // Peak-first forms the fully-sliceable 4-PAO AO integral (the C60 pathology).
   CHECK(peak_first.max_free_mu >= 4);

From 91dd48a2dbb9617a3812141aa01c0e3de43b7d2e Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Sun, 5 Jul 2026 09:26:43 -0400
Subject: [PATCH 29/78] eval: [dryrun-perf] optional DRYRUN_PERF_TREE schedule
 dump (free ixs + batch_axes per node)

---
 tests/unit/test_eval_dryrun.cpp | 31 +++++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)

diff --git a/tests/unit/test_eval_dryrun.cpp b/tests/unit/test_eval_dryrun.cpp
index aeac07f1ee..823e74d122 100644
--- a/tests/unit/test_eval_dryrun.cpp
+++ b/tests/unit/test_eval_dryrun.cpp
@@ -1488,6 +1488,37 @@ TEST_CASE("dryrun perf-first vs peak-first factorization of the C60 giant term",
     auto node = binarize<EvalExprDryRun>(optimized, {}, bopts);
     SEQUANT_PRAGMA_IGNORE_DEPRECATED_END
 
+    // Optional full-tree dump (DRYRUN_PERF_TREE=1): every node's free indices
+    // and batch_axes (the indices SLICED, i.e. batched, at that node), in
+    // post-order-ish indentation, so the exact schedule is inspectable.
+    if (std::getenv("DRYRUN_PERF_TREE")) {
+      wchar_t const* on = (obj == ObjectiveFunction::DenseTimeSpaceBatched)
+                              ? L"perf-first (DenseTimeSpaceBatched)"
+                              : L"peak-first (DenseSpaceTimeBatched)";
+      std::wcerr << L"\n[dryrun-perf] TREE for " << on << L":\n";
+      std::function<void(std::remove_cvref_t<decltype(node)> const&, int)>
+          dump = [&](auto const& n, int depth) {
+            std::wstring const pad(2 * depth + 2, L' ');
+            auto const free = node_free_indices(*n);
+            container::vector<Index> const bax(n->batch_axes().begin(),
+                                               n->batch_axes().end());
+            std::size_t nmu = 0, nk = 0;
+            for (auto const& ix : free) {
+              if (ix.space().base_key() == L"μ̃") ++nmu;
+              if (ix.space().base_key() == L"Κ") ++nk;
+            }
+            std::wcerr << pad << (n.leaf() ? L"leaf  " : L"CONTRACT ")
+                       << L"free={" << describe_indices(free) << L"} (mu~="
+                       << nmu << L" K=" << nk << L")  batch_axes={"
+                       << describe_indices(bax) << L"}\n";
+            if (!n.leaf()) {
+              dump(n.left(), depth + 1);
+              dump(n.right(), depth + 1);
+            }
+          };
+      dump(node, 0);
+    }
+
     Analysis a;
     std::function<void(std::remove_cvref_t<decltype(node)> const&,
                        std::map<std::wstring, std::wstring>)>

From 8cda8ce76482d059d5e2ae0630898f5d22de624e Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Sun, 5 Jul 2026 10:49:21 -0400
Subject: [PATCH 30/78] eval: [dryrun-trace] whole-residual dry-run trace to a
 file

Add a hidden ([.]) test that optimizes+binarizes EVERY summand of the
post-transform PNO-CCSD doubles residual, then replays them all through the real
eval loop and ONE shared CacheManager (cross-term CSE, as in MPQC's
process_for_evaluation), writing the full per-op trace
("Eval | ... left= right= result= alloc= hw= rss= | <expr>") to a file.

Select explicitly (minutes-long; trace can be hundreds of MB):
  ./unit_tests-sequant "[dryrun-trace]"
Env: DRYRUN_OBJ (dense_time_space default | dense_space_time),
     DRYRUN_TRACE_FILE (default /tmp/dryrun_residual_trace.txt),
     DRYRUN_MAX_TERMS (default 0 = all; cap for a quick smoke run).

Smoke (DRYRUN_MAX_TERMS=3): 3 summands -> 32729 trace lines, one shared cache.
---
 tests/unit/test_eval_dryrun.cpp | 151 ++++++++++++++++++++++++++++++++
 1 file changed, 151 insertions(+)

diff --git a/tests/unit/test_eval_dryrun.cpp b/tests/unit/test_eval_dryrun.cpp
index 823e74d122..80ce8b2cde 100644
--- a/tests/unit/test_eval_dryrun.cpp
+++ b/tests/unit/test_eval_dryrun.cpp
@@ -1703,3 +1703,154 @@ TEST_CASE("dryrun perf-first vs peak-first factorization of the C60 giant term",
   // Perf-first, being flops-primary, must never form it.
   CHECK(perf_first.max_free_mu < 4);
 }
+
+// Whole-residual dry-run trace: optimize+binarize EVERY summand of the
+// post-transform PNO-CCSD doubles residual, then replay them all through the
+// real eval loop and ONE SHARED CacheManager (so cross-term CSE / persistent
+// caching is exercised, as in MPQC's process_for_evaluation), with the per-op
+// trace ("Eval | ... result= ... hw= ...") written to a FILE. Hidden ([.])
+// because the batched DP runs per summand and the trace can be hundreds of MB;
+// select it explicitly:
+//   ./unit_tests-sequant "[dryrun-trace]"
+// Env knobs (all optional):
+//   DRYRUN_OBJ         dense_time_space (default, perf-first) |
+//   dense_space_time DRYRUN_TRACE_FILE  output path (default
+//   /tmp/dryrun_residual_trace.txt) DRYRUN_MAX_TERMS   cap #summands (default 0
+//   = all) -- for a quick smoke run
+TEST_CASE("dryrun whole-residual trace (PNO-CCSD doubles)",
+          "[.][dryrun-trace]") {
+  auto ctx = get_default_context().clone();
+  ctx.set_first_dummy_index_ordinal(1000000);
+  auto isr = ctx.mutable_index_space_registry();
+  REQUIRE(isr != nullptr);
+  sequant::mbpt::add_pao_spaces(isr);  // mu~
+  sequant::mbpt::add_df_spaces(isr);   // K
+  auto ctx_resetter = set_scoped_default_context(std::move(ctx));
+
+  auto const body = slurp(std::string(SEQUANT_UNIT_TESTS_SOURCE_DIR) +
+                          "/data/csv_ccsd_doubles_residual_df.txt");
+  REQUIRE(!body.empty());
+  std::string line = body;
+  if (auto nl = line.find('\n'); nl != std::string::npos)
+    line = line.substr(0, nl);
+  auto expr = deserialize<ExprPtr>(line);
+  REQUIRE(static_cast<bool>(expr));
+  REQUIRE(expr->is<Sum>());
+  auto flatten_product = [](ExprPtr const& e) -> ExprPtr {
+    if (!e->is<Product>()) return e;
+    auto const& p = e->as<Product>();
+    return ex<Product>(p.scalar(), p.factors(), Product::Flatten::Yes);
+  };
+  std::vector<ExprPtr> terms;
+  for (auto const& s : expr->as<Sum>().summands())
+    terms.push_back(flatten_product(s));
+  REQUIRE(!terms.empty());
+
+  // Objective (perf-first default; dense_space_time / dense_peak_size = peak).
+  char const* const obj_env = std::getenv("DRYRUN_OBJ");
+  std::string const obj_s = obj_env ? obj_env : "dense_time_space";
+  ObjectiveFunction const obj =
+      (obj_s == "dense_space_time" || obj_s == "dense_peak_size")
+          ? ObjectiveFunction::DenseSpaceTimeBatched
+          : ObjectiveFunction::DenseTimeSpaceBatched;
+  char const* const max_env = std::getenv("DRYRUN_MAX_TERMS");
+  std::size_t const max_terms =
+      max_env ? static_cast<std::size_t>(std::atoll(max_env)) : 0u;
+  std::size_t const n_terms =
+      (max_terms > 0 && max_terms < terms.size()) ? max_terms : terms.size();
+
+  // FAITHFUL real C60 config (614336 job log), identical to [dryrun-eval].
+  auto regime = df_regime(1800u, 4320u, 120u, 42.0, 310.0);
+  auto cm = std::make_shared<CostModel const>(regime);
+  sequant::BatchPolicy policy;
+  policy.is_batchable_index = is_df_batchable;
+  policy.batch_target_size = [](Index const& ix) -> std::size_t {
+    return ix.space().base_key() == L"μ̃" ? std::size_t{256} : std::size_t{72};
+  };
+  policy.is_volatile_leaf = [](Tensor const& t) { return t.label() == L"t"; };
+  policy.accumulation_factor = 1.0;
+  policy.peak_threshold = 40e9;
+
+  // Phase 1: optimize + binarize every summand; collect the DryRun trees so one
+  // shared cache can count cross-term repeats.
+  std::vector<EvalNodeDryRun> nodes;
+  nodes.reserve(n_terms);
+  for (std::size_t ti = 0; ti < n_terms; ++ti) {
+    std::cerr << "[dryrun-trace] optimizing summand " << (ti + 1) << "/"
+              << n_terms << " ..." << std::flush;
+    auto axes_map = std::make_shared<std::unordered_map<
+        Expr const*, container::vector<container::svector<Index>>>>();
+    OptimizeOptions opts;
+    opts.objective_function = obj;
+    opts.idx_to_extent = regime.idx_to_extent();
+    opts.inner_pow = regime.inner_pow_fn();
+    opts.batch_policy = policy;
+    opts.volatile_weight = 20.0;
+    opts.roofline.machine_balance = 200.0;
+    opts.roofline.fast_mem_elems = 1000000.0;
+    opts.term_batch_axes = axes_map;
+    auto t0 = std::chrono::steady_clock::now();
+    auto optimized = optimize(terms[ti], opts);
+    auto const ms = std::chrono::duration_cast<std::chrono::milliseconds>(
+                        std::chrono::steady_clock::now() - t0)
+                        .count();
+    std::cerr << " " << ms << "ms\n";
+    if (!static_cast<bool>(optimized)) continue;
+    auto it = axes_map->find(optimized.get());
+    container::vector<container::svector<Index>> node_axes;
+    if (it != axes_map->end()) node_axes = it->second;
+    BinarizationOptions bopts;
+    bopts.node_batch_axes = node_axes;
+    SEQUANT_PRAGMA_IGNORE_DEPRECATED_BEGIN
+    nodes.push_back(binarize<EvalExprDryRun>(optimized, {}, bopts));
+    SEQUANT_PRAGMA_IGNORE_DEPRECATED_END
+  }
+  REQUIRE(!nodes.empty());
+
+  // Phase 2: one shared cache over ALL trees (cross-term CSE), the real batched
+  // evaluator, trace -> file. The cache is NOT reset between summands, so
+  // working_set_hwmark() reflects cross-term cached residency (subject to the
+  // [dryrun-perf] caveats: batched-inner transients and twin-PNO sizing).
+  auto cache = sequant::cache_manager(nodes);
+  cache.set_custom_evaluator(
+      sequant::make_evaluator(policy, DryRunLeafEvaluator{cm}));
+
+  char const* const file_env = std::getenv("DRYRUN_TRACE_FILE");
+  std::string const trace_path =
+      file_env ? file_env : "/tmp/dryrun_residual_trace.txt";
+  std::ofstream trace_file(trace_path);
+  REQUIRE(trace_file.is_open());
+  auto& logger = Logger::instance();
+  auto const prev_level = logger.eval.level;
+  auto* const prev_stream = logger.eval.stream;
+  logger.eval.level = 2;  // gate log::printing() on
+  logger.eval.stream = &trace_file;
+
+  std::size_t n_ok = 0;
+  for (std::size_t i = 0; i < nodes.size(); ++i) {
+    try {
+      (void)sequant::evaluate<Trace::On>(nodes[i], DryRunLeafEvaluator{cm},
+                                         cache);
+      ++n_ok;
+    } catch (std::exception const& e) {
+      trace_file << "  [summand " << i << " threw: " << e.what() << "]\n";
+    }
+  }
+
+  logger.eval.level = prev_level;
+  logger.eval.stream = prev_stream;
+  trace_file.flush();
+  auto const hwmark_gb = double(cache.working_set_hwmark()) / 1e9;
+
+  std::wcerr << L"\n=== [dryrun-trace] whole-residual trace written ===\n"
+             << L"objective    = "
+             << (obj == ObjectiveFunction::DenseTimeSpaceBatched
+                     ? L"dense_time_space (perf-first)"
+                     : L"dense_space_time (peak-first)")
+             << L"\nsummands     = " << n_ok << L"/" << nodes.size()
+             << L" evaluated\ncache hwmark = " << hwmark_gb
+             << L" GB (cross-term cached residency; see [dryrun-perf] caveats)"
+             << L"\ntrace file   = "
+             << std::wstring(trace_path.begin(), trace_path.end()) << L"\n";
+  SUCCEED();
+}

From 52300a3e26eec6d2484c3068fe8a228a4a41e5e2 Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Sun, 5 Jul 2026 11:42:04 -0400
Subject: [PATCH 31/78] eval: design spec for dry-run cost-profile prediction
 (SQ + MPQC)

---
 ...5-dryrun-cost-profile-prediction-design.md | 186 ++++++++++++++++++
 1 file changed, 186 insertions(+)
 create mode 100644 doc/dev/specs/2026-07-05-dryrun-cost-profile-prediction-design.md

diff --git a/doc/dev/specs/2026-07-05-dryrun-cost-profile-prediction-design.md b/doc/dev/specs/2026-07-05-dryrun-cost-profile-prediction-design.md
new file mode 100644
index 0000000000..317ff5a384
--- /dev/null
+++ b/doc/dev/specs/2026-07-05-dryrun-cost-profile-prediction-design.md
@@ -0,0 +1,186 @@
+# Dry-run cost-profile prediction (SQ + MPQC)
+
+**Goal:** Make the SeQuant DryRun eval backend a faithful, reusable predictor of
+a factorized schedule's full cost profile -- peak memory, FLOPs, and roofline
+wall-time -- and wire it into MPQC as a predict-then-run pre-flight fed by the
+real CSV size moments, so a CCk residual's memory/cost can be predicted from the
+same factorized IR that the real run evaluates.
+
+**Architecture:** One dry-run pipeline. The DryRun backend
+(`SeQuant/core/eval/backends/dryrun/`) gains a `cost_profile(...)` entry point
+that replays the zero-data schedule through the real eval loop + a cache built
+from the real cache config, and returns a `CostProfile`. MPQC computes the CSV
+domain power means `M_1..M_4`, exposes them in-memory as the same `inner_pow`
+provider SeQuant already uses, and (when enabled) calls `cost_profile` on the
+real IR before the real evaluation. The single code path differs between SQ tests
+and MPQC only in the moment-data source.
+
+**Tech stack:** SeQuant C++20 (`core/eval/`, `core/optimize/`), Catch2; MPQC4
+(`chemistry/qc/lcao/cc/`, `.../expression/`). SeQuant is primary; MPQC consumes
+it via `FETCHCONTENT_SOURCE_DIR_SEQUANT` (local) and the
+`MPQC_TRACKED_SEQUANT_TAG` pin (CI). Cross-repo: SeQuant change lands first, MPQC
+repins after.
+
+## Global constraints
+
+- No en-dashes (U+2013) or non-breaking spaces (U+00A0); ASCII hyphens only
+  (pre-commit hook rejects both). No `Co-Authored-By` trailers.
+- `inner_pow(composite, k)` must return the k-th POWER MEAN
+  `M_k = (mean_over_pairs d^k)^(1/k)`, NOT the raw moment `mean(d^k)`, so that a
+  group of `k` composites sharing a proto-set contributes
+  `prod M_k = M_k^k = mean(d^k)` = the true block-sparse volume. `M_1` = today's
+  printed average (clean extension).
+- Predict-then-run is non-fatal: a dry-run failure logs and continues to the
+  real evaluation.
+- The dry-run and the real run share the SAME factorized IR, the SAME cache
+  config (max_footprint, batchable-axis veto, persistence), and the SAME
+  `inner_pow`; only the leaf evaluator differs (zero-data vs real tiles).
+- clang-format every changed C/C++ file (`/opt/homebrew/opt/llvm@17/bin/clang-format --style=file -i`).
+
+## The moment interface (b)
+
+`inner_pow` is the single moment provider for BOTH the DP cost model and the
+runtime Result sizing. It is a `std::function<double(Index const&, size_t k)>`
+returning `M_k` for the index's composite arity (1 proto -> OSV domain, 2 protos
+-> PNO domain). SeQuant already threads `inner_pow` into the optimizer
+(`OptimizeOptions::inner_pow`) and the DryRun `SizeRegime`
+(`csv_pno_moment[k]` / `csv_osv_moment[k]`); today the harness populates it with
+a CONSTANT (M_k = the mean, independent of k). This design replaces the constant
+with real `M_1..M_4`.
+
+- **MPQC (producer):** the CSV/PNO construction already computes each pair's PNO
+  domain size and each orbital's OSV domain size to print the average. Extend
+  that reduction to accumulate `sum(d)`, `sum(d^2)`, `sum(d^3)`, `sum(d^4)` and
+  emit `M_k = (sum(d^k)/N)^(1/k)` for k=1..4 (PNO and OSV), replacing/extending
+  the single "Average ... per pair" line. Expose the eight numbers in-memory as
+  an `inner_pow` closure for the dry-run.
+- **SeQuant (consumer):** `inner_pow(ix, k)` looks up `M_k` (k clamped to
+  [1,4]; for k>4 fall back to `M_4`, which over-estimates slightly -- documented
+  and adequate, twin composites use k<=2). SQ standalone tests hardcode the C60
+  `M_1..M_4` (read from an MPQC run's printout) into `df_regime`.
+
+## Components
+
+### a1. Moment-aware runtime Result sizing (SeQuant)
+
+The DryRun `Result::size_in_bytes()` currently sizes a twin-PNO result
+`R{a<i,i>,a<i,i>;i,i}` as the naive product `occ^2 * PNO^4` (the 358 GB
+artifact). Route the runtime Result footprint through the SAME `inner_pow` the
+DP uses (the `SizeRegime`/`CostModel` already holds it), so a group of `k`
+proto-sharing composites contributes `M_k^k` and the result sizes as
+`occ^2 * M_2^2` (~89 GB). One source of sizing truth for DP and runtime.
+
+### a2. Faithful dry-run cache (SeQuant)
+
+Build the dry-run cache with the gated factory
+`cache_manager(nodes, is_volatile, min_repeats, footprint_of, max_footprint, is_batchable_index)`
+(`cache_manager.hpp:477`), using the real run's values: `max_footprint` from the
+config (e.g. 1e11), `footprint_of` = the moment-aware node size (a1),
+`is_batchable_index` = the batch policy's predicate (so free-mu-tilde/K giants
+are NOT cached whole, matching the real run), `is_volatile` from the volatile
+leaf policy. `reset()` after each summand (persistent entries survive), so the
+cache models cross-term persistence without accumulating per-term NP scratch.
+
+### a3. Scratch-fold global peak (SeQuant)
+
+Thread a shared peak accumulator into `make_batched_scratch`
+(`eval.hpp:1142`) so each batch scratch's `working_set_hwmark` is folded into one
+global peak (the outer cache misses batched transients today -- proven in
+`[dryrun-perf]`: 0.2 GB outer vs 38.9 GB scratch). The accumulator is the true
+peak of the whole replay. Because the batched evaluator is shared, this also
+makes the REAL run's reported peak faithful (a free bonus enabling
+predicted-vs-actual comparison). The peak sink is an opt-in parameter (a pointer,
+null = current behavior) so non-dry-run callers are byte-unchanged unless they
+pass one.
+
+**Scope of the predicted peak.** It is the single-logical working-set high
+watermark (whole-DistArray element sizes, replicated accounting -- the same
+quantity the real run's `working_set_hwmark` reports on each rank), NOT per-rank
+RSS nor the SLURM step-cgroup aggregate that actually triggers OOM. Relating the
+logical peak to node memory requires the run's distribution/replication model,
+which is out of scope here; predicted-vs-actual compares logical peak to logical
+peak.
+
+### a4. CostProfile API (SeQuant)
+
+```
+struct CostProfile {
+  double peak_bytes = 0;   // global scratch-folded working-set high watermark
+  double flops = 0;        // summed unweighted contraction FLOPs
+  double exec_cost = 0;    // summed roofline op cost (machine-balance aware)
+  std::size_t n_ops = 0;   // contraction nodes evaluated
+};
+CostProfile cost_profile(forest, cache_config, inner_pow, leaf_evaluator,
+                         optional trace_stream);
+```
+
+`cost_profile` builds the gated cache (a2) with the peak sink (a3), replays each
+tree zero-data (moment-aware sizing a1), aggregates peak/flops/exec_cost from the
+per-op accounting, and (if a trace stream is given) writes the per-op trace.
+`[dryrun-perf]` and `[dryrun-trace]` switch to this API; the ad-hoc cache setup,
+manual hwmark reads, and gap-diagnosis prints in those tests are replaced by the
+`CostProfile` return (their assertions become: twin-PNO sizes as occ^2*M_2^2,
+peak in a realistic band, perf-first flops <= peak-first flops).
+
+### b. MPQC CSV moment print + provider
+
+In the CSV/PNO construction (`pao_to_pno_mp2.ipp` and/or the CSV builder that
+prints "Average number of PNOs per pair"), extend the per-pair reduction to
+`M_1..M_4` for PNO and OSV, print them, and build an `inner_pow` closure over
+the eight numbers for the dry-run to consume.
+
+### c. MPQC dry-run hook
+
+Keyword `sequant:eval:dry_run` (bool, default false) parsed by `SeQuantEngine`.
+When true, `process_for_evaluation` (`sequant.cpp`), immediately before the real
+residual eval, calls SeQuant's `cost_profile` on the ALREADY-built factorized IR
+(the per-summand optimized eval forest) with: the in-memory `M_1..M_4`
+`inner_pow` (b), the real cache config (max_footprint, batch policy, volatile
+predicate), and the zero-data DryRun leaf evaluator. It logs the `CostProfile`
+(peak/flops/exec_cost/n_ops) and optionally writes the per-op trace to a file
+(`sequant:eval:dry_run_trace` path). Then the real evaluation proceeds unchanged
+(predict-then-run). The dry-run builds its OWN cache (from the same config), so
+it does not perturb the real run's cache.
+
+## Data flow
+
+CSV domains -> `M_1..M_4` (print + in-memory `inner_pow`) -> CCk builds the
+factorized IR (unchanged) -> if `dry_run`: `cost_profile(IR, real cache config,
+M_k inner_pow, zero-data leaf)` -> log CostProfile (+ optional trace) -> real
+eval runs. Predicted vs actual: both sides read the now-faithful scratch-folded
+peak (a3).
+
+## Error handling
+
+- Dry-run replay throws -> catch, log "dry-run failed: <what>", continue to the
+  real eval (predict-then-run is never blocked by prediction).
+- No moment provider (dry-run driven without moments) -> constant-moment fallback
+  with a one-line warning (current behavior; sizes are then indicative only).
+- `k > 4` requested from `inner_pow` -> return `M_4` (documented slight
+  over-estimate; twin composites need only k<=2).
+
+## Testing
+
+- **SeQuant unit:** (1) `inner_pow` power-mean helper: `M_k` from a small size
+  list equals `(mean d^k)^(1/k)`. (2) moment-aware Result sizing: a twin-PNO
+  result sizes as `occ^2*M_2^2`, not `occ^2*M_1^4`. (3) gated-cache dry-run peak:
+  a free-batchable-axis giant is NOT cached (footprint gate + veto), so the
+  peak matches the sliced size. (4) scratch-fold: a batched contraction's global
+  peak >= its per-batch scratch hwmark.
+- **SeQuant harness:** `[dryrun-perf]` / `[dryrun-trace]` use `cost_profile`
+  with real C60 `M_1..M_4`; assert twin-PNO sizing fixed and the whole-residual
+  peak lands in a realistic band (order ~1 TB or below, not 11.9 TB).
+- **MPQC unit:** `M_1..M_4` computed correctly from a synthetic domain-size list;
+  `sequant:eval:dry_run` parses.
+- **MPQC validation:** a small CCk input with `dry_run=true` logs a CostProfile
+  and still completes the real run; a coarse predicted-vs-actual peak check
+  (same order of magnitude).
+
+## Sequencing and cross-repo
+
+Implement b -> a -> c: (b) MPQC moment print is standalone and gives real
+numbers to hardcode; (a1-a4) SeQuant realism consumes them; (c) MPQC hook drives
+the SeQuant API. The SeQuant changes (a, and the `inner_pow` contract) land and
+are pushed first; MPQC repins `MPQC_TRACKED_SEQUANT_TAG` (CURRENT + PREVIOUS) in
+its own commit before/with the MPQC wiring (b, c). Local MPQC builds see SeQuant
+via `FETCHCONTENT_SOURCE_DIR_SEQUANT`; the repin is for CI/clean builds.

From b678dcbf5ead5924753e4ec0ab57fe967ffabca4 Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Sun, 5 Jul 2026 11:55:26 -0400
Subject: [PATCH 32/78] dryrun: correct a1 sizing premise and add
 implementation plan

Sizing was already moment-aware (inner_aware_volume via inner_pow); the
358 GB is the genuine constant-domain size of the 4-PNO CC doubles W
intermediate, not a twin-PNO occ^2*PNO^4 artifact. a1 becomes a
verification task; the real moment work is feeding real M_1..M_4.
---
 ...26-07-05-dryrun-cost-profile-prediction.md | 504 ++++++++++++++++++
 ...5-dryrun-cost-profile-prediction-design.md |  30 +-
 2 files changed, 526 insertions(+), 8 deletions(-)
 create mode 100644 doc/dev/plans/2026-07-05-dryrun-cost-profile-prediction.md

diff --git a/doc/dev/plans/2026-07-05-dryrun-cost-profile-prediction.md b/doc/dev/plans/2026-07-05-dryrun-cost-profile-prediction.md
new file mode 100644
index 0000000000..20da44a2d8
--- /dev/null
+++ b/doc/dev/plans/2026-07-05-dryrun-cost-profile-prediction.md
@@ -0,0 +1,504 @@
+# Dry-run cost-profile prediction Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Make the SeQuant DryRun eval backend a faithful predictor of a factorized schedule's full cost profile (peak memory, FLOPs, roofline cost), and wire it into MPQC as a predict-then-run pre-flight fed by the real CSV domain moments.
+
+**Architecture:** SeQuant gains a `cost_profile(...)` entry point that replays the zero-data eval forest through the real eval loop plus a cache built from the real cache config, folding batched-scratch high-watermarks into one global peak, and returns a `CostProfile`. MPQC computes the CSV domain power means `M_1..M_4`, exposes them in-memory as the `inner_pow` provider SeQuant already threads through the optimizer and DryRun `SizeRegime`, and (when enabled) calls `cost_profile` on the real IR before the real evaluation. SeQuant lands first; MPQC repins and wires.
+
+**Tech Stack:** SeQuant C++20 (`core/eval/backends/dryrun/`, `core/optimize/`), Catch2; MPQC4 (`chemistry/qc/lcao/mbpt/`, `.../expression/`). MPQC consumes SeQuant via `FETCHCONTENT_SOURCE_DIR_SEQUANT` (local) and `MPQC_TRACKED_SEQUANT_TAG` (CI).
+
+## Global Constraints
+
+- No en-dashes (U+2013) or non-breaking spaces (U+00A0); ASCII hyphens only (a pre-commit hook rejects both). No `Co-Authored-By` trailers in commits.
+- `inner_pow(composite, k)` MUST return the k-th POWER MEAN `M_k = (mean_over_pairs d^k)^(1/k)`, NOT the raw moment `mean(d^k)`. The optimizer's `inner_aware_volume` (`SeQuant/core/optimize/single_term_detail.hpp:87-92`) multiplies `inner_pow(c,k)` once per member of a k-composite group, so the group product is `M_k^k = mean(d^k)` and `outer_nocc^N * M_k^k = Sum_pairs d^k` = the true block-sparse volume. `M_1` = today's printed average. At k=1, `M_1 = mean(d)`, matching the current single-average print exactly.
+- The dry-run and the real run share the SAME factorized IR, the SAME cache config (`max_footprint`, batchable-axis veto, volatile predicate, `min_repeats`), and the SAME `inner_pow`; only the leaf evaluator differs (zero-data DryRun vs real tiles).
+- Predict-then-run is non-fatal: a dry-run failure logs and continues to the real evaluation.
+- The predicted peak is the single-logical working-set high watermark (whole-DistArray element sizes, replicated accounting), NOT per-rank RSS nor the SLURM step-cgroup aggregate. Predicted-vs-actual compares logical peak to logical peak.
+- clang-format every changed C/C++ file: `/opt/homebrew/opt/llvm@17/bin/clang-format --style=file -i <file>`. Do NOT format `.tpp` files.
+- SeQuant threads its unit-test binaries internally; NEVER run two SeQuant unit-test binaries concurrently. No parallel MPQC runs. Use `cmake-build-release` for any MPQC validation run.
+- Commit after each task; push only the SeQuant branch when all SeQuant tasks are green (Task 6 gates the MPQC repin on the pushed SeQuant SHA).
+
+Reference spec: `SeQuant/doc/dev/specs/2026-07-05-dryrun-cost-profile-prediction-design.md`.
+
+---
+
+## Repo A: SeQuant (Tasks 1-5)
+
+Branch: continue on the existing `feature/eval-predicted-peak-trace` (SeQuant). Source tree: `/Users/efv/code/SeQuant`. Build dir: `cmake-build-release` (create with the project's standard cmake invocation if absent). Unit-test binary target: `unit_tests-sequant`. Run a single test by tag with `unit_tests-sequant "<tag>"`.
+
+### Task 1: Lock the power-mean sizing contract (a1 verification)
+
+The DryRun sizing is ALREADY moment-aware (`Result::size_in_bytes()` -> `cm_->memsize` -> `inner_aware_volume`). This task does NOT change sizing; it pins the power-mean contract with a test so later real-moment data cannot silently regress to raw moments, and documents the contract at the `SizeRegime` definition.
+
+**Files:**
+- Test: `SeQuant/tests/unit/test_eval_dryrun.cpp` (add one `TEST_CASE`)
+- Modify (doc only): `SeQuant/core/eval/backends/dryrun/size_regime.hpp:18-52` (comment above `csv_pno_moment`)
+
+**Interfaces:**
+- Consumes: `sequant::eval::dryrun::SizeRegime` with fields `space_extent`, `csv_pno_moment[5]`, `csv_osv_moment[5]`, method `inner_pow(Index const&, size_t) const`, and `inner_pow_fn()`. The optimizer helper `sequant::opt::detail::inner_aware_volume(tot_idxs, ixex, inner_pow)` (already exists).
+- Produces: nothing new; a locked invariant.
+
+- [ ] **Step 1: Write the failing test**
+
+Add to `test_eval_dryrun.cpp`. This builds a `SizeRegime` whose PNO moment array holds a NON-constant power-mean sequence (a heavy-tailed domain: `M_1<M_2<M_3<M_4`), then sizes a synthetic 2-composite (twin-PNO) result over an occ-pair and asserts the size equals `occ^2 * M_2^2`, NOT `occ^2 * M_1^2` (the flat-average under-count) and NOT `occ^2 * M_1^4` (the old misdiagnosed "artifact").
+
+```cpp
+TEST_CASE("dryrun power-mean sizing contract", "[dryrun][sizing]") {
+  using namespace sequant;
+  using sequant::eval::dryrun::SizeRegime;
+
+  // Heavy-tailed PNO domain: power means strictly increasing in k.
+  // (For any non-degenerate distribution, M_1 < M_2 < M_3 < M_4 by Jensen.)
+  SizeRegime r;
+  const std::size_t occ = 10;
+  r.space_extent[L"i"] = occ;  // occupied index extent
+  const std::array<double, 5> Mk{1.0, 30.0, 40.0, 55.0, 75.0};  // M_0..M_4
+  for (std::size_t k = 0; k <= 4; ++k) {
+    r.csv_pno_moment[k] = Mk[k];
+    r.csv_osv_moment[k] = Mk[k];
+  }
+  auto ip = r.inner_pow_fn();
+
+  // A composite PNO index a<i_1,i_2> has a 2-proto (PNO) domain.
+  Index i1(L"i_1"), i2(L"i_2");
+  Index a1 = Index(L"a_1", {i1, i2});
+  Index a2 = Index(L"a_2", {i1, i2});
+
+  // Two composites sharing the SAME proto-set => a k=2 group.
+  // inner_aware_volume multiplies ip(c,2) once per member => M_2^2.
+  opt::detail::tot_indices tot;
+  tot.outer = {i1, i2};              // occ^2 outer
+  tot.inner = {a1, a2};              // twin PNO composites
+  auto ixex = [&](Index const& ix) {
+    return static_cast<double>(r.extent(ix));
+  };
+  const double vol = opt::detail::inner_aware_volume(tot, ixex, ip);
+
+  const double expected = double(occ) * double(occ) * Mk[2] * Mk[2];  // occ^2 * M_2^2
+  CHECK(vol == Catch::Approx(expected));
+  // Guard against the two wrong models:
+  CHECK(vol != Catch::Approx(double(occ) * occ * Mk[1] * Mk[1]));      // flat-average under-count
+  CHECK(vol != Catch::Approx(double(occ) * occ * std::pow(Mk[1], 4))); // old "occ^2*PNO^4 artifact"
+}
+```
+
+Before writing, open `size_regime.hpp` and `single_term_detail.hpp` to confirm the exact spellings of `tot_indices`, its `outer`/`inner` members, the `Index` proto-index constructor, and the `inner_aware_volume` namespace path; adjust the `#include`s and qualified names in the test to match. If `tot_indices` is not default-constructible with public `outer`/`inner`, build it via the existing `tot_indices(...)` splitter used elsewhere in this file (grep `tot_indices` in the test for a live example) rather than aggregate-initializing.
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `unit_tests-sequant "[sizing]"`
+Expected: FAIL to COMPILE if a name is wrong (fix names), or PASS immediately if the contract already holds. If it PASSES on first run, that is the desired end state for this task, but you MUST still confirm it fails when the contract is broken: temporarily change the test's `expected` to `occ*occ*Mk[1]*Mk[1]` and confirm FAIL, then revert. Record that you did this in the commit body.
+
+- [ ] **Step 3: Document the contract**
+
+Edit the comment block directly above `csv_pno_moment` in `size_regime.hpp` to state verbatim:
+
+```cpp
+  // csv_pno_moment[k] / csv_osv_moment[k] hold the k-th POWER MEAN
+  // M_k = (mean_over_pairs d^k)^(1/k) of the per-pair PNO / per-orbital OSV
+  // domain size d, for k in [1,4] (index 0 is unused, set to 1). inner_pow()
+  // returns M_k so that inner_aware_volume's per-member product over a
+  // k-composite group is M_k^k = mean(d^k), and outer_nocc^N * M_k^k equals
+  // the true block-sparse volume Sum_pairs d^k. Do NOT store raw moments
+  // mean(d^k) here: that would over-count k-composite groups by a further
+  // power of k. For a constant domain d, M_k = d for all k.
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `unit_tests-sequant "[sizing]"`
+Expected: PASS.
+
+- [ ] **Step 5: clang-format and commit**
+
+```bash
+/opt/homebrew/opt/llvm@17/bin/clang-format --style=file -i \
+  SeQuant/tests/unit/test_eval_dryrun.cpp SeQuant/core/eval/backends/dryrun/size_regime.hpp
+git add SeQuant/tests/unit/test_eval_dryrun.cpp SeQuant/core/eval/backends/dryrun/size_regime.hpp
+git commit -m "dryrun: lock power-mean sizing contract with a regression test"
+```
+
+---
+
+### Task 2: Faithful gated dry-run cache with per-term reset (a2)
+
+Build the dry-run cache with the gated `cache_manager` factory so free-batchable-axis giants are not cached whole (matching the real run), and `reset()` between summands so persistent entries survive but per-term NP scratch does not accumulate across terms.
+
+**Files:**
+- Modify: `SeQuant/core/eval/backends/dryrun/` (the dry-run driver that today builds a cache; grep for `cache_manager(` under `backends/dryrun/`). If the driver is inside the test harness rather than a library header, the cache-build helper you add lives in a new small header `SeQuant/core/eval/backends/dryrun/cost_profile.hpp` created in Task 4; for this task add the helper to that header's eventual home but expose it now as a free function.
+- Test: `SeQuant/tests/unit/test_eval_dryrun.cpp`
+
+**Interfaces:**
+- Consumes: the gated factory `sequant::eval::cache_manager(nodes, is_volatile, min_repeats, footprint_of, max_footprint, is_batchable_index)` (`SeQuant/core/eval/cache_manager.hpp:477`); the DryRun node-size functor (moment-aware, from Task 1's `inner_pow`).
+- Produces: `struct CacheConfig { double max_footprint; std::size_t min_repeats; std::function<bool(EvalNode const&)> is_volatile; std::function<bool(Index const&)> is_batchable_index; };` (define in `cost_profile.hpp`, consumed by Task 4). `is_volatile`/`is_batchable_index` element types must match the gated factory's actual parameter types; confirm them by reading `cache_manager.hpp:461-490` and copy the exact signatures.
+
+- [ ] **Step 1: Write the failing test**
+
+Add a `TEST_CASE("dryrun gated cache vetoes free-batchable giant", "[dryrun][cache]")` that:
+1. Builds a `SizeRegime` (reuse `df_regime` from this file) and an eval forest containing one node whose result carries a free batchable axis (a `mu~`/`K`-carrying giant) plus a small cacheable intermediate.
+2. Builds the cache via the gated factory with `max_footprint = 1e11`, an `is_batchable_index` that returns true for the giant's free axis, `footprint_of` = the moment-aware node size, `min_repeats = 1`.
+3. Asserts the giant is NOT resident in the cache after evaluation (query the cache's residency the same way `[dryrun-perf]` inspects it today; grep `cache` in the test for the accessor), while the small intermediate IS cached when repeated.
+
+Model the forest construction on the existing `[dryrun-perf]` test in the same file (it already optimizes and replays the giant term). Reuse its term selection rather than authoring a new expression.
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `unit_tests-sequant "[cache]"`
+Expected: FAIL (giant currently cached, or the gated factory not yet wired into the dry-run path).
+
+- [ ] **Step 3: Wire the gated factory + per-term reset**
+
+In the dry-run cache build path, replace the simple `cache_manager(nodes, min_repeats)` call with the gated overload, passing `CacheConfig`'s fields. After each summand's replay, call `cache.reset()` (persistent entries survive by the factory's persistence rule; NP scratch is dropped). Read `cache_manager.hpp:461-490` to confirm `reset()` semantics (it must keep persistent/`min_repeats`-qualified entries and drop transients); if `reset()` clears everything, use the narrower per-term-scratch clear the class exposes, or scope the transient cache per summand and keep a separate persistent cache across summands (mirror how the real eval loop in `eval.hpp` scopes persistence across summands - grep `reset(` in `eval.hpp`).
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `unit_tests-sequant "[cache]"`
+Expected: PASS.
+
+- [ ] **Step 5: clang-format and commit**
+
+```bash
+/opt/homebrew/opt/llvm@17/bin/clang-format --style=file -i <changed .hpp/.cpp files>
+git add -A && git commit -m "dryrun: gated cache with batchable-axis veto and per-term reset"
+```
+
+---
+
+### Task 3: Scratch-fold global peak accumulator (a3)
+
+The batched evaluator runs each batch in a separate scratch cache (`make_batched_scratch`, `SeQuant/core/eval/eval.hpp:1142`), so batched-inner transients are invisible to the outer cache's `working_set_hwmark` (proven: 0.2 GB outer vs 38.9 GB scratch). Thread an opt-in shared peak sink so each scratch's high-watermark folds into one global peak. Null sink = byte-unchanged behavior for the real run.
+
+**Files:**
+- Modify: `SeQuant/core/eval/eval.hpp` (around `make_batched_scratch`, line ~1142, and the batched contraction loop that calls it)
+- Modify: `SeQuant/core/eval/cache_manager.hpp` (expose `working_set_hwmark()` if not already public; it is per the summary)
+- Test: `SeQuant/tests/unit/test_eval_dryrun.cpp`
+
+**Interfaces:**
+- Consumes: `CacheManager::working_set_hwmark()` (existing).
+- Produces: an optional peak sink parameter. Define `using PeakSink = std::atomic<double>*;` (or a plain `double*` guarded by the eval's existing serialization - confirm the batched loop's threading model in `eval.hpp` before choosing; if batches run concurrently use `std::atomic<double>` with a `fetch_max` CAS loop, else a plain `double*` max-assign). Add the sink as a trailing defaulted parameter (`PeakSink peak = nullptr`) to `make_batched_scratch` and to the batched-eval entry it feeds, so all existing callers compile unchanged.
+
+- [ ] **Step 1: Write the failing test**
+
+Add `TEST_CASE("dryrun scratch-fold captures batched peak", "[dryrun][peak]")`:
+1. Reuse the `[dryrun-perf]` giant-term forest and objective that produces a batched (K-sliced) contraction.
+2. Evaluate once with a `PeakSink` passed in; capture `global_peak`.
+3. Also read the outer cache's `working_set_hwmark()` (as today).
+4. Assert `global_peak >= outer_hwmark` and, for this specifically-batched term, `global_peak` is strictly greater (the batched transient exceeds the outer residency): `CHECK(global_peak > outer_hwmark * 2.0)` (the observed gap is ~195x; a 2x floor is a safe, non-flaky assertion).
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `unit_tests-sequant "[peak]"`
+Expected: FAIL to compile (no `PeakSink` parameter yet) or FAIL the assertion (peak not folded).
+
+- [ ] **Step 3: Implement the fold**
+
+In `make_batched_scratch` and its caller: after each batch's scratch cache finishes, read `scratch.working_set_hwmark()` and fold it into `*peak` (max). If batches run concurrently, use a `fetch_max` loop:
+```cpp
+if (peak) {
+  double cur = peak->load(std::memory_order_relaxed);
+  const double cand = scratch.working_set_hwmark();
+  while (cand > cur &&
+         !peak->compare_exchange_weak(cur, cand, std::memory_order_relaxed)) {}
+}
+```
+Also fold the OUTER cache's `working_set_hwmark()` into the same sink at end of replay, so `*peak = max(outer, all scratch)` = the true whole-replay peak. Confirm the exact place the outer replay completes (grep the function that owns the outer `CacheManager` and drives all summands).
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `unit_tests-sequant "[peak]"`
+Expected: PASS.
+
+- [ ] **Step 5: clang-format and commit**
+
+```bash
+/opt/homebrew/opt/llvm@17/bin/clang-format --style=file -i \
+  SeQuant/core/eval/eval.hpp SeQuant/core/eval/cache_manager.hpp \
+  SeQuant/tests/unit/test_eval_dryrun.cpp
+git add -A && git commit -m "eval: opt-in scratch-fold peak sink for faithful batched-replay peak"
+```
+
+---
+
+### Task 4: CostProfile struct and cost_profile() API (a4)
+
+Wrap Tasks 2-3 in a single reusable entry point that both SeQuant tests and MPQC call.
+
+**Files:**
+- Create: `SeQuant/core/eval/backends/dryrun/cost_profile.hpp` (declarations + inline template body, header-only per SeQuant convention; if it must cross a TU boundary add `cost_profile.cpp` and register in `SeQuant/core/CMakeLists.txt` under the eval sources)
+- Modify: `SeQuant/core/CMakeLists.txt` only if a `.cpp` is added
+- Test: `SeQuant/tests/unit/test_eval_dryrun.cpp`
+
+**Interfaces:**
+- Consumes: `CacheConfig` (Task 2), `PeakSink` (Task 3), the DryRun leaf evaluator and zero-data `Result`, `inner_pow` (`std::function<double(Index const&, std::size_t)>`).
+- Produces:
+```cpp
+namespace sequant::eval::dryrun {
+
+struct CostProfile {
+  double peak_bytes = 0;   // global scratch-folded working-set high watermark
+  double flops = 0;        // summed unweighted contraction FLOPs
+  double exec_cost = 0;    // summed roofline op cost (machine-balance aware)
+  std::size_t n_ops = 0;   // contraction nodes evaluated
+};
+
+/// Replays a factorized eval forest zero-data through the real eval loop with a
+/// cache built from `cfg`, folding batched-scratch high-watermarks into
+/// CostProfile::peak_bytes. Optionally writes a per-op trace to `trace`.
+/// \param forest        per-summand optimized eval forest (the real IR)
+/// \param cfg           real cache config (max_footprint, veto, volatile, repeats)
+/// \param inner_pow     M_k power-mean provider (see size_regime.hpp contract)
+/// \param leaf_eval     zero-data DryRun leaf evaluator
+/// \param trace         optional per-op trace sink (nullptr = no trace)
+CostProfile cost_profile(
+    EvalForest const& forest, CacheConfig const& cfg,
+    std::function<double(Index const&, std::size_t)> inner_pow,
+    LeafEvaluator const& leaf_eval, std::wostream* trace = nullptr);
+
+}  // namespace sequant::eval::dryrun
+```
+Replace `EvalForest`, `LeafEvaluator` with the concrete types the existing `[dryrun-perf]` replay uses (grep the test for the forest container type and the leaf functor type; use those exact spellings so MPQC and the tests share them).
+
+- [ ] **Step 1: Write the failing test**
+
+Add `TEST_CASE("cost_profile returns peak/flops/exec/n_ops", "[dryrun][cost_profile]")`:
+1. Build the `df_regime` with real C60 `M_1..M_4` (hardcode the numbers you will later read from an MPQC printout; until Task 7 exists, use the constant `M_k = 42` PNO / `310` OSV that `df_regime(1800,4320,120,42.0,310.0)` already encodes, extended so `csv_pno_moment[k]` differs per k once real numbers land - for now constant is fine, the test asserts structure not magnitude).
+2. Build `CacheConfig` (max_footprint 1e11, veto on the giant's free axis, min_repeats 1).
+3. Call `cost_profile(forest, cfg, regime.inner_pow_fn(), leaf_eval)`.
+4. Assert: `cp.n_ops > 0`, `cp.flops > 0`, `cp.peak_bytes > 0`, and `cp.peak_bytes` equals the Task-3 folded peak for the same forest (call both, compare).
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `unit_tests-sequant "[cost_profile]"`
+Expected: FAIL (no such symbol).
+
+- [ ] **Step 3: Implement cost_profile**
+
+In `cost_profile.hpp`: build the gated cache (Task 2 helper), allocate a `PeakSink`, loop over summands replaying zero-data through the real eval loop (reuse the exact replay call the `[dryrun-perf]` test performs), accumulate `flops`/`exec_cost`/`n_ops` from the per-op accounting the DryRun backend already produces (grep the test for where it reads per-op flop/cost today), set `peak_bytes` from the sink, and if `trace` is non-null pass it into the replay's trace hook. Return the `CostProfile`.
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `unit_tests-sequant "[cost_profile]"`
+Expected: PASS.
+
+- [ ] **Step 5: clang-format and commit**
+
+```bash
+/opt/homebrew/opt/llvm@17/bin/clang-format --style=file -i \
+  SeQuant/core/eval/backends/dryrun/cost_profile.hpp \
+  SeQuant/tests/unit/test_eval_dryrun.cpp
+git add -A && git commit -m "dryrun: CostProfile struct and cost_profile() reusable entry point"
+```
+
+---
+
+### Task 5: Retrofit [dryrun-perf] and [dryrun-trace] onto cost_profile (a4)
+
+Replace the ad-hoc cache setup, manual hwmark reads, and gap-diagnosis prints in the two harness tests with `cost_profile`, so there is one code path.
+
+**Files:**
+- Modify: `SeQuant/tests/unit/test_eval_dryrun.cpp` (`[dryrun-perf]` and `[.][dryrun-trace]` cases)
+
+**Interfaces:**
+- Consumes: `cost_profile` (Task 4).
+- Produces: nothing new.
+
+- [ ] **Step 1: Update [dryrun-perf]**
+
+Replace its manual cache build + replay + hwmark read with a `cost_profile` call under each objective (perf-first, peak-first). Keep the objective comparison. New assertions:
+- `perf.flops <= peak.flops` (perf-first minimizes flops).
+- Both `peak_bytes` land in a realistic band for the constant-moment C60 giant: `CHECK(perf.peak_bytes < 1e12); CHECK(perf.peak_bytes > 1e11);` (perf-first forms the ~358 GB 4-PNO `W`; band 100 GB..1 TB is safe and non-flaky). Document in a comment that with real heavy-tailed moments this rises.
+
+- [ ] **Step 2: Update [.][dryrun-trace]**
+
+Replace its manual whole-residual replay with a `cost_profile(forest, cfg, inner_pow, leaf, &trace_file)` call, keeping the env knobs (`DRYRUN_OBJ`, `DRYRUN_TRACE_FILE`, `DRYRUN_MAX_TERMS`). Assert the returned `CostProfile.peak_bytes` is finite and the trace file is non-empty.
+
+- [ ] **Step 3: Run both tests**
+
+Run: `unit_tests-sequant "[dryrun-perf]"` then `unit_tests-sequant "[dryrun-trace]"` (serially; never concurrent).
+Expected: PASS (`[dryrun-trace]` is hidden `[.]`, invoke by explicit tag).
+
+- [ ] **Step 4: clang-format and commit**
+
+```bash
+/opt/homebrew/opt/llvm@17/bin/clang-format --style=file -i SeQuant/tests/unit/test_eval_dryrun.cpp
+git add SeQuant/tests/unit/test_eval_dryrun.cpp
+git commit -m "dryrun: route [dryrun-perf]/[dryrun-trace] through cost_profile"
+```
+
+- [ ] **Step 5: Push SeQuant branch**
+
+```bash
+git -C /Users/efv/code/SeQuant push
+git -C /Users/efv/code/SeQuant rev-parse HEAD   # record SHA for Task 6
+```
+
+---
+
+## Repo B: MPQC (Tasks 6-8)
+
+Source tree: `/Users/efv/code/mpqc4`. Branch: continue on `feature/eval-predicted-peak-trace`. Build dir: `cmake-build-release`. Executable target: `mpqc`.
+
+### Task 6: Repin SeQuant
+
+**Files:**
+- Modify: `external/versions.cmake:13-14`
+
+**Interfaces:**
+- Consumes: the pushed SeQuant SHA from Task 5 Step 5.
+- Produces: an updated pin so CI/clean builds see the new API.
+
+- [ ] **Step 1: Update the pin**
+
+Set `MPQC_TRACKED_SEQUANT_PREVIOUS_TAG` to the current `MPQC_TRACKED_SEQUANT_TAG` value (`91dd48a2dbb9617a3812141aa01c0e3de43b7d2e`), and set `MPQC_TRACKED_SEQUANT_TAG` to the SHA recorded in Task 5.
+
+- [ ] **Step 2: Commit (pin change alone, per CLAUDE.md)**
+
+```bash
+git add external/versions.cmake
+git commit -m "external: repin SeQuant to <new-sha> (dry-run cost_profile API)"
+```
+
+---
+
+### Task 7: MPQC CSV moment print + inner_pow provider (b)
+
+Extend the existing CC-pair PNO average reduction to `M_1..M_4` power means, print them, and build an `inner_pow` closure the dry-run hook (Task 8) consumes. OSV moments are computed where per-pair data exists; where only a total is available, emit `M_1` and set `M_2..M_4 = M_1` with a one-line caveat (documented limitation, not a placeholder - PNO composites dominate the C60 giant).
+
+**Files:**
+- Modify: `src/mpqc/chemistry/qc/lcao/mbpt/pao_to_pno_mp2.ipp:570-597` (PNO moment accumulation + print) and `:1474-1494` (OSV)
+- Modify: the CSV-holder struct that already carries per-pair PNO/OSV counts to store the eight moments and expose an `inner_pow` closure (grep the return type of the function containing line 570; the moments live next to the CSV maps handed to CCk). If there is no natural holder, add a small `struct CsvMoments { std::array<double,5> pno{1,1,1,1,1}; std::array<double,5> osv{1,1,1,1,1}; std::function<double(...)> inner_pow() const; };` next to the CSV data type and thread it to where CCk builds its `SeQuantEngine`.
+- Test: `tests/unit/` new file `test_csv_moments.cpp` (add to `tests/unit/CMakeLists.txt`)
+
+**Interfaces:**
+- Consumes: the per-pair `cc_pnos` accumulation loop at `pao_to_pno_mp2.ipp:574-585`.
+- Produces: `CsvMoments{ std::array<double,5> pno, osv; }` with `M_k = (sum(d^k)/N)^(1/k)`, and `inner_pow(Index const&, size_t k) -> double` returning `pno[k]` for 2-proto composites, `osv[k]` for 1-proto, `pow(extent,k)` otherwise. The `inner_pow` closure signature and composite-arity dispatch MUST match `SizeRegime::inner_pow` (`size_regime.hpp:36-45`) exactly so the two are interchangeable.
+
+- [ ] **Step 1: Write the failing test**
+
+`tests/unit/test_csv_moments.cpp`: a pure function `csv_power_means(std::vector<std::size_t> const& d) -> std::array<double,5>` computing `M_k = (mean d^k)^(1/k)` for k=0..4 (M_0 := 1). Test with a small heavy-tailed list, e.g. `{1, 2, 2, 40}`:
+```cpp
+TEST_CASE("csv_power_means", "[csv][moments]") {
+  const std::vector<std::size_t> d{1, 2, 2, 40};
+  const auto M = mpqc::lcao::csv_power_means(d);
+  const double N = 4;
+  auto mean_pow = [&](int k) {
+    double s = 0; for (auto x : d) s += std::pow(double(x), k); return s / N;
+  };
+  CHECK(M[1] == Catch::Approx(mean_pow(1)));                       // M_1 = mean(d)
+  CHECK(M[2] == Catch::Approx(std::pow(mean_pow(2), 1.0 / 2)));
+  CHECK(M[4] == Catch::Approx(std::pow(mean_pow(4), 1.0 / 4)));
+  CHECK(M[4] > M[1]);                                              // heavy tail: M_4 > M_1
+}
+```
+Add `test_csv_moments.cpp` to `tests/unit/CMakeLists.txt`.
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `ctest --test-dir cmake-build-release -R csv_moments` (or run the unit binary directly). Expected: FAIL (undefined `csv_power_means`).
+
+- [ ] **Step 3: Implement `csv_power_means` and wire the reduction**
+
+- Add `csv_power_means` (free function, in an `mbpt` header included by `pao_to_pno_mp2.ipp`, e.g. a small `csv_moments.h`; declare in `mpqc::lcao`).
+- In the CC-pair loop (`:574-585`), replace the single `cc_pnos += pno` with four accumulators `cc_pno_pk[k] += std::pow(double(pno), k)` for k=1..4 (keep `cc_pnos` for the existing average line, or derive M_1 from it). `world.gop.sum` each. After reduction compute `M_k = pow(cc_pno_pk[k]/cc_npairs, 1.0/k)`.
+- Replace/extend the print at `:594-597`:
+```cpp
+ExEnv::out0() << "Average number of PAOs per pair: " << avg_paos << "\n";
+ExEnv::out0() << "PNO domain power means M_1..M_4 per pair: "
+              << M_pno[1] << " " << M_pno[2] << " " << M_pno[3] << " "
+              << M_pno[4] << "\n";
+```
+(Keep the "Average number of PNOs per pair" line = `M_pno[1]` for backward-compatible log grepping.)
+- Store `M_pno[1..4]` into the `CsvMoments` on the CSV holder; build the `inner_pow` closure. For OSV (`:1474-1494`): if per-pair OSV domain sizes are reachable from `pno_builder`, accumulate the same four power sums; otherwise set `M_osv[1] = nosvs_total/numIJ_total` and `M_osv[2..4] = M_osv[1]`, and print `"OSV domain power means (M_2..M_4 approximated by M_1: per-pair OSV sizes not exposed)"`.
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `ctest --test-dir cmake-build-release -R csv_moments`. Expected: PASS.
+
+- [ ] **Step 5: clang-format and commit**
+
+```bash
+/opt/homebrew/opt/llvm@17/bin/clang-format --style=file -i \
+  src/mpqc/chemistry/qc/lcao/mbpt/pao_to_pno_mp2.ipp \
+  src/mpqc/chemistry/qc/lcao/mbpt/csv_moments.h \
+  tests/unit/test_csv_moments.cpp
+git add -A && git commit -m "mbpt: print CSV PNO/OSV domain power means M_1..M_4 and expose inner_pow"
+```
+
+---
+
+### Task 8: MPQC dry-run hook (predict-then-run) (c)
+
+Add `sequant:eval:dry_run` (bool, default false). When true, immediately before the real residual evaluation, call SeQuant's `cost_profile` on the already-built factorized IR with the in-memory `M_1..M_4` provider (Task 7), the real cache config, and the zero-data DryRun leaf evaluator; log the `CostProfile`; then run the real evaluation unchanged.
+
+**Files:**
+- Modify: `src/mpqc/chemistry/qc/lcao/expression/sequant_engine.cpp` (parse the keyword, ~line 78-90 block) and `sequant_engine.h` (add a `bool dry_run_` field + accessor; default in `SeQuantEngineDefaults`)
+- Modify: `src/mpqc/chemistry/qc/lcao/expression/sequant.cpp` (`process_for_evaluation`, the function that holds the optimized forest and drives the real eval; grep `optimize`/`eval` near line 274-380) to call `cost_profile` when `engine.dry_run()` is set
+- Test: MPQC validation input under `tests/validation/reference/inputs/` (small CCk with `dry_run: true`)
+
+**Interfaces:**
+- Consumes: `sequant::eval::dryrun::cost_profile` (Task 4), `CsvMoments::inner_pow()` (Task 7), the engine's existing cache config (`eval:cache:max_footprint`, `eval:cache:min_repeats`), the optimized eval forest already built in `process_for_evaluation`.
+- Produces: a logged `CostProfile` line; no change to the real result.
+
+- [ ] **Step 1: Parse the keyword**
+
+In `sequant_engine.cpp` alongside the `eval:cache:*` parses (line ~78-90):
+```cpp
+dry_run_ = kv.value<bool>("eval:dry_run", d.dry_run);
+if (kv.exists("eval:dry_run_trace"))
+  dry_run_trace_path_ = kv.value<std::string>("eval:dry_run_trace", std::string{});
+```
+Add `bool dry_run_ = false; std::string dry_run_trace_path_;` and accessors `bool dry_run() const; std::string const& dry_run_trace_path() const;` to `sequant_engine.h`; add `bool dry_run = false;` to `SeQuantEngineDefaults`. Document the two keys in the engine's Doxygen key table.
+
+- [ ] **Step 2: Write the failing validation test**
+
+Copy the smallest existing CCk PNO input from `tests/validation/reference/inputs/` to a new `<name>-dryrun.json`, add `"dry_run": true` to its `sequant:eval` block, and its reference output (tighter precision than input) identical to the base input's energy (the dry-run must NOT change the result). Register the pair per `tests/validation/`'s CMake/JSON harness. Run it; expect FAIL (dry_run not yet honored -> either unknown-key error or no CostProfile in the log, depending on how you assert). Assert via the harness that the run completes with the reference energy AND the log contains `"dry-run CostProfile"`.
+
+- [ ] **Step 3: Wire the predict-then-run call**
+
+In `process_for_evaluation`, immediately before the real per-summand eval, guard `if (engine.dry_run())` and:
+```cpp
+try {
+  auto cfg = sequant::eval::dryrun::CacheConfig{
+      engine.cache_max_footprint(), engine.cache_min_repeats(),
+      /*is_volatile=*/engine.volatile_predicate(),
+      /*is_batchable_index=*/engine.batchable_predicate()};
+  std::wofstream trace;
+  std::wostream* tp = nullptr;
+  if (!engine.dry_run_trace_path().empty()) {
+    trace.open(engine.dry_run_trace_path());
+    tp = &trace;
+  }
+  const auto cp = sequant::eval::dryrun::cost_profile(
+      forest, cfg, csv_moments.inner_pow(), make_dryrun_leaf_evaluator(), tp);
+  ExEnv::out0() << "dry-run CostProfile: peak=" << cp.peak_bytes / 1e9
+                << " GB flops=" << cp.flops << " exec=" << cp.exec_cost
+                << " n_ops=" << cp.n_ops << "\n";
+} catch (std::exception const& e) {
+  ExEnv::out0() << "dry-run failed (continuing to real eval): " << e.what()
+                << "\n";
+}
+```
+Replace `engine.volatile_predicate()`, `engine.batchable_predicate()`, `make_dryrun_leaf_evaluator()`, `csv_moments`, and `forest` with the real accessors/locals in scope at that point (grep the function for the forest variable name and how the real cache config is currently assembled; reuse those exact expressions so dry-run and real share config). The DryRun leaf evaluator is the zero-data one from `backends/dryrun/`; if MPQC has no helper, add a one-line factory next to the eval call.
+
+- [ ] **Step 4: Run the validation test**
+
+Run: `ctest --test-dir cmake-build-release -R <name>-dryrun`. Expected: PASS (real energy matches reference; log carries the CostProfile line). Serialize; no other MPQC run concurrently.
+
+- [ ] **Step 5: clang-format and commit**
+
+```bash
+/opt/homebrew/opt/llvm@17/bin/clang-format --style=file -i \
+  src/mpqc/chemistry/qc/lcao/expression/sequant_engine.cpp \
+  src/mpqc/chemistry/qc/lcao/expression/sequant_engine.h \
+  src/mpqc/chemistry/qc/lcao/expression/sequant.cpp
+git add -A && git commit -m "sequant: sequant:eval:dry_run predict-then-run cost-profile pre-flight"
+```
+
+---
+
+## Self-review notes (author)
+
+- **Spec coverage:** a1 -> Task 1; a2 -> Task 2; a3 -> Task 3; a4 -> Tasks 4-5; b -> Task 7; c -> Task 8; cross-repo repin -> Task 6. Data flow (moments -> IR -> cost_profile -> log -> real eval) is realized by Tasks 7+8. Error handling (dry-run non-fatal, k>4 clamp, no-moment fallback) is in the `inner_pow` closure (Task 7) and the try/catch (Task 8 Step 3).
+- **Sequencing:** b (Task 7) is standalone but the plan orders SeQuant first (Tasks 1-5) because Task 4's API is what Task 8 calls and Task 6 gates the repin on the pushed SeQuant SHA; Task 7 (MPQC moment print) has no SeQuant dependency and MAY be done any time after Task 6, but is listed after it to keep one linear branch history. This matches the spec's "b -> a -> c" intent while respecting the cross-repo push/repin gate.
+- **Known soft spots the implementer must resolve by reading code (flagged inline, not placeholders):** exact `tot_indices` construction (Task 1), `reset()` persistence semantics (Task 2), batched-loop threading model for the peak sink (Task 3), the concrete `EvalForest`/`LeafEvaluator` type spellings (Task 4), the CSV-holder that carries moments to CCk and the OSV per-pair reachability (Task 7), and the in-scope forest/config/leaf expressions in `process_for_evaluation` (Task 8). Each is named with the file/line to read.
diff --git a/doc/dev/specs/2026-07-05-dryrun-cost-profile-prediction-design.md b/doc/dev/specs/2026-07-05-dryrun-cost-profile-prediction-design.md
index 317ff5a384..288e205385 100644
--- a/doc/dev/specs/2026-07-05-dryrun-cost-profile-prediction-design.md
+++ b/doc/dev/specs/2026-07-05-dryrun-cost-profile-prediction-design.md
@@ -61,14 +61,28 @@ with real `M_1..M_4`.
 
 ## Components
 
-### a1. Moment-aware runtime Result sizing (SeQuant)
-
-The DryRun `Result::size_in_bytes()` currently sizes a twin-PNO result
-`R{a<i,i>,a<i,i>;i,i}` as the naive product `occ^2 * PNO^4` (the 358 GB
-artifact). Route the runtime Result footprint through the SAME `inner_pow` the
-DP uses (the `SizeRegime`/`CostModel` already holds it), so a group of `k`
-proto-sharing composites contributes `M_k^k` and the result sizes as
-`occ^2 * M_2^2` (~89 GB). One source of sizing truth for DP and runtime.
+### a1. Verify (do not "fix") moment-aware runtime sizing (SeQuant)
+
+The DryRun `Result::size_in_bytes()` already routes through the SAME `inner_pow`
+the DP uses: `size_in_bytes() = cm_->memsize(indices_, overrides_)`
+(`result.hpp:254,384`), and `memsize` runs `inner_aware_volume`
+(`single_term_detail.hpp:82`), which for a group of `k` composites sharing a
+proto-set multiplies `inner_pow(c, k)` over members. So a result with `k`
+proto-sharing PNO legs over one occ-pair sizes as `occ^N * M_k^k = occ^N *
+<d^k>` -- the true block-sparse volume -- PROVIDED `inner_pow` returns the power
+mean `M_k`. This is correct today: `df_regime` sets `csv_pno_moment[k] = pno`
+(the power mean of a CONSTANT domain), so a 4-PNO intermediate
+`{a_1<i,i>..a_4<i,i>}` sizes as `occ^2 * pno^4` (= 358 GB at C60 constant
+extents) -- the genuine size of the CC doubles PPL `W`, NOT an artifact.
+
+Therefore a1 is a VERIFICATION task, not a fix: add a unit test pinning that a
+k-composite result sizes as `occ^N * M_k^k` for a NON-constant `M_k`, so the
+power-mean contract is locked before (b) supplies real, heavy-tailed moments.
+Real moments have `M_k > M_1` for `k>1` (Jensen), so composite intermediates
+size LARGER than the constant-domain model, not smaller; the dry-run's job is to
+quantify that. (The earlier "twin-PNO occ^2*PNO^4 sizing artifact" framing was a
+misdiagnosis: the sizing was always moment-aware; only the moment VALUES were a
+constant stand-in.)
 
 ### a2. Faithful dry-run cache (SeQuant)
 

From 13a2cc03674948bf1440a36c14919b2f59060886 Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Sun, 5 Jul 2026 12:06:22 -0400
Subject: [PATCH 33/78] dryrun: lock power-mean sizing contract with a
 regression test

Add TEST_CASE("dryrun power-mean sizing contract", "[dryrun][sizing]") to
test_eval_dryrun.cpp: builds a SizeRegime with a heavy-tailed (non-constant
in k) PNO/OSV moment table and asserts inner_aware_volume sizes a twin-PNO
composite result as occ^2 * M_2^2, guarding against both the flat-average
under-count (occ^2 * M_1^2) and the old raw-moment artifact (occ^2 * M_1^4).

The contract already holds on this branch (df_regime's csv_pno_moment[k] is
already the power mean of a constant domain), so this is a regression lock,
not a behavior change. Verified RED/GREEN by hand: temporarily setting
`expected` to occ^2*M_1^2 makes the test fail (160000 == Approx(90000) not
satisfied at the checked line), reverting to occ^2*M_2^2 makes it pass.

Also documents the power-mean contract in a comment above csv_pno_moment /
csv_osv_moment in size_regime.hpp so future real-moment data cannot silently
regress to storing raw moments.
---
 .../core/eval/backends/dryrun/size_regime.hpp |  9 ++++
 tests/unit/test_eval_dryrun.cpp               | 47 +++++++++++++++++++
 2 files changed, 56 insertions(+)

diff --git a/SeQuant/core/eval/backends/dryrun/size_regime.hpp b/SeQuant/core/eval/backends/dryrun/size_regime.hpp
index ea26172bb9..c43561e66e 100644
--- a/SeQuant/core/eval/backends/dryrun/size_regime.hpp
+++ b/SeQuant/core/eval/backends/dryrun/size_regime.hpp
@@ -17,6 +17,15 @@ namespace sequant::eval::dryrun {
 /// power means over occupied pairs (PNO) or singles (OSV).
 struct SizeRegime {
   std::map<std::wstring, std::size_t> space_extent;
+
+  // csv_pno_moment[k] / csv_osv_moment[k] hold the k-th POWER MEAN
+  // M_k = (mean_over_pairs d^k)^(1/k) of the per-pair PNO / per-orbital OSV
+  // domain size d, for k in [1,4] (index 0 is unused, set to 1). inner_pow()
+  // returns M_k so that inner_aware_volume's per-member product over a
+  // k-composite group is M_k^k = mean(d^k), and outer_nocc^N * M_k^k equals
+  // the true block-sparse volume Sum_pairs d^k. Do NOT store raw moments
+  // mean(d^k) here: that would over-count k-composite groups by a further
+  // power of k. For a constant domain d, M_k = d for all k.
   std::array<double, 5> csv_pno_moment{1.0, 1.0, 1.0, 1.0, 1.0};
   std::array<double, 5> csv_osv_moment{1.0, 1.0, 1.0, 1.0, 1.0};
 
diff --git a/tests/unit/test_eval_dryrun.cpp b/tests/unit/test_eval_dryrun.cpp
index 80ce8b2cde..094604c0b0 100644
--- a/tests/unit/test_eval_dryrun.cpp
+++ b/tests/unit/test_eval_dryrun.cpp
@@ -225,6 +225,53 @@ TEST_CASE("dryrun regime self-consistency (no cluster anchors needed)",
   }
 }
 
+// Regression lock (Task 1, a1 verification): inner_pow() must return the
+// k-th POWER MEAN M_k, not the raw k-th MOMENT <d^k>, so that
+// inner_aware_volume's per-member product over a k-composite group
+// (M_k multiplied once per member) telescopes to mean(d^k) rather than
+// over-counting by a further power of k. This pins the contract with a
+// heavy-tailed (non-constant-in-k) moment table so a future regression to
+// raw moments would be caught even though the CURRENT SizeRegime factories
+// in this file (c60_regime/df_regime) all use a constant domain, for which
+// M_k == d for every k and the bug would otherwise be invisible.
+TEST_CASE("dryrun power-mean sizing contract", "[dryrun][sizing]") {
+  // Heavy-tailed PNO domain: power means strictly increasing in k.
+  // (For any non-degenerate distribution, M_1 < M_2 < M_3 < M_4 by Jensen.)
+  SizeRegime r;
+  const std::size_t occ = 10;
+  r.space_extent[L"i"] = occ;  // occupied index extent
+  const std::array<double, 5> Mk{1.0, 30.0, 40.0, 55.0, 75.0};  // M_0..M_4
+  for (std::size_t k = 0; k <= 4; ++k) {
+    r.csv_pno_moment[k] = Mk[k];
+    r.csv_osv_moment[k] = Mk[k];
+  }
+  auto ip = r.inner_pow_fn();
+
+  // A composite PNO index a<i_1,i_2> has a 2-proto (PNO) domain.
+  Index i1{L"i_1"}, i2{L"i_2"};
+  Index a1{L"a_1", {i1, i2}};
+  Index a2{L"a_2", {i1, i2}};
+
+  // Two composites sharing the SAME proto-set => a k=2 group.
+  // inner_aware_volume multiplies ip(c,2) once per member => M_2^2.
+  auto tot = tot_indices(std::vector<Index>{a1, a2});
+  auto ixex = [&](Index const& ix) {
+    return static_cast<double>(r.extent(ix));
+  };
+  const double vol = sequant::opt::detail::inner_aware_volume(tot, ixex, ip);
+
+  const double expected =
+      double(occ) * double(occ) * Mk[2] * Mk[2];  // occ^2 * M_2^2
+  CHECK(vol == Catch::Approx(expected));
+  // Guard against the two wrong models:
+  CHECK(vol !=
+        Catch::Approx(double(occ) * occ * Mk[1] * Mk[1]));  // flat-average
+                                                            // under-count
+  CHECK(vol != Catch::Approx(double(occ) * occ *
+                             std::pow(Mk[1], 4)));  // old "occ^2*PNO^4
+                                                    // artifact"
+}
+
 // Sanity check for the probe's own plumbing (is_stand_in_batchable /
 // batch_policy / term_batch_axes / binarize round-trip), independent of the
 // real residual: with a tiny peak_threshold that makes every schedule

From 8b55749ef4709f36aaf1d23ea0a809aa045375bb Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Sun, 5 Jul 2026 12:33:19 -0400
Subject: [PATCH 34/78] dryrun: gated cache with batchable-axis veto and
 per-term reset

---
 .../eval/backends/dryrun/cost_profile.hpp     |  99 +++++++++
 tests/unit/test_eval_dryrun.cpp               | 193 ++++++++++++++++++
 2 files changed, 292 insertions(+)
 create mode 100644 SeQuant/core/eval/backends/dryrun/cost_profile.hpp

diff --git a/SeQuant/core/eval/backends/dryrun/cost_profile.hpp b/SeQuant/core/eval/backends/dryrun/cost_profile.hpp
new file mode 100644
index 0000000000..e45b377b1e
--- /dev/null
+++ b/SeQuant/core/eval/backends/dryrun/cost_profile.hpp
@@ -0,0 +1,99 @@
+#ifndef SEQUANT_CORE_EVAL_BACKENDS_DRYRUN_COST_PROFILE_HPP
+#define SEQUANT_CORE_EVAL_BACKENDS_DRYRUN_COST_PROFILE_HPP
+
+#include <SeQuant/core/eval/backends/dryrun/eval_expr.hpp>
+#include <SeQuant/core/eval/backends/dryrun/size_regime.hpp>
+
+#include <SeQuant/core/eval/cache_manager.hpp>
+#include <SeQuant/core/index.hpp>
+#include <SeQuant/core/optimize/single_term_detail.hpp>
+
+#include <cstddef>
+#include <functional>
+#include <vector>
+
+namespace sequant::eval::dryrun {
+
+/// Configuration for a faithful (gated) dry-run cache: the same footprint gate
+/// and free-batchable-axis veto the real batched eval loop applies, so a
+/// free-batchable giant (a `mu~`/`K`-carrying DF intermediate) is NOT cached
+/// whole but recomputed sliced under each consumer's batch trigger.
+///
+/// The element types mirror the gated \c sequant::cache_manager overload
+/// (\c cache_manager.hpp): \c is_volatile is invoked on every \c TreeNode
+/// (deduced as \c EvalNodeDryRun for the dry-run backend), \c
+/// is_batchable_index on every result \c Index.
+///
+/// This struct lives here (rather than only in the test) because Task 4's
+/// \c cost_profile() entry point consumes it.
+struct CacheConfig {
+  /// Footprint gate (bytes): a node whose result footprint exceeds this is not
+  /// cached. 0 (default) disables the gate.
+  double max_footprint = 0.;
+  /// Minimum non-persistent repeats to cache an internal node (CSE rule).
+  std::size_t min_repeats = 2;
+  /// `bool(EvalNodeDryRun const&)`: true if the node is intrinsically volatile
+  /// (typically the amplitude leaves). Empty => nothing is volatile.
+  std::function<bool(EvalNodeDryRun const&)> is_volatile;
+  /// `bool(Index const&)`: true for an index the runtime batched evaluator
+  /// slices over (e.g. DF aux `K` / PAO `mu~`). A node whose result carries
+  /// such a free index is vetoed from caching. Empty => nothing is batchable.
+  std::function<bool(Index const&)> is_batchable_index;
+};
+
+/// Builds a gated dry-run cache from an eval-node range, a \p cfg, and a
+/// \p regime that supplies the moment-aware node-size model used for the
+/// footprint gate.
+///
+/// The footprint functor sizes a node's result (its \c canon_indices()) with
+/// the SAME moment-aware counter the DryRun \c Result uses
+/// (\c memsize_counter over \c regime.idx_to_extent()/inner_pow_fn()), scaled
+/// to bytes, so the gate compares like-for-like against \c cfg.max_footprint.
+///
+/// Unlike the SIMPLE \c cache_manager(nodes) factory the ad-hoc dry-run test
+/// sites use, this routes through the GATED overload so free-batchable-axis
+/// giants are vetoed (matching the real run). Call \c CacheManager::reset() on
+/// the returned cache between summands to drop per-term non-persistent scratch
+/// while keeping persistent (cross-term) entries.
+///
+/// \param nodes the evaluation forest (a range of \c EvalNodeDryRun).
+/// \param cfg   footprint/repeat/volatility/batchability configuration.
+/// \param regime the size regime supplying extents and CSV moment tables.
+/// \return a \c CacheManager over \c EvalNodeDryRun.
+template <typename NodeRange>
+auto build_dryrun_cache(NodeRange const& nodes, CacheConfig const& cfg,
+                        SizeRegime const& regime) {
+  auto memsize = sequant::opt::detail::memsize_counter(regime.idx_to_extent(),
+                                                       regime.inner_pow_fn());
+
+  // Footprint (bytes) of a node's RESULT: canon_indices() fed to the
+  // moment-aware counter (as the counter's `result` slot; the empty lhs/rhs
+  // contribute nothing) times 8 bytes/element. Same arithmetic as the DryRun
+  // Result::size_in_bytes(), so the gate is faithful.
+  auto footprint_of =
+      [memsize = std::move(memsize)](EvalNodeDryRun const& n) -> double {
+    std::vector<Index> const result(n->canon_indices().begin(),
+                                    n->canon_indices().end());
+    return memsize(std::vector<Index>{}, std::vector<Index>{}, result) * 8.0;
+  };
+
+  // Default the predicates so the gated factory never invokes an empty
+  // std::function (nothing volatile / nothing batchable leaves those gates
+  // inert, matching the factory's own defaults).
+  std::function<bool(EvalNodeDryRun const&)> is_volatile =
+      cfg.is_volatile ? cfg.is_volatile
+                      : std::function<bool(EvalNodeDryRun const&)>(
+                            [](EvalNodeDryRun const&) { return false; });
+  std::function<bool(Index const&)> is_batchable_index =
+      cfg.is_batchable_index ? cfg.is_batchable_index
+                             : std::function<bool(Index const&)>(
+                                   [](Index const&) { return false; });
+
+  return sequant::cache_manager(nodes, std::move(is_volatile), cfg.min_repeats,
+                                std::move(footprint_of), cfg.max_footprint,
+                                std::move(is_batchable_index));
+}
+
+}  // namespace sequant::eval::dryrun
+
+#endif  // SEQUANT_CORE_EVAL_BACKENDS_DRYRUN_COST_PROFILE_HPP
diff --git a/tests/unit/test_eval_dryrun.cpp b/tests/unit/test_eval_dryrun.cpp
index 094604c0b0..a3cf378d9e 100644
--- a/tests/unit/test_eval_dryrun.cpp
+++ b/tests/unit/test_eval_dryrun.cpp
@@ -56,6 +56,7 @@
 #define SEQUANT_EVAL_TRACE 1
 
 #include <SeQuant/core/eval/backends/dryrun/cost_model_object.hpp>
+#include <SeQuant/core/eval/backends/dryrun/cost_profile.hpp>
 #include <SeQuant/core/eval/backends/dryrun/eval_expr.hpp>
 #include <SeQuant/core/eval/backends/dryrun/result.hpp>
 #include <SeQuant/core/eval/backends/dryrun/size_regime.hpp>
@@ -1751,6 +1752,198 @@ TEST_CASE("dryrun perf-first vs peak-first factorization of the C60 giant term",
   CHECK(perf_first.max_free_mu < 4);
 }
 
+// Task 2: the FAITHFUL (gated) dry-run cache built by build_dryrun_cache must
+// VETO caching of a free-batchable giant -- a node whose result carries a free
+// mu~/K axis the runtime slices over -- exactly as the real batched eval loop
+// does, instead of materializing it whole. The SIMPLE cache_manager(nodes) the
+// ad-hoc [dryrun-perf]/[dryrun-trace] sites use caches such a giant; the gated
+// build must not. We prove this by contrasting three configs over the SAME
+// binarized C60 giant term (index 38):
+//   ref:  no gate  (max_footprint=0, never batchable) -> giant IS cached
+//   axis: axis veto only (max_footprint=0, is_df_batchable) -> giant NOT cached
+//   task: axis veto + footprint gate (max_footprint=1e11, is_df_batchable)
+//                                                            -> giant NOT
+//                                                            cached
+// A small non-batchable intermediate stays cached under all three. Residency is
+// read via CacheManager::exists() (the veto is a registration-time decision:
+// a vetoed node is never registered, so it is not, and cannot become, resident;
+// this is a stronger/cleaner signal than working_set_hwmark, which only tracks
+// alive cached bytes and is confounded by batched-inner scratch -- see the
+// [dryrun-perf] INTERPRETATION notes).
+TEST_CASE("dryrun gated cache vetoes free-batchable giant", "[dryrun][cache]") {
+  auto ctx = get_default_context().clone();
+  ctx.set_first_dummy_index_ordinal(1000000);
+  auto isr = ctx.mutable_index_space_registry();
+  REQUIRE(isr != nullptr);
+  sequant::mbpt::add_pao_spaces(isr);  // mu~
+  sequant::mbpt::add_df_spaces(isr);   // K
+  auto ctx_resetter = set_scoped_default_context(std::move(ctx));
+
+  auto const body = slurp(std::string(SEQUANT_UNIT_TESTS_SOURCE_DIR) +
+                          "/data/csv_ccsd_doubles_residual_df.txt");
+  REQUIRE(!body.empty());
+  std::string line = body;
+  if (auto nl = line.find('\n'); nl != std::string::npos)
+    line = line.substr(0, nl);
+  auto expr = deserialize<ExprPtr>(line);
+  REQUIRE(static_cast<bool>(expr));
+  REQUIRE(expr->is<Sum>());
+  auto const& summands = expr->as<Sum>().summands();
+  REQUIRE(!summands.empty());
+  auto flatten_product = [](ExprPtr const& e) -> ExprPtr {
+    if (!e->is<Product>()) return e;
+    auto const& p = e->as<Product>();
+    return ex<Product>(p.scalar(), p.factors(), Product::Flatten::Yes);
+  };
+  std::size_t const giant_idx = 38 < summands.size() ? 38 : 0;
+  ExprPtr giant = flatten_product(summands[giant_idx]);
+  REQUIRE(giant);
+
+  // FAITHFUL real C60 config (614336 job log), identical to [dryrun-perf].
+  auto regime = df_regime(/*mu_tilde=*/1800u, /*aux=*/4320u, /*i_occ=*/120u,
+                          /*pno=*/42.0, /*osv=*/310.0);
+  auto memsize = sequant::opt::detail::memsize_counter(regime.idx_to_extent(),
+                                                       regime.inner_pow_fn());
+
+  sequant::BatchPolicy policy;
+  policy.is_batchable_index = is_df_batchable;
+  policy.batch_target_size = [](Index const& ix) -> std::size_t {
+    return ix.space().base_key() == L"μ̃" ? std::size_t{256} : std::size_t{72};
+  };
+  policy.is_volatile_leaf = [](Tensor const& t) { return t.label() == L"t"; };
+  policy.accumulation_factor = 1.0;
+  policy.peak_threshold = 40e9;
+
+  // Optimize (perf-first) + binarize the giant, carrying the per-node batch
+  // axes so the binarized tree matches the real schedule.
+  auto axes_map = std::make_shared<std::unordered_map<
+      Expr const*, container::vector<container::svector<Index>>>>();
+  OptimizeOptions opts;
+  opts.objective_function = ObjectiveFunction::DenseTimeSpaceBatched;
+  opts.idx_to_extent = regime.idx_to_extent();
+  opts.inner_pow = regime.inner_pow_fn();
+  opts.batch_policy = policy;
+  opts.volatile_weight = 20.0;
+  opts.roofline.machine_balance = 200.0;
+  opts.roofline.fast_mem_elems = 1000000.0;
+  opts.term_batch_axes = axes_map;
+  auto optimized = optimize(giant, opts);
+  REQUIRE(static_cast<bool>(optimized));
+  auto it = axes_map->find(optimized.get());
+  container::vector<container::svector<Index>> node_axes;
+  if (it != axes_map->end()) node_axes = it->second;
+  BinarizationOptions bopts;
+  bopts.node_batch_axes = node_axes;
+  SEQUANT_PRAGMA_IGNORE_DEPRECATED_BEGIN
+  auto node = binarize<EvalExprDryRun>(optimized, {}, bopts);
+  SEQUANT_PRAGMA_IGNORE_DEPRECATED_END
+  std::vector<EvalNodeDryRun> const nodes{node};
+
+  // A node carries a free-batchable axis iff any of its RESULT (canon) indices
+  // is a batch axis -- the exact condition the gated factory's veto keys off.
+  auto carries_batchable = [](EvalNodeDryRun const& n) {
+    for (auto const& ix : n->canon_indices())
+      if (is_df_batchable(ix)) return true;
+    return false;
+  };
+
+  // Walk the binarized tree: pick the internal free-batchable node with the
+  // largest result footprint (THE giant), and any internal non-batchable node
+  // (a small intermediate that must stay cacheable).
+  EvalNodeDryRun giant_node = node;
+  double giant_bytes = -1.0;
+  bool giant_found = false;
+  EvalNodeDryRun small_node = node;
+  bool small_found = false;
+  std::function<void(EvalNodeDryRun const&)> walk =
+      [&](EvalNodeDryRun const& n) {
+        if (!n.leaf()) {
+          std::vector<Index> const free(n->canon_indices().begin(),
+                                        n->canon_indices().end());
+          double const bytes =
+              memsize(std::vector<Index>{}, std::vector<Index>{}, free) * 8.0;
+          if (carries_batchable(n)) {
+            if (bytes > giant_bytes) {
+              giant_bytes = bytes;
+              giant_node = n;
+              giant_found = true;
+            }
+          } else if (!small_found) {
+            small_node = n;
+            small_found = true;
+          }
+          walk(n.left());
+          walk(n.right());
+        }
+      };
+  walk(node);
+  REQUIRE(giant_found);  // the term has a free-mu~/K internal node
+  REQUIRE(small_found);  // and at least one non-batchable internal node
+
+  // is_volatile for the gated factory (the amplitude leaves are volatile).
+  auto is_vol = [](EvalNodeDryRun const& n) {
+    return n.leaf() && n->is_tensor() && n->as_tensor().label() == L"t";
+  };
+
+  using sequant::eval::dryrun::build_dryrun_cache;
+  using sequant::eval::dryrun::CacheConfig;
+
+  // ref: no gates -> the giant IS cached (baseline; this is what the SIMPLE
+  // ad-hoc factory would do).
+  CacheConfig ref_cfg;
+  ref_cfg.max_footprint = 0.;
+  ref_cfg.min_repeats = 1;
+  ref_cfg.is_volatile = is_vol;
+  ref_cfg.is_batchable_index = [](Index const&) { return false; };
+  auto ref_cache = build_dryrun_cache(nodes, ref_cfg, regime);
+
+  // axis: batchable-axis veto ONLY (footprint gate disabled) -> giant NOT
+  // cached, isolating the veto from the footprint gate.
+  CacheConfig axis_cfg = ref_cfg;
+  axis_cfg.is_batchable_index = is_df_batchable;
+  auto axis_cache = build_dryrun_cache(nodes, axis_cfg, regime);
+
+  // task: the config the task asks for (footprint gate + axis veto).
+  CacheConfig task_cfg = axis_cfg;
+  task_cfg.max_footprint = 1e11;
+  auto task_cache = build_dryrun_cache(nodes, task_cfg, regime);
+
+  // Without any gate the giant is registered/cacheable...
+  CHECK(ref_cache.exists(giant_node));
+  // ...the batchable-axis veto alone removes it...
+  CHECK_FALSE(axis_cache.exists(giant_node));
+  // ...and so does the task config.
+  CHECK_FALSE(task_cache.exists(giant_node));
+
+  // A small non-batchable intermediate stays cached under all three.
+  CHECK(ref_cache.exists(small_node));
+  CHECK(axis_cache.exists(small_node));
+  CHECK(task_cache.exists(small_node));
+
+  // Faithful end-to-end: replay the schedule through the real eval loop against
+  // the gated (task) cache; the giant must not become resident, while eval
+  // completes without materializing it whole.
+  auto cm = std::make_shared<CostModel const>(regime);
+  task_cache.set_custom_evaluator(
+      sequant::make_evaluator(policy, DryRunLeafEvaluator{cm}));
+  REQUIRE_NOTHROW(
+      (void)sequant::evaluate(node, DryRunLeafEvaluator{cm}, task_cache));
+  CHECK_FALSE(task_cache.exists(giant_node));  // still not registered => never
+                                               // resident
+  CHECK_FALSE(task_cache.alive(giant_node));
+
+  std::wcerr << L"\n=== [dryrun][cache] gated-veto verdict (C60 giant, index "
+             << giant_idx << L") ===\n  giant free-batchable node footprint = "
+             << (giant_bytes / 1e9) << L" GB\n  ref (no gate)  exists(giant) = "
+             << (ref_cache.exists(giant_node) ? L"YES" : L"no")
+             << L"\n  axis veto      exists(giant) = "
+             << (axis_cache.exists(giant_node) ? L"YES" : L"no")
+             << L"\n  task config    exists(giant) = "
+             << (task_cache.exists(giant_node) ? L"YES" : L"no")
+             << L"\n  small intermediate exists (task) = "
+             << (task_cache.exists(small_node) ? L"YES" : L"no") << L"\n";
+}
+
 // Whole-residual dry-run trace: optimize+binarize EVERY summand of the
 // post-transform PNO-CCSD doubles residual, then replay them all through the
 // real eval loop and ONE SHARED CacheManager (so cross-term CSE / persistent

From 612154caf3853b226115f3f38df0e313a1d046b9 Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Sun, 5 Jul 2026 12:47:31 -0400
Subject: [PATCH 35/78] eval: opt-in scratch-fold peak sink for faithful
 batched-replay peak

---
 SeQuant/core/eval/eval.hpp      |  41 +++++++++--
 tests/unit/test_eval_dryrun.cpp | 118 ++++++++++++++++++++++++++++++++
 2 files changed, 153 insertions(+), 6 deletions(-)

diff --git a/SeQuant/core/eval/eval.hpp b/SeQuant/core/eval/eval.hpp
index a9672d0cb4..8eec1d93a2 100644
--- a/SeQuant/core/eval/eval.hpp
+++ b/SeQuant/core/eval/eval.hpp
@@ -19,6 +19,7 @@
 
 #include <algorithm>
 #include <any>
+#include <atomic>
 #include <chrono>
 #include <iostream>
 #include <optional>
@@ -1205,6 +1206,16 @@ template <typename TreeNode, bool FHC, typename Members>
 
 }  // namespace detail
 
+/// Opt-in sink for the batched evaluator's per-batch scratch high-watermarks.
+/// The batched replay runs each aux/mu~ batch in a SEPARATE scratch
+/// CacheManager whose transients never enter the outer cache, so the outer
+/// cache's working_set_hwmark() misses the batched-inner peak. When a non-null
+/// PeakSink is threaded through make_batched_custom_evaluator (and its nested
+/// re-instantiations), each scratch's high-watermark folds (max) into this one
+/// global accumulator, yielding the true batched-replay peak. A null sink
+/// (the default) leaves all existing behavior byte-identical.
+using PeakSink = std::atomic<double>*;
+
 template <typename F, typename IndexPredicate = accept_any_index,
           typename ScopeGuardFactory = make_no_scope_guard,
           typename IsVolatile = never_volatile>
@@ -1212,9 +1223,9 @@ template <typename F, typename IndexPredicate = accept_any_index,
     F le, std::function<std::size_t(Index const&)> target_batch_size,
     IndexPredicate accept = {}, ScopeGuardFactory make_scope_guard = {},
     IsVolatile is_volatile = {}, bool persistent_only = false,
-    std::size_t depth = 0) {
+    std::size_t depth = 0, PeakSink peak = nullptr) {
   return [le = std::move(le), target_batch_size = std::move(target_batch_size),
-          accept, is_volatile, persistent_only, depth,
+          accept, is_volatile, persistent_only, depth, peak,
           make_scope_guard](auto const& node, auto& cache) -> ResultPtr {
     // Runaway backstop: nesting re-enters this evaluator on the per-batch
     // scratch (see the reinstall below), incrementing depth once per nested
@@ -1413,14 +1424,29 @@ template <typename F, typename IndexPredicate = accept_any_index,
           // is the same specialization as the one that reinstalls it.
           bs.cache.set_custom_evaluator(make_batched_custom_evaluator(
               std::function<ResultPtr(node_t const&)>{le_g}, target_batch_size,
-              accept, make_scope_guard, is_volatile, persistent_only,
-              depth + 1));
+              accept, make_scope_guard, is_volatile, persistent_only, depth + 1,
+              peak));
           ResultPtr part = evaluate(*mem, le_g, bs.cache);
           if (!acc[m])
             acc[m] = std::move(part);
           else
             acc[m]->add_inplace(*part);
         }
+        // Fold this batch's scratch high-watermark into the global sink. The
+        // next iteration calls bs.cache.reset(), which ZEROES the scratch
+        // hwmark, so the fold MUST happen here (per batch), not after the
+        // batches loop. The loop is serial (the nested evaluate() re-entry is
+        // serial too), but the sink is atomic; a relaxed fetch-max CAS keeps it
+        // correct regardless. A null sink skips the fold entirely, leaving
+        // existing (sink-less) callers byte-unchanged.
+        if (peak) {
+          const double cand =
+              static_cast<double>(bs.cache.working_set_hwmark());
+          double cur = peak->load(std::memory_order_relaxed);
+          while (cand > cur && !peak->compare_exchange_weak(
+                                   cur, cand, std::memory_order_relaxed)) {
+          }
+        }
       }
 
       // Store the members into the real cache under the canonical-phase
@@ -1463,9 +1489,12 @@ template <typename F, typename IndexPredicate = accept_any_index,
 /// \param yielder      The leaf evaluator (captured and forwarded).
 /// \param make_scope_guard  Optional scope-guard factory (same semantics as in
 ///        make_batched_custom_evaluator; defaults to make_no_scope_guard).
+/// \param peak      Optional PeakSink (same semantics as in
+///        make_batched_custom_evaluator); defaults to null (no folding).
 template <class F, class ScopeGuardFactory = make_no_scope_guard>
 [[nodiscard]] auto make_evaluator(BatchPolicy const& policy, F yielder,
-                                  ScopeGuardFactory make_scope_guard = {}) {
+                                  ScopeGuardFactory make_scope_guard = {},
+                                  PeakSink peak = nullptr) {
   auto is_volatile_node = [p = policy.is_volatile_leaf](auto const& n) -> bool {
     if (!n.leaf() || !n->is_tensor()) return false;
     return p && p(n->as_tensor());
@@ -1485,7 +1514,7 @@ template <class F, class ScopeGuardFactory = make_no_scope_guard>
   return make_batched_custom_evaluator(
       std::move(yielder), std::move(target), std::move(accept),
       std::move(make_scope_guard), std::move(is_volatile_node),
-      policy.persistent_only);
+      policy.persistent_only, /*depth=*/0, peak);
 }
 
 }  // namespace sequant
diff --git a/tests/unit/test_eval_dryrun.cpp b/tests/unit/test_eval_dryrun.cpp
index a3cf378d9e..982a827afd 100644
--- a/tests/unit/test_eval_dryrun.cpp
+++ b/tests/unit/test_eval_dryrun.cpp
@@ -80,6 +80,7 @@
 #include <catch2/catch_approx.hpp>
 #include <catch2/catch_test_macros.hpp>
 
+#include <atomic>
 #include <chrono>
 #include <cmath>
 #include <cstddef>
@@ -1752,6 +1753,123 @@ TEST_CASE("dryrun perf-first vs peak-first factorization of the C60 giant term",
   CHECK(perf_first.max_free_mu < 4);
 }
 
+// Task 3: the opt-in scratch-fold peak sink captures the batched-inner peak the
+// OUTER cache.working_set_hwmark() misses. Reuse the [dryrun-perf] peak-first
+// (DenseSpaceTimeBatched) setup -- the objective whose batched-inner transient
+// (~38.9 GB, materialized INSIDE a make_batched_scratch cache) dwarfs the
+// outer, cross-batch cached residency (~0.2 GB). A PeakSink passed to
+// make_evaluator folds each scratch cache's high-watermark into one global
+// accumulator, so the global peak reflects the true batched-replay peak rather
+// than just the outer residency the accessor sees today.
+TEST_CASE("dryrun scratch-fold captures batched peak", "[dryrun][peak]") {
+  auto ctx = get_default_context().clone();
+  ctx.set_first_dummy_index_ordinal(1000000);
+  auto isr = ctx.mutable_index_space_registry();
+  REQUIRE(isr != nullptr);
+  sequant::mbpt::add_pao_spaces(isr);  // mu~
+  sequant::mbpt::add_df_spaces(isr);   // K
+  auto ctx_resetter = set_scoped_default_context(std::move(ctx));
+
+  auto const body = slurp(std::string(SEQUANT_UNIT_TESTS_SOURCE_DIR) +
+                          "/data/csv_ccsd_doubles_residual_df.txt");
+  REQUIRE(!body.empty());
+  std::string line = body;
+  if (auto nl = line.find('\n'); nl != std::string::npos)
+    line = line.substr(0, nl);
+  auto expr = deserialize<ExprPtr>(line);
+  REQUIRE(static_cast<bool>(expr));
+  REQUIRE(expr->is<Sum>());
+  auto const& summands = expr->as<Sum>().summands();
+  REQUIRE(!summands.empty());
+  auto flatten_product = [](ExprPtr const& e) -> ExprPtr {
+    if (!e->is<Product>()) return e;
+    auto const& p = e->as<Product>();
+    return ex<Product>(p.scalar(), p.factors(), Product::Flatten::Yes);
+  };
+  std::size_t const giant_idx = 38 < summands.size() ? 38 : 0;
+  ExprPtr giant = flatten_product(summands[giant_idx]);
+  REQUIRE(giant);
+
+  // FAITHFUL real C60 config (identical to [dryrun-perf]).
+  auto regime = df_regime(/*mu_tilde=*/1800u, /*aux=*/4320u, /*i_occ=*/120u,
+                          /*pno=*/42.0, /*osv=*/310.0);
+  auto cm = std::make_shared<CostModel const>(regime);
+
+  sequant::BatchPolicy policy;
+  policy.is_batchable_index = is_df_batchable;
+  policy.batch_target_size = [](Index const& ix) -> std::size_t {
+    return ix.space().base_key() == L"μ̃" ? std::size_t{256} : std::size_t{72};
+  };
+  policy.is_volatile_leaf = [](Tensor const& t) { return t.label() == L"t"; };
+  policy.accumulation_factor = 1.0;
+  policy.peak_threshold = 40e9;
+
+  auto axes_map = std::make_shared<std::unordered_map<
+      Expr const*, container::vector<container::svector<Index>>>>();
+  OptimizeOptions opts;
+  // peak-first: forms the fully-sliceable 4-PAO node whose per-batch scratch
+  // transient is the batched-inner peak we want the sink to capture.
+  opts.objective_function = ObjectiveFunction::DenseSpaceTimeBatched;
+  opts.idx_to_extent = regime.idx_to_extent();
+  opts.inner_pow = regime.inner_pow_fn();
+  opts.batch_policy = policy;
+  opts.volatile_weight = 20.0;
+  opts.roofline.machine_balance = 200.0;
+  opts.roofline.fast_mem_elems = 1000000.0;
+  opts.term_batch_axes = axes_map;
+
+  auto optimized = optimize(giant, opts);
+  REQUIRE(static_cast<bool>(optimized));
+  auto it = axes_map->find(optimized.get());
+  container::vector<container::svector<Index>> node_axes;
+  if (it != axes_map->end()) node_axes = it->second;
+  BinarizationOptions bopts;
+  bopts.node_batch_axes = node_axes;
+  SEQUANT_PRAGMA_IGNORE_DEPRECATED_BEGIN
+  auto node = binarize<EvalExprDryRun>(optimized, {}, bopts);
+  SEQUANT_PRAGMA_IGNORE_DEPRECATED_END
+
+  // Zero-data replay through the real eval loop + real CacheManager, with the
+  // real batched custom evaluator, but now with a PeakSink threaded through
+  // make_evaluator so each per-batch scratch cache's working_set_hwmark folds
+  // into `peak`.
+  auto cache = sequant::cache_manager(std::vector<EvalNodeDryRun>{node});
+  std::atomic<double> peak{0.0};
+  cache.set_custom_evaluator(sequant::make_evaluator(
+      policy, DryRunLeafEvaluator{cm}, sequant::make_no_scope_guard{}, &peak));
+
+  std::ostringstream trace_os;
+  auto& logger = Logger::instance();
+  auto const prev_level = logger.eval.level;
+  auto* const prev_stream = logger.eval.stream;
+  logger.eval.level = 2;  // gate log::printing() on so hwmark accumulates
+  logger.eval.stream = &trace_os;
+  try {
+    (void)sequant::evaluate<Trace::On>(node, DryRunLeafEvaluator{cm}, cache);
+  } catch (std::exception const&) {
+    // mirror [dryrun-perf]: a DryRun sizing throw must not mask the sink read
+  }
+  logger.eval.level = prev_level;
+  logger.eval.stream = prev_stream;
+
+  double const global_peak = peak.load();
+  double const outer_hwmark = double(cache.working_set_hwmark());
+
+  std::wcerr << L"\n[dryrun-peak] global scratch-folded peak="
+             << (global_peak / 1e9) << L" GB  outer working_set_hwmark="
+             << (outer_hwmark / 1e9) << L" GB  ratio="
+             << (outer_hwmark > 0.0 ? global_peak / outer_hwmark : 0.0)
+             << L"\n";
+
+  // The sink must have captured something (batched replay ran).
+  CHECK(global_peak > 0.0);
+  // The global (scratch-folded) peak is at least the outer cached residency.
+  CHECK(global_peak >= outer_hwmark);
+  // For this specifically-batched term the batched-inner transient dwarfs the
+  // outer residency (~195x observed); a 2x floor is safe and non-flaky.
+  CHECK(global_peak > outer_hwmark * 2.0);
+}
+
 // Task 2: the FAITHFUL (gated) dry-run cache built by build_dryrun_cache must
 // VETO caching of a free-batchable giant -- a node whose result carries a free
 // mu~/K axis the runtime slices over -- exactly as the real batched eval loop

From 1bf6f3f820a3d9be4a9bbb493414b82eb6cbc44b Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Sun, 5 Jul 2026 13:02:23 -0400
Subject: [PATCH 36/78] dryrun: CostProfile struct and cost_profile() reusable
 entry point

---
 .../eval/backends/dryrun/cost_profile.hpp     | 156 ++++++++++++++++++
 tests/unit/test_eval_dryrun.cpp               | 138 ++++++++++++++++
 2 files changed, 294 insertions(+)

diff --git a/SeQuant/core/eval/backends/dryrun/cost_profile.hpp b/SeQuant/core/eval/backends/dryrun/cost_profile.hpp
index e45b377b1e..267000c45e 100644
--- a/SeQuant/core/eval/backends/dryrun/cost_profile.hpp
+++ b/SeQuant/core/eval/backends/dryrun/cost_profile.hpp
@@ -1,15 +1,26 @@
 #ifndef SEQUANT_CORE_EVAL_BACKENDS_DRYRUN_COST_PROFILE_HPP
 #define SEQUANT_CORE_EVAL_BACKENDS_DRYRUN_COST_PROFILE_HPP
 
+#include <SeQuant/core/eval/backends/dryrun/cost_model_object.hpp>
 #include <SeQuant/core/eval/backends/dryrun/eval_expr.hpp>
 #include <SeQuant/core/eval/backends/dryrun/size_regime.hpp>
 
+#include <SeQuant/core/batch_policy.hpp>
+#include <SeQuant/core/container.hpp>
 #include <SeQuant/core/eval/cache_manager.hpp>
+#include <SeQuant/core/eval/eval.hpp>
 #include <SeQuant/core/index.hpp>
+#include <SeQuant/core/logger.hpp>
 #include <SeQuant/core/optimize/single_term_detail.hpp>
 
+#include <algorithm>
+#include <atomic>
 #include <cstddef>
 #include <functional>
+#include <memory>
+#include <ostream>
+#include <sstream>
+#include <string>
 #include <vector>
 
 namespace sequant::eval::dryrun {
@@ -94,6 +105,151 @@ auto build_dryrun_cache(NodeRange const& nodes, CacheConfig const& cfg,
                                 std::move(is_batchable_index));
 }
 
+/// Summary of the modeled cost of a factorized dry-run eval forest, as produced
+/// by \c cost_profile(). All quantities are summed/maxed over every summand
+/// tree in the forest.
+struct CostProfile {
+  /// Predicted peak working-set (bytes): the max over summands of the
+  /// batched-scratch high-watermark folded by the Task-3 \c PeakSink and the
+  /// outer gated cache's \c working_set_hwmark().
+  double peak_bytes = 0;
+  /// Summed unweighted static contraction FLOPs over all internal nodes.
+  double flops = 0;
+  /// Summed roofline-projected execution cost over all internal nodes.
+  double exec_cost = 0;
+  /// Number of internal (contraction) nodes across the forest.
+  std::size_t n_ops = 0;
+};
+
+/// Replays a factorized eval forest zero-data through the real eval loop --
+/// with a gated cache built from \p cfg (Task 2) and a \c PeakSink threaded
+/// through the batched evaluator (Task 3) -- and, alongside, does a static walk
+/// of the forest to accumulate FLOPs / roofline exec cost / op count. This is
+/// the single reusable entry point both SeQuant tests and MPQC call.
+///
+/// \par The printing gate
+/// \c CacheManager::working_set_hwmark() only accumulates while
+/// \c sequant::eval::log::printing() is true (the hwmark update sits on the
+/// trace-printing path). This routine therefore FORCES the eval logger's level
+/// > 0 around the replay -- discarding the narrow trace to a null sink when no
+/// \p trace is requested -- and restores the previous logger state afterward,
+/// so \c peak_bytes is non-zero even with no trace stream.
+///
+/// \param forest per-summand optimized+binarized eval forest (the real IR).
+/// \param policy the batch policy driving the replay evaluator; its
+///        \c is_batchable_index MUST match \c cfg.is_batchable_index.
+/// \param cfg    gated-cache config (footprint gate, axis veto, volatile,
+///        repeats).
+/// \param regime the size regime supplying extents and CSV moment tables;
+///        the internal \c CostModel and \c DryRunLeafEvaluator are built from
+///        it.
+/// \param trace  optional per-op trace sink (nullptr = no trace). When
+///        non-null, the eval loop's narrow trace is transcoded (UTF-8) into it.
+/// \return the accumulated \c CostProfile.
+inline CostProfile cost_profile(std::vector<EvalNodeDryRun> const& forest,
+                                BatchPolicy const& policy,
+                                CacheConfig const& cfg,
+                                SizeRegime const& regime,
+                                std::wostream* trace = nullptr) {
+  CostProfile profile;
+
+  auto cm = std::make_shared<CostModel const>(regime);
+  DryRunLeafEvaluator const leaf{cm};
+
+  // ---- static cost walk (independent of the replay) --------------------
+  // For every internal node: flops = flops_counter(left, right, result); the
+  // roofline exec cost uses the left operand's footprint as the transferred
+  // bytes and the arena convention (4096) the [dryrun-costmodel] test fixes.
+  auto const flops_of = sequant::opt::detail::flops_counter(
+      regime.idx_to_extent(), regime.inner_pow_fn());
+  std::function<void(EvalNodeDryRun const&)> walk =
+      [&](EvalNodeDryRun const& n) {
+        if (n.leaf()) return;
+        profile.n_ops += 1;
+        double const node_flops =
+            flops_of(n.left()->canon_indices(), n.right()->canon_indices(),
+                     n->canon_indices());
+        profile.flops += node_flops;
+        container::svector<Index> const left(n.left()->canon_indices().begin(),
+                                             n.left()->canon_indices().end());
+        profile.exec_cost += cm->exec_cost(node_flops, cm->memsize(left), 4096);
+        walk(n.left());
+        walk(n.right());
+      };
+  for (auto const& root : forest) walk(root);
+
+  // ---- peak replay through the real eval loop --------------------------
+  auto cache = build_dryrun_cache(forest, cfg, regime);
+
+  auto& logger = Logger::instance();
+  auto const prev_level = logger.eval.level;
+  auto* const prev_stream = logger.eval.stream;
+  // Force printing() on so working_set_hwmark() accumulates. The eval logger
+  // stream is narrow; capture into a narrow buffer only when a (wide) trace
+  // sink was requested, else discard to a null stream.
+  std::ostringstream trace_capture;
+  logger.eval.level = 2;
+  logger.eval.stream = trace ? &trace_capture : nullptr;
+
+  std::atomic<double> peak{0.0};
+  for (auto const& root : forest) {
+    cache.set_custom_evaluator(sequant::make_evaluator(
+        policy, leaf, sequant::make_no_scope_guard{}, &peak));
+    try {
+      (void)sequant::evaluate<Trace::On>(root, leaf, cache);
+    } catch (std::exception const&) {
+      // A zero-data DryRun sizing throw must not mask the peak read.
+    }
+    // Fold the outer cached residency BEFORE reset() (which zeroes the
+    // hwmark). `peak` folds every batched scratch high-watermark across all
+    // summands via std::max, so its running load() is the global scratch peak.
+    profile.peak_bytes = std::max(
+        {profile.peak_bytes, peak.load(), double(cache.working_set_hwmark())});
+    cache.reset();  // drop per-term non-persistent scratch; keep persistent
+  }
+
+  logger.eval.level = prev_level;
+  logger.eval.stream = prev_stream;
+
+  // If a wide trace sink was requested, transcode the captured narrow (UTF-8)
+  // eval trace into it (the eval loop writes only to the narrow logger stream;
+  // index labels such as mu~/K are multi-byte, so a plain widen would corrupt
+  // them -- decode UTF-8 to code points instead).
+  if (trace) {
+    std::string const s = trace_capture.str();
+    std::wstring w;
+    w.reserve(s.size());
+    for (std::size_t i = 0; i < s.size();) {
+      unsigned char const c = static_cast<unsigned char>(s[i]);
+      char32_t cp;
+      std::size_t len;
+      if (c < 0x80) {
+        cp = c;
+        len = 1;
+      } else if ((c >> 5) == 0x6) {
+        cp = c & 0x1Fu;
+        len = 2;
+      } else if ((c >> 4) == 0xE) {
+        cp = c & 0x0Fu;
+        len = 3;
+      } else if ((c >> 3) == 0x1E) {
+        cp = c & 0x07u;
+        len = 4;
+      } else {
+        cp = c;  // invalid lead byte: pass through
+        len = 1;
+      }
+      for (std::size_t k = 1; k < len && i + k < s.size(); ++k)
+        cp = (cp << 6) | (static_cast<unsigned char>(s[i + k]) & 0x3Fu);
+      w.push_back(static_cast<wchar_t>(cp));
+      i += len;
+    }
+    *trace << w;
+  }
+
+  return profile;
+}
+
 }  // namespace sequant::eval::dryrun
 
 #endif  // SEQUANT_CORE_EVAL_BACKENDS_DRYRUN_COST_PROFILE_HPP
diff --git a/tests/unit/test_eval_dryrun.cpp b/tests/unit/test_eval_dryrun.cpp
index 982a827afd..78a791de45 100644
--- a/tests/unit/test_eval_dryrun.cpp
+++ b/tests/unit/test_eval_dryrun.cpp
@@ -1870,6 +1870,144 @@ TEST_CASE("dryrun scratch-fold captures batched peak", "[dryrun][peak]") {
   CHECK(global_peak > outer_hwmark * 2.0);
 }
 
+// Task 4: cost_profile() is the single reusable entry point that ties the
+// static cost walk (flops/exec_cost/n_ops) to the gated-cache peak replay
+// (Task 2 build_dryrun_cache + Task 3 PeakSink scratch-fold) behind one API
+// that MPQC and these tests share. The key regression guard is peak_bytes > 0
+// with NO trace stream: cost_profile MUST force log::printing() on internally
+// (the CacheManager hwmark only accumulates on the printing path), otherwise
+// the sink and the outer hwmark would both be zero.
+TEST_CASE("cost_profile returns peak/flops/exec/n_ops",
+          "[dryrun][cost_profile]") {
+  using sequant::eval::dryrun::build_dryrun_cache;
+  using sequant::eval::dryrun::CacheConfig;
+  using sequant::eval::dryrun::cost_profile;
+  using sequant::eval::dryrun::CostProfile;
+
+  auto ctx = get_default_context().clone();
+  ctx.set_first_dummy_index_ordinal(1000000);
+  auto isr = ctx.mutable_index_space_registry();
+  REQUIRE(isr != nullptr);
+  sequant::mbpt::add_pao_spaces(isr);  // mu~
+  sequant::mbpt::add_df_spaces(isr);   // K
+  auto ctx_resetter = set_scoped_default_context(std::move(ctx));
+
+  auto const body = slurp(std::string(SEQUANT_UNIT_TESTS_SOURCE_DIR) +
+                          "/data/csv_ccsd_doubles_residual_df.txt");
+  REQUIRE(!body.empty());
+  std::string line = body;
+  if (auto nl = line.find('\n'); nl != std::string::npos)
+    line = line.substr(0, nl);
+  auto expr = deserialize<ExprPtr>(line);
+  REQUIRE(static_cast<bool>(expr));
+  REQUIRE(expr->is<Sum>());
+  auto const& summands = expr->as<Sum>().summands();
+  REQUIRE(!summands.empty());
+  auto flatten_product = [](ExprPtr const& e) -> ExprPtr {
+    if (!e->is<Product>()) return e;
+    auto const& p = e->as<Product>();
+    return ex<Product>(p.scalar(), p.factors(), Product::Flatten::Yes);
+  };
+  std::size_t const giant_idx = 38 < summands.size() ? 38 : 0;
+  ExprPtr giant = flatten_product(summands[giant_idx]);
+  REQUIRE(giant);
+
+  // FAITHFUL real C60 config (identical to [dryrun-perf] / [peak]).
+  auto regime = df_regime(/*mu_tilde=*/1800u, /*aux=*/4320u, /*i_occ=*/120u,
+                          /*pno=*/42.0, /*osv=*/310.0);
+
+  // ONE BatchPolicy, reused for optimize() and the replay evaluator (its
+  // is_batchable_index MUST equal CacheConfig::is_batchable_index).
+  sequant::BatchPolicy policy;
+  policy.is_batchable_index = is_df_batchable;
+  policy.batch_target_size = [](Index const& ix) -> std::size_t {
+    return ix.space().base_key() == L"μ̃" ? std::size_t{256} : std::size_t{72};
+  };
+  policy.is_volatile_leaf = [](Tensor const& t) { return t.label() == L"t"; };
+  policy.accumulation_factor = 1.0;
+  policy.peak_threshold = 40e9;
+
+  auto axes_map = std::make_shared<std::unordered_map<
+      Expr const*, container::vector<container::svector<Index>>>>();
+  OptimizeOptions opts;
+  // peak-first: forms the fully-sliceable 4-PAO node whose per-batch scratch
+  // transient is the batched-inner peak the sink must capture.
+  opts.objective_function = ObjectiveFunction::DenseSpaceTimeBatched;
+  opts.idx_to_extent = regime.idx_to_extent();
+  opts.inner_pow = regime.inner_pow_fn();
+  opts.batch_policy = policy;
+  opts.volatile_weight = 20.0;
+  opts.roofline.machine_balance = 200.0;
+  opts.roofline.fast_mem_elems = 1000000.0;
+  opts.term_batch_axes = axes_map;
+
+  auto optimized = optimize(giant, opts);
+  REQUIRE(static_cast<bool>(optimized));
+  auto it = axes_map->find(optimized.get());
+  container::vector<container::svector<Index>> node_axes;
+  if (it != axes_map->end()) node_axes = it->second;
+  BinarizationOptions bopts;
+  bopts.node_batch_axes = node_axes;
+  SEQUANT_PRAGMA_IGNORE_DEPRECATED_BEGIN
+  auto node = binarize<EvalExprDryRun>(optimized, {}, bopts);
+  SEQUANT_PRAGMA_IGNORE_DEPRECATED_END
+
+  std::vector<EvalNodeDryRun> forest{node};
+
+  // CacheConfig mirroring the real batched run: footprint gate + free-batchable
+  // axis veto; is_volatile adapts policy.is_volatile_leaf onto tree nodes.
+  CacheConfig cfg;
+  cfg.max_footprint = 1e11;
+  cfg.min_repeats = 1;
+  cfg.is_batchable_index = policy.is_batchable_index;
+  cfg.is_volatile = [](EvalNodeDryRun const& n) {
+    if (!n.leaf() || !n->is_tensor()) return false;
+    return n->as_tensor().label() == L"t";
+  };
+
+  // Call cost_profile with NO trace stream: this is the printing-gate gotcha
+  // regression guard -- peak_bytes must still be > 0.
+  CostProfile const cp = cost_profile(forest, policy, cfg, regime,
+                                      /*trace=*/nullptr);
+
+  std::wcerr << L"\n[cost_profile] n_ops=" << cp.n_ops << L" flops=" << cp.flops
+             << L" exec_cost=" << cp.exec_cost << L" peak_bytes="
+             << (cp.peak_bytes / 1e9) << L" GB\n";
+
+  CHECK(cp.n_ops > 0);
+  CHECK(cp.flops > 0.0);
+  CHECK(cp.exec_cost > 0.0);
+  // The gotcha guard: printing was forced on internally, so the hwmark/sink
+  // accumulated even with no trace stream.
+  CHECK(cp.peak_bytes > 0.0);
+
+  // Cross-check that cost_profile's peak wires the SAME fold as the Task-3
+  // [peak] test: replay the same forest through the same gated cache + the same
+  // make_evaluator(&peak2) sink, force printing on identically, and fold the
+  // outer hwmark. cost_profile's peak_bytes must equal max(sink, outer hwmark).
+  auto cm = std::make_shared<CostModel const>(regime);
+  DryRunLeafEvaluator leaf{cm};
+  auto cache = build_dryrun_cache(forest, cfg, regime);
+  std::atomic<double> peak2{0.0};
+  cache.set_custom_evaluator(sequant::make_evaluator(
+      policy, leaf, sequant::make_no_scope_guard{}, &peak2));
+  auto& logger = Logger::instance();
+  auto const prev_level = logger.eval.level;
+  auto* const prev_stream = logger.eval.stream;
+  logger.eval.level = 2;
+  logger.eval.stream = nullptr;
+  try {
+    (void)sequant::evaluate<Trace::On>(node, leaf, cache);
+  } catch (std::exception const&) {
+  }
+  logger.eval.level = prev_level;
+  logger.eval.stream = prev_stream;
+  double const expected_peak =
+      std::max(peak2.load(), double(cache.working_set_hwmark()));
+  CHECK(expected_peak > 0.0);
+  CHECK(cp.peak_bytes == Catch::Approx(expected_peak).epsilon(1e-9));
+}
+
 // Task 2: the FAITHFUL (gated) dry-run cache built by build_dryrun_cache must
 // VETO caching of a free-batchable giant -- a node whose result carries a free
 // mu~/K axis the runtime slices over -- exactly as the real batched eval loop

From db332d445846580a5b1fdbe201a36a05058e997c Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Sun, 5 Jul 2026 13:22:19 -0400
Subject: [PATCH 37/78] dryrun: route [dryrun-perf]/[dryrun-trace] through
 cost_profile

Retrofit both harness tests onto the single cost_profile() entry point,
replacing their ad-hoc cache build + manual replay + working_set_hwmark
reads so there is one peak/flops code path.

[dryrun-perf]: analyze() now calls cost_profile() per objective; keeps the
static tree-walk 4-PAO structural proof (peak-first forms it, perf-first
does not) plus new cost assertions perf.flops <= peak.flops and a
100 GB..1 TB band on perf.peak_bytes (measured 387.73 GB).

[dryrun-trace]: whole-residual replay replaced by one cost_profile() call
into a wide sink, re-encoded to UTF-8 for the trace file; asserts finite
peak_bytes > 0 and a non-empty trace.

cost_profile() now copies policy.is_batchable_index over the local
CacheConfig before build_dryrun_cache so the cache veto and the evaluator
batch on the same predicate (Task-4 Minor a; field documented advisory).

Adds a focused round-trip test exercising the UTF-8 -> wide bridge
(asserts result= and the multi-byte mu~ label; Task-4 Minor b).
---
 .../eval/backends/dryrun/cost_profile.hpp     |  16 +-
 tests/unit/test_eval_dryrun.cpp               | 398 ++++++++++--------
 2 files changed, 237 insertions(+), 177 deletions(-)

diff --git a/SeQuant/core/eval/backends/dryrun/cost_profile.hpp b/SeQuant/core/eval/backends/dryrun/cost_profile.hpp
index 267000c45e..d2469f9c3b 100644
--- a/SeQuant/core/eval/backends/dryrun/cost_profile.hpp
+++ b/SeQuant/core/eval/backends/dryrun/cost_profile.hpp
@@ -49,6 +49,11 @@ struct CacheConfig {
   /// `bool(Index const&)`: true for an index the runtime batched evaluator
   /// slices over (e.g. DF aux `K` / PAO `mu~`). A node whose result carries
   /// such a free index is vetoed from caching. Empty => nothing is batchable.
+  ///
+  /// ADVISORY when passed to \c cost_profile(): that entry point OVERWRITES
+  /// this field with \c policy.is_batchable_index before building the cache, so
+  /// the cache veto and the replay evaluator can never batch on different
+  /// predicates. Only \c build_dryrun_cache() called directly honors it as-is.
   std::function<bool(Index const&)> is_batchable_index;
 };
 
@@ -137,7 +142,9 @@ struct CostProfile {
 ///
 /// \param forest per-summand optimized+binarized eval forest (the real IR).
 /// \param policy the batch policy driving the replay evaluator; its
-///        \c is_batchable_index MUST match \c cfg.is_batchable_index.
+///        \c is_batchable_index is COPIED over \c cfg.is_batchable_index
+///        internally so the cache veto and the evaluator batch on the same
+///        axis predicate (the \c cfg field is advisory here).
 /// \param cfg    gated-cache config (footprint gate, axis veto, volatile,
 ///        repeats).
 /// \param regime the size regime supplying extents and CSV moment tables;
@@ -179,7 +186,12 @@ inline CostProfile cost_profile(std::vector<EvalNodeDryRun> const& forest,
   for (auto const& root : forest) walk(root);
 
   // ---- peak replay through the real eval loop --------------------------
-  auto cache = build_dryrun_cache(forest, cfg, regime);
+  // Force the cache veto and the replay evaluator to slice on the SAME axis
+  // predicate: a mismatch would let the cache retain a giant the evaluator
+  // batches (or vice versa), silently diverging the modeled peak from the run.
+  CacheConfig local_cfg = cfg;
+  local_cfg.is_batchable_index = policy.is_batchable_index;
+  auto cache = build_dryrun_cache(forest, local_cfg, regime);
 
   auto& logger = Logger::instance();
   auto const prev_level = logger.eval.level;
diff --git a/tests/unit/test_eval_dryrun.cpp b/tests/unit/test_eval_dryrun.cpp
index 78a791de45..82ff9eed3f 100644
--- a/tests/unit/test_eval_dryrun.cpp
+++ b/tests/unit/test_eval_dryrun.cpp
@@ -1474,32 +1474,24 @@ TEST_CASE("dryrun perf-first vs peak-first factorization of the C60 giant term",
     return ix.space().base_key() == L"μ̃" ? 256.0 : 72.0;
   };
   auto keyof = [](Index const& ix) { return std::wstring(ix.full_label()); };
-  auto cm = std::make_shared<CostModel const>(regime);
 
   struct Analysis {
     std::size_t max_free_mu = 0;       // >= 4 => 4-PAO AO integral formed
     double largest_realized_gb = 0.0;  // DP-model realized free-mu~ (static)
     std::wstring largest_desc;
-    // Runtime-replay metrics (zero-data eval through the REAL eval loop + REAL
-    // CacheManager):
-    double hwmark_gb =
-        0.0;  // cache.working_set_hwmark() = per-op running max
-              // of (sum of alive cached entries + in-flight
-              // result). "high watermark of cached intermediates"
-    double max_single_result_gb = 0.0;  // largest single result= in the trace =
-                                        // the largest transient materialized
-    std::string largest_result_line;    // full trace line of that result=
-                                        // (shows result= and hw= together)
-    bool replay_threw = false;
+    // Peak/flops/exec from the single shared cost_profile() entry point (Task
+    // 4: gated-cache peak replay + static flops/exec walk), replacing the
+    // ad-hoc manual replay + hwmark read this case used before Task 5.
+    sequant::eval::dryrun::CostProfile cp;
   };
 
   // Optimize the giant under `obj`, binarize, and walk the tree computing per
-  // node (a) its free-mu~ count and (b) its REALIZED free-mu~ size after
-  // ancestor slicing (same active-ancestor accounting as the [dryrun-df]
-  // verdict case). Then REPLAY the zero-data schedule through the real eval
-  // loop + real CacheManager to capture the cached-intermediate high watermark
-  // (working_set_hwmark) alongside the largest single transient (result=), so
-  // the cache-vs-transient accounting gap is visible per objective.
+  // node (a) its free-mu~ count (the 4-PAO structural signature) and (b) its
+  // REALIZED free-mu~ size after ancestor slicing (same active-ancestor
+  // accounting as the [dryrun-df] verdict case). Then call the single shared
+  // cost_profile() entry point (Task 4) to get the modeled peak/flops/exec via
+  // the gated-cache replay -- replacing the ad-hoc manual replay + hwmark read
+  // this case used before Task 5, so there is ONE peak/flops code path.
   auto analyze = [&](ObjectiveFunction obj) -> Analysis {
     sequant::BatchPolicy policy;
     policy.is_batchable_index = is_df_batchable;
@@ -1604,59 +1596,26 @@ TEST_CASE("dryrun perf-first vs peak-first factorization of the C60 giant term",
         };
     walk(node, {});
 
-    // ---- runtime replay: predict the cached-intermediate high watermark ----
-    // Zero-data eval through the real eval loop + real CacheManager, with the
-    // real batched custom evaluator. working_set_hwmark() folds, per op, (sum
-    // of alive cached entries + in-flight result) into a running max; the
-    // trace's result= field is the largest single materialized transient.
-    // (Single-term, default cache_manager: this is the WITHIN-TERM cached
-    // working set. The whole-residual / cross-iteration watermark -- one shared
-    // cache over the full DAG with the real max_footprint gate -- is the
-    // deferred DryRun-as-prefix wiring.)
-    auto cache = sequant::cache_manager(std::vector<EvalNodeDryRun>{node});
-    cache.set_custom_evaluator(
-        sequant::make_evaluator(policy, DryRunLeafEvaluator{cm}));
-    std::ostringstream trace_os;
-    auto& logger = Logger::instance();
-    auto const prev_level = logger.eval.level;
-    auto* const prev_stream = logger.eval.stream;
-    logger.eval.level = 2;  // gate log::printing() on so hwmark accumulates
-    logger.eval.stream = &trace_os;
-    try {
-      (void)sequant::evaluate<Trace::On>(node, DryRunLeafEvaluator{cm}, cache);
-    } catch (std::exception const&) {
-      a.replay_threw = true;
-    }
-    logger.eval.level = prev_level;
-    logger.eval.stream = prev_stream;
-    a.hwmark_gb = double(cache.working_set_hwmark()) / 1e9;
-    // Largest single result= in the trace, and its full line (result= and hw=
-    // appear together, so the line exposes whether the giant transient is
-    // folded into the cache hwmark).
-    {
-      std::string const trace = trace_os.str();
-      std::size_t pos = 0, best = 0;
-      while ((pos = trace.find("result=", pos)) != std::string::npos) {
-        std::size_t const np = pos + std::string("result=").size();
-        std::size_t const end = trace.find('B', np);
-        if (end == std::string::npos) break;
-        std::string const num = trace.substr(np, end - np);
-        if (!num.empty() &&
-            num.find_first_not_of("0123456789") == std::string::npos) {
-          std::size_t const v = std::stoull(num);
-          if (v > best) {
-            best = v;
-            std::size_t ls = trace.rfind('\n', pos);
-            ls = (ls == std::string::npos) ? 0 : ls + 1;
-            std::size_t const le = trace.find('\n', pos);
-            a.largest_result_line = trace.substr(
-                ls, (le == std::string::npos ? trace.size() : le) - ls);
-          }
-        }
-        pos = end;
-      }
-      a.max_single_result_gb = double(best) / 1e9;
-    }
+    // ---- modeled cost via the single shared cost_profile() entry point ----
+    // Replaces the ad-hoc manual replay + working_set_hwmark read this case
+    // used before Task 5. cost_profile() builds the gated dry-run cache (Task
+    // 2: free-batchable-axis veto + footprint gate), replays zero-data through
+    // the real eval loop with the Task-3 scratch-fold PeakSink, forces the
+    // printing gate on internally, and folds the outer cached residency -- so
+    // peak_bytes captures the batched-inner transient the raw outer hwmark
+    // misses. The same CacheConfig the [cost_profile] test uses;
+    // is_batchable_index is set from `policy` inside cost_profile() (advisory
+    // here).
+    sequant::eval::dryrun::CacheConfig cfg;
+    cfg.max_footprint = 1e11;
+    cfg.min_repeats = 1;
+    cfg.is_volatile = [](EvalNodeDryRun const& n) {
+      if (!n.leaf() || !n->is_tensor()) return false;
+      return n->as_tensor().label() == L"t";
+    };
+    a.cp = sequant::eval::dryrun::cost_profile(
+        std::vector<EvalNodeDryRun>{node}, policy, cfg, regime,
+        /*trace=*/nullptr);
 
     wchar_t const* obj_name = (obj == ObjectiveFunction::DenseTimeSpaceBatched)
                                   ? L"perf-first (DenseTimeSpaceBatched)"
@@ -1664,11 +1623,9 @@ TEST_CASE("dryrun perf-first vs peak-first factorization of the C60 giant term",
     std::wcerr << L"[dryrun-perf] " << obj_name << L": optimize " << opt_ms
                << L"ms  max free-mu~ on a node=" << a.max_free_mu
                << L"  largest realized free-mu~={" << a.largest_desc << L"}="
-               << a.largest_realized_gb << L" GB\n               replay: cache "
-               << L"working_set_hwmark=" << a.hwmark_gb
-               << L" GB  largest single transient(result=)="
-               << a.max_single_result_gb << L" GB"
-               << (a.replay_threw ? L"  [replay threw]" : L"") << L"\n";
+               << a.largest_realized_gb << L" GB\n               cost_profile: "
+               << L"n_ops=" << a.cp.n_ops << L" flops=" << a.cp.flops
+               << L" peak_bytes=" << (a.cp.peak_bytes / 1e9) << L" GB\n";
     return a;
   };
 
@@ -1680,77 +1637,37 @@ TEST_CASE("dryrun perf-first vs peak-first factorization of the C60 giant term",
                << (a.max_free_mu >= 4 ? L"YES" : L"NO") << L" (max free mu~="
                << a.max_free_mu << L")\n    DP-model largest realized free-mu~="
                << a.largest_realized_gb << L" GB {" << a.largest_desc << L"}\n"
-               << L"    replay cache working_set_hwmark=" << a.hwmark_gb
-               << L" GB  largest single transient(result=)="
-               << a.max_single_result_gb << L" GB\n";
+               << L"    cost_profile: n_ops=" << a.cp.n_ops << L" flops="
+               << a.cp.flops << L" peak_bytes=" << (a.cp.peak_bytes / 1e9)
+               << L" GB\n";
   };
   std::wcerr << L"\n=== [dryrun-perf] VERDICT (C60 giant, index 38) ===\n";
   report(L"peak-first (DenseSpaceTimeBatched)", peak_first);
   report(L"perf-first (DenseTimeSpaceBatched)", perf_first);
-  // (b) The cache-vs-transient accounting gap: print the full trace line of the
-  // largest single materialized result for each objective. result= (the
-  // transient) and hw= (the cache watermark at that op) appear together, so a
-  // large result= with a small hw= means the transient is NOT folded into the
-  // cache high watermark (it is a streamed/batched result, never a cached
-  // co-resident entry) -- i.e. working_set_hwmark tracks CACHED residency, not
-  // the transient peak. The two together bound the true peak memory.
-  std::wcerr
-      << L"\n--- largest transient trace line (result= with its hw=) ---\n";
-  {
-    std::string const& pl = peak_first.largest_result_line;
-    std::string const& tl = perf_first.largest_result_line;
-    std::wcerr << L"peak-first: " << std::wstring(pl.begin(), pl.end()) << L"\n"
-               << L"perf-first: " << std::wstring(tl.begin(), tl.end())
-               << L"\n";
-  }
 
-  // INTERPRETATION -- why the outer working_set_hwmark is NOT the whole peak,
-  // and why the replay sizes are not directly comparable to the DP-model sizes:
-  //
-  // (1) Batched transients are invisible to the OUTER cache accessor. The
-  //     batched custom evaluator runs each batch against a SEPARATE scratch
-  //     cache (detail::make_batched_scratch, eval.hpp:1386), so the per-op hw=
-  //     field on the peak-first giant reaches ~38.9 GB (the 34 GB 4-PAO result
-  //     + operands) INSIDE that scratch, while the outer
-  //     cache.working_set_hwmark() reports only ~0.2 GB (outer-scope ops). So
-  //     the outer accessor tracks CACHED (persistent, cross-batch) residency,
-  //     not the batched-inner transient peak. Reading the whole peak requires
-  //     folding each scratch cache's hwmark into a global accumulator.
-  //
-  // (2) Twin-PNO composite Results are mis-sized by the runtime backend. The
-  //     perf-first largest transient = 358.47 GB = 120^2 * 42^4 * 8 EXACTLY
-  //     (occ^2 * PNO^4): the DryRun Result's size_in_bytes() sizes the
-  //     twin-PNO result R{a<i,i>,a<i,i>;i,i} as the naive product, NOT the
-  //     power-mean moment (occ^2 * PNO^2 ~ 89 GB) the DP cost model uses via
-  //     inner_pow. So the perf-first replay hwmark (~358 GB) is a sizing
-  //     artifact, ~4x the true ~89 GB; the DP-model realized size (89 GB) is
-  //     the trustworthy number. A faithful cached-watermark predictor needs the
-  //     runtime Result sizing to be moment-aware too.
-  //
-  // Bottom line: the moment-aware DP peak model is the reliable predictor
-  // today; the runtime replay hwmark is not, until (1) scratch hwmarks
-  // propagate and (2) the Result sizing is moment-aware.
-  std::wcerr
-      << L"\n--- INTERPRETATION ---\n"
-      << L"(1) peak-first outer hwmark (" << peak_first.hwmark_gb
-      << L" GB) << its batched-inner transient ("
-      << peak_first.max_single_result_gb
-      << L" GB, hw= inside a make_batched_scratch cache): the OUTER accessor "
-         L"misses batched transients.\n"
-      << L"(2) perf-first transient " << perf_first.max_single_result_gb
-      << L" GB = 120^2*42^4*8 (occ^2*PNO^4) = the twin-PNO size_in_bytes() "
-         L"artifact; the moment-aware DP size ("
-      << perf_first.largest_realized_gb
-      << L" GB) is the real number. Runtime Result sizing is NOT "
-         L"moment-aware.\n"
-      << L"=> DP-model peak is the reliable predictor; the replay hwmark is "
-         L"not "
-         L"(yet).\n";
-
-  // Peak-first forms the fully-sliceable 4-PAO AO integral (the C60 pathology).
+  // STRUCTURAL PROOF (the direct in-harness proof of the fix), read from the
+  // static tree walk above -- NOT from the cost_profile replay: peak-first
+  // forms the fully-sliceable 4-PAO AO integral (the C60 pathology),
+  // perf-first, being flops-primary, must NEVER form it. Kept as a plain
+  // tree-walk check because the free-mu~ signature is a property of the
+  // FACTORIZATION the DP picked, not of the peak replay; cost_profile() models
+  // cost, it does not expose per-node free-index structure.
   CHECK(peak_first.max_free_mu >= 4);
-  // Perf-first, being flops-primary, must never form it.
   CHECK(perf_first.max_free_mu < 4);
+
+  // COST PROOF via the single shared cost_profile() entry point.
+  // (a) perf-first is flops-primary: it must not pick a higher-flops
+  //     factorization than peak-first.
+  CHECK(perf_first.cp.flops <= peak_first.cp.flops);
+  // (b) perf-first's modeled peak lands in a realistic band for this
+  //     constant-moment C60 giant. Observed perf peak_bytes ~= 358 GB (the
+  //     4-PNO twin-composite W the perf-first schedule forms: 120^2*42^4*8,
+  //     the naive-product size_in_bytes() of R{a<i,i>,a<i,i>;i,i}). A
+  //     100 GB..1 TB band brackets it with comfortable margin and is
+  //     non-flaky. NOTE: with real heavy-tailed PNO moments (not the constant
+  //     moments this regime uses) this rises further.
+  CHECK(perf_first.cp.peak_bytes < 1e12);
+  CHECK(perf_first.cp.peak_bytes > 1e11);
 }
 
 // Task 3: the opt-in scratch-fold peak sink captures the batched-inner peak the
@@ -2008,6 +1925,114 @@ TEST_CASE("cost_profile returns peak/flops/exec/n_ops",
   CHECK(cp.peak_bytes == Catch::Approx(expected_peak).epsilon(1e-9));
 }
 
+// Task 5 (Minor b): cover the UTF-8 -> wide bridge cost_profile() uses to fill
+// a caller's wide trace stream. The eval loop writes a NARROW (UTF-8) trace
+// whose per-op label field carries multi-byte index labels (mu~ = U+03BC
+// U+0303, aux = U+039A). cost_profile transcodes that narrow buffer into the
+// wide sink by decoding UTF-8 code points (a plain widen() would mojibake the
+// labels). This runs cost_profile on the single C60 giant with a real
+// std::wostringstream and asserts the wide output is non-empty and contains a
+// token the eval trace emits -- both an ASCII field (`result=`) and a
+// multi-byte index label (mu~), so the code-point decode path (not just the
+// ASCII path) is exercised.
+TEST_CASE("cost_profile trace stream round-trips", "[dryrun][cost_profile]") {
+  using sequant::eval::dryrun::CacheConfig;
+  using sequant::eval::dryrun::cost_profile;
+  using sequant::eval::dryrun::CostProfile;
+
+  auto ctx = get_default_context().clone();
+  ctx.set_first_dummy_index_ordinal(1000000);
+  auto isr = ctx.mutable_index_space_registry();
+  REQUIRE(isr != nullptr);
+  sequant::mbpt::add_pao_spaces(isr);  // mu~
+  sequant::mbpt::add_df_spaces(isr);   // K
+  auto ctx_resetter = set_scoped_default_context(std::move(ctx));
+
+  auto const body = slurp(std::string(SEQUANT_UNIT_TESTS_SOURCE_DIR) +
+                          "/data/csv_ccsd_doubles_residual_df.txt");
+  REQUIRE(!body.empty());
+  std::string line = body;
+  if (auto nl = line.find('\n'); nl != std::string::npos)
+    line = line.substr(0, nl);
+  auto expr = deserialize<ExprPtr>(line);
+  REQUIRE(static_cast<bool>(expr));
+  REQUIRE(expr->is<Sum>());
+  auto const& summands = expr->as<Sum>().summands();
+  REQUIRE(!summands.empty());
+  auto flatten_product = [](ExprPtr const& e) -> ExprPtr {
+    if (!e->is<Product>()) return e;
+    auto const& p = e->as<Product>();
+    return ex<Product>(p.scalar(), p.factors(), Product::Flatten::Yes);
+  };
+  std::size_t const giant_idx = 38 < summands.size() ? 38 : 0;
+  ExprPtr giant = flatten_product(summands[giant_idx]);
+  REQUIRE(giant);
+
+  auto regime = df_regime(1800u, 4320u, 120u, 42.0, 310.0);
+
+  sequant::BatchPolicy policy;
+  policy.is_batchable_index = is_df_batchable;
+  policy.batch_target_size = [](Index const& ix) -> std::size_t {
+    return ix.space().base_key() == L"μ̃" ? std::size_t{256} : std::size_t{72};
+  };
+  policy.is_volatile_leaf = [](Tensor const& t) { return t.label() == L"t"; };
+  policy.accumulation_factor = 1.0;
+  policy.peak_threshold = 40e9;
+
+  auto axes_map = std::make_shared<std::unordered_map<
+      Expr const*, container::vector<container::svector<Index>>>>();
+  OptimizeOptions opts;
+  opts.objective_function = ObjectiveFunction::DenseSpaceTimeBatched;
+  opts.idx_to_extent = regime.idx_to_extent();
+  opts.inner_pow = regime.inner_pow_fn();
+  opts.batch_policy = policy;
+  opts.volatile_weight = 20.0;
+  opts.roofline.machine_balance = 200.0;
+  opts.roofline.fast_mem_elems = 1000000.0;
+  opts.term_batch_axes = axes_map;
+
+  auto optimized = optimize(giant, opts);
+  REQUIRE(static_cast<bool>(optimized));
+  auto it = axes_map->find(optimized.get());
+  container::vector<container::svector<Index>> node_axes;
+  if (it != axes_map->end()) node_axes = it->second;
+  BinarizationOptions bopts;
+  bopts.node_batch_axes = node_axes;
+  SEQUANT_PRAGMA_IGNORE_DEPRECATED_BEGIN
+  auto node = binarize<EvalExprDryRun>(optimized, {}, bopts);
+  SEQUANT_PRAGMA_IGNORE_DEPRECATED_END
+
+  std::vector<EvalNodeDryRun> forest{node};
+
+  CacheConfig cfg;
+  cfg.max_footprint = 1e11;
+  cfg.min_repeats = 1;
+  cfg.is_volatile = [](EvalNodeDryRun const& n) {
+    if (!n.leaf() || !n->is_tensor()) return false;
+    return n->as_tensor().label() == L"t";
+  };
+
+  // Real wide sink: exercise the UTF-8 -> wide transcode.
+  std::wostringstream trace;
+  CostProfile const cp = cost_profile(forest, policy, cfg, regime, &trace);
+
+  std::wstring const w = trace.str();
+  if (std::getenv("DRYRUN_DUMP_TRACE"))
+    std::wcerr << L"[round-trip] first 600 wide chars:\n"
+               << w.substr(0, std::min<std::size_t>(600, w.size())) << L"\n";
+
+  CHECK(std::isfinite(cp.peak_bytes));
+  CHECK(cp.peak_bytes > 0.0);
+  // Non-empty wide output.
+  CHECK(!w.empty());
+  // ASCII field the eval trace always emits (exercises the 1-byte decode path).
+  CHECK(w.find(L"result=") != std::wstring::npos);
+  // Multi-byte index label in an op's label field (exercises the multi-byte
+  // code-point decode path -- the whole point of the transcode). mu~ =
+  // U+03BC U+0303; a plain widen() of the UTF-8 bytes would NOT produce it.
+  CHECK(w.find(L"μ̃") != std::wstring::npos);
+}
+
 // Task 2: the FAITHFUL (gated) dry-run cache built by build_dryrun_cache must
 // VETO caching of a free-batchable giant -- a node whose result carries a free
 // mu~/K axis the runtime slices over -- exactly as the real batched eval loop
@@ -2257,7 +2282,6 @@ TEST_CASE("dryrun whole-residual trace (PNO-CCSD doubles)",
 
   // FAITHFUL real C60 config (614336 job log), identical to [dryrun-eval].
   auto regime = df_regime(1800u, 4320u, 120u, 42.0, 310.0);
-  auto cm = std::make_shared<CostModel const>(regime);
   sequant::BatchPolicy policy;
   policy.is_batchable_index = is_df_batchable;
   policy.batch_target_size = [](Index const& ix) -> std::size_t {
@@ -2303,50 +2327,74 @@ TEST_CASE("dryrun whole-residual trace (PNO-CCSD doubles)",
   }
   REQUIRE(!nodes.empty());
 
-  // Phase 2: one shared cache over ALL trees (cross-term CSE), the real batched
-  // evaluator, trace -> file. The cache is NOT reset between summands, so
-  // working_set_hwmark() reflects cross-term cached residency (subject to the
-  // [dryrun-perf] caveats: batched-inner transients and twin-PNO sizing).
-  auto cache = sequant::cache_manager(nodes);
-  cache.set_custom_evaluator(
-      sequant::make_evaluator(policy, DryRunLeafEvaluator{cm}));
+  // Phase 2: route the whole-residual forest through the single shared
+  // cost_profile() entry point (Task 4/5) -- replacing the ad-hoc
+  // cache_manager(nodes) + manual per-summand replay + logger juggling this
+  // case used before Task 5. cost_profile() builds the gated dry-run cache,
+  // forces the printing gate on, replays every summand (resetting per-term
+  // non-persistent scratch while keeping persistent cross-term CSE entries),
+  // folds the batched-scratch peak, and transcodes the narrow (UTF-8) eval
+  // trace into the requested wide trace stream. We point that stream at a FILE.
+  sequant::eval::dryrun::CacheConfig cfg;
+  cfg.max_footprint = 1e11;  // faithful footprint gate
+  cfg.min_repeats = 2;       // real CSE rule (cache only 2+ repeats)
+  cfg.is_volatile = [](EvalNodeDryRun const& n) {
+    if (!n.leaf() || !n->is_tensor()) return false;
+    return n->as_tensor().label() == L"t";
+  };
 
   char const* const file_env = std::getenv("DRYRUN_TRACE_FILE");
   std::string const trace_path =
       file_env ? file_env : "/tmp/dryrun_residual_trace.txt";
-  std::ofstream trace_file(trace_path);
-  REQUIRE(trace_file.is_open());
-  auto& logger = Logger::instance();
-  auto const prev_level = logger.eval.level;
-  auto* const prev_stream = logger.eval.stream;
-  logger.eval.level = 2;  // gate log::printing() on
-  logger.eval.stream = &trace_file;
-
-  std::size_t n_ok = 0;
-  for (std::size_t i = 0; i < nodes.size(); ++i) {
-    try {
-      (void)sequant::evaluate<Trace::On>(nodes[i], DryRunLeafEvaluator{cm},
-                                         cache);
-      ++n_ok;
-    } catch (std::exception const& e) {
-      trace_file << "  [summand " << i << " threw: " << e.what() << "]\n";
+
+  // Capture the wide trace, then re-encode it to UTF-8 bytes for the file
+  // (a raw std::wofstream would re-narrow the multi-byte index labels via the
+  // classic-locale codecvt and mangle/truncate them).
+  std::wostringstream trace_capture;
+  sequant::eval::dryrun::CostProfile const cp =
+      sequant::eval::dryrun::cost_profile(nodes, policy, cfg, regime,
+                                          &trace_capture);
+
+  std::wstring const wtrace = trace_capture.str();
+  std::string utf8;
+  utf8.reserve(wtrace.size());
+  for (wchar_t const wc : wtrace) {
+    char32_t const cp32 = static_cast<char32_t>(wc);
+    if (cp32 < 0x80) {
+      utf8.push_back(static_cast<char>(cp32));
+    } else if (cp32 < 0x800) {
+      utf8.push_back(static_cast<char>(0xC0 | (cp32 >> 6)));
+      utf8.push_back(static_cast<char>(0x80 | (cp32 & 0x3F)));
+    } else if (cp32 < 0x10000) {
+      utf8.push_back(static_cast<char>(0xE0 | (cp32 >> 12)));
+      utf8.push_back(static_cast<char>(0x80 | ((cp32 >> 6) & 0x3F)));
+      utf8.push_back(static_cast<char>(0x80 | (cp32 & 0x3F)));
+    } else {
+      utf8.push_back(static_cast<char>(0xF0 | (cp32 >> 18)));
+      utf8.push_back(static_cast<char>(0x80 | ((cp32 >> 12) & 0x3F)));
+      utf8.push_back(static_cast<char>(0x80 | ((cp32 >> 6) & 0x3F)));
+      utf8.push_back(static_cast<char>(0x80 | (cp32 & 0x3F)));
     }
   }
-
-  logger.eval.level = prev_level;
-  logger.eval.stream = prev_stream;
-  trace_file.flush();
-  auto const hwmark_gb = double(cache.working_set_hwmark()) / 1e9;
+  {
+    std::ofstream trace_file(trace_path, std::ios::binary);
+    REQUIRE(trace_file.is_open());
+    trace_file.write(utf8.data(), static_cast<std::streamsize>(utf8.size()));
+  }
+  std::size_t const trace_bytes = utf8.size();
 
   std::wcerr << L"\n=== [dryrun-trace] whole-residual trace written ===\n"
              << L"objective    = "
              << (obj == ObjectiveFunction::DenseTimeSpaceBatched
                      ? L"dense_time_space (perf-first)"
                      : L"dense_space_time (peak-first)")
-             << L"\nsummands     = " << n_ok << L"/" << nodes.size()
-             << L" evaluated\ncache hwmark = " << hwmark_gb
-             << L" GB (cross-term cached residency; see [dryrun-perf] caveats)"
-             << L"\ntrace file   = "
-             << std::wstring(trace_path.begin(), trace_path.end()) << L"\n";
-  SUCCEED();
+             << L"\nsummands     = " << nodes.size() << L" optimized"
+             << L"\nn_ops        = " << cp.n_ops << L"  peak_bytes="
+             << (cp.peak_bytes / 1e9) << L" GB" << L"\ntrace file   = "
+             << std::wstring(trace_path.begin(), trace_path.end()) << L" ("
+             << trace_bytes << L" bytes)\n";
+
+  CHECK(std::isfinite(cp.peak_bytes));
+  CHECK(cp.peak_bytes > 0.0);
+  CHECK(trace_bytes > 0);
 }

From 0102390d43c89ba997107065af87bb7c0919c4b4 Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Sun, 5 Jul 2026 13:28:14 -0400
Subject: [PATCH 38/78] dryrun: correct [dryrun-perf] peak comment to the
 tree-proven 4-PNO W

The 387 GB perf-first peak is the genuine 4-PNO CC doubles W node
{a1<i,i>..a4<i,i>} (four distinct PNO legs, verified via DRYRUN_PERF_TREE),
correctly sized occ^2*M_4^4 with df_regime power means. It is NOT a
naive-product artifact nor a mis-sized twin R (which would be occ^2*M_2^2
~0.2 GB). Kappa is contracted at this node so batching cannot shrink it.
---
 tests/unit/test_eval_dryrun.cpp | 20 ++++++++++++++------
 1 file changed, 14 insertions(+), 6 deletions(-)

diff --git a/tests/unit/test_eval_dryrun.cpp b/tests/unit/test_eval_dryrun.cpp
index 82ff9eed3f..652c5cd780 100644
--- a/tests/unit/test_eval_dryrun.cpp
+++ b/tests/unit/test_eval_dryrun.cpp
@@ -1660,12 +1660,20 @@ TEST_CASE("dryrun perf-first vs peak-first factorization of the C60 giant term",
   //     factorization than peak-first.
   CHECK(perf_first.cp.flops <= peak_first.cp.flops);
   // (b) perf-first's modeled peak lands in a realistic band for this
-  //     constant-moment C60 giant. Observed perf peak_bytes ~= 358 GB (the
-  //     4-PNO twin-composite W the perf-first schedule forms: 120^2*42^4*8,
-  //     the naive-product size_in_bytes() of R{a<i,i>,a<i,i>;i,i}). A
-  //     100 GB..1 TB band brackets it with comfortable margin and is
-  //     non-flaky. NOTE: with real heavy-tailed PNO moments (not the constant
-  //     moments this regime uses) this rises further.
+  //     constant-moment C60 giant. Observed perf peak_bytes ~= 387 GB,
+  //     dominated by the GENUINE 4-PNO intermediate the perf-first schedule
+  //     forms -- the CC doubles W node {a_1<i,i> a_2<i,i> a_3<i,i> a_4<i,i>}
+  //     with FOUR distinct PNO legs over one occ-pair (see DRYRUN_PERF_TREE
+  //     dump), sized occ^2 * M_4^4 = 120^2*42^4*8 = 358 GB (+ co-resident).
+  //     This is the CORRECT, moment-aware size (df_regime's csv_pno_moment[k]
+  //     are power means), NOT a naive-product artifact and NOT a mis-sized
+  //     twin R{a<i,i>,a<i,i>}: the sizing was made moment-aware and the twin
+  //     would be occ^2*M_2^2 ~= 0.2 GB. The Kappa axis is CONTRACTED at this
+  //     node, so batching cannot shrink the W (irreducible peak floor of the
+  //     flop-optimal factorization). A 100 GB..1 TB band brackets it with
+  //     comfortable margin and is non-flaky. NOTE: with real heavy-tailed PNO
+  //     moments (M_4 > 42) this rises further -- the OOM question Tasks 6-8
+  //     quantify for C60.
   CHECK(perf_first.cp.peak_bytes < 1e12);
   CHECK(perf_first.cp.peak_bytes > 1e11);
 }

From 4f5ca615de11ae516da6ad34c9650e95de769871 Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Sun, 5 Jul 2026 13:39:19 -0400
Subject: [PATCH 39/78] dryrun: RAII logger restore in cost_profile +
 peak/threading doc caveats

cost_profile() saved/overwrote the global Logger::instance().eval state
around the replay loop and only restored it via two trailing assignments,
so an exception from anywhere in the loop other than evaluate<Trace::On>
(e.g. bad_alloc from make_evaluator/set_custom_evaluator/reset) would
unwind past the local trace_capture stream, leaving logger.eval.stream
dangling with level=2 still set. Replace the manual restore with an RAII
guard whose destructor always runs the restore, regardless of exit path.

Also document: CostProfile::peak_bytes is a max (not a sum) of
batched-inner scratch vs. outer cross-term residency, so it is a lower
bound when both co-reside; flops/exec_cost are summed per node and are
not CSE-aware across summands; cost_profile() mutates the global Logger
singleton and must be called single-threaded; and make_evaluator's peak
sink is the 4th positional argument, after the scope-guard factory.
---
 .../eval/backends/dryrun/cost_profile.hpp     | 58 +++++++++++++++++--
 SeQuant/core/eval/eval.hpp                    |  7 +++
 2 files changed, 60 insertions(+), 5 deletions(-)

diff --git a/SeQuant/core/eval/backends/dryrun/cost_profile.hpp b/SeQuant/core/eval/backends/dryrun/cost_profile.hpp
index d2469f9c3b..a19dbf4112 100644
--- a/SeQuant/core/eval/backends/dryrun/cost_profile.hpp
+++ b/SeQuant/core/eval/backends/dryrun/cost_profile.hpp
@@ -117,10 +117,22 @@ struct CostProfile {
   /// Predicted peak working-set (bytes): the max over summands of the
   /// batched-scratch high-watermark folded by the Task-3 \c PeakSink and the
   /// outer gated cache's \c working_set_hwmark().
+  ///
+  /// This is computed as \c max(batched-inner scratch high-watermark,
+  /// outer cross-term cached residency), NOT their sum. When a persistent
+  /// cross-term cache entry co-resides in memory with a batched-inner
+  /// transient at the same instant, the two are actually additive, so this
+  /// value is a LOWER BOUND on the true peak in that case. It is exact
+  /// whenever one of the two terms dominates the other (e.g. the C60 4-PNO
+  /// \c W case, where the batched-inner scratch dwarfs any persistent
+  /// cross-term residency).
   double peak_bytes = 0;
   /// Summed unweighted static contraction FLOPs over all internal nodes.
+  /// NOT CSE-aware across summands: a cross-term shared intermediate is
+  /// walked (and its FLOPs counted) once per occurrence, not once overall.
   double flops = 0;
-  /// Summed roofline-projected execution cost over all internal nodes.
+  /// Summed roofline-projected execution cost over all internal nodes. Same
+  /// per-occurrence (not CSE-deduplicated) accounting caveat as \c flops.
   double exec_cost = 0;
   /// Number of internal (contraction) nodes across the forest.
   std::size_t n_ops = 0;
@@ -140,6 +152,24 @@ struct CostProfile {
 /// \p trace is requested -- and restores the previous logger state afterward,
 /// so \c peak_bytes is non-zero even with no trace stream.
 ///
+/// \par Global state / threading
+/// This routine mutates the process-global \c Logger::instance().eval state
+/// (\c level and \c stream) for the duration of the replay (restored on every
+/// exit path, including exceptions). Because that state is a singleton shared
+/// by the whole process, \c cost_profile() MUST be called single-threaded --
+/// e.g. as a pre-flight step before, or a post-hoc step after, the real
+/// multi-threaded eval -- never concurrently with other code that reads or
+/// writes \c Logger::instance().eval (including another concurrent
+/// \c cost_profile() call).
+///
+/// \par FLOPs / exec_cost accounting
+/// \c CostProfile::flops and \c CostProfile::exec_cost are accumulated by a
+/// static walk that sums a contribution per BINARIZED internal node of the
+/// forest; they are NOT CSE-aware across summands. A shared intermediate
+/// that recurs across multiple summand trees (or multiple times within one)
+/// is counted once per occurrence, not once overall -- unlike \c peak_bytes,
+/// which is driven by the gated cache and so does reflect cross-term reuse.
+///
 /// \param forest per-summand optimized+binarized eval forest (the real IR).
 /// \param policy the batch policy driving the replay evaluator; its
 ///        \c is_batchable_index is COPIED over \c cfg.is_batchable_index
@@ -194,8 +224,26 @@ inline CostProfile cost_profile(std::vector<EvalNodeDryRun> const& forest,
   auto cache = build_dryrun_cache(forest, local_cfg, regime);
 
   auto& logger = Logger::instance();
-  auto const prev_level = logger.eval.level;
-  auto* const prev_stream = logger.eval.stream;
+  // RAII guard restoring the process-global Logger::eval state on EVERY exit
+  // path from this point on -- normal return, early return, or an exception
+  // unwinding out of the replay loop below -- not just the two trailing
+  // assignments a plain save/restore would rely on. Without this, a throw
+  // from anything in the loop OTHER than evaluate<Trace::On> (e.g.
+  // std::bad_alloc from make_evaluator/set_custom_evaluator/
+  // working_set_hwmark/cache.reset()) would unwind past the local
+  // `trace_capture` destructor while `logger.eval.stream` still points at it,
+  // leaving a dangling pointer in the process-global singleton with
+  // level == 2 still set.
+  struct LoggerEvalGuard {
+    decltype(logger.eval)& eval;
+    std::size_t const prev_level;
+    std::ostream* const prev_stream;
+    ~LoggerEvalGuard() {
+      eval.level = prev_level;
+      eval.stream = prev_stream;
+    }
+  } logger_eval_guard{logger.eval, logger.eval.level, logger.eval.stream};
+
   // Force printing() on so working_set_hwmark() accumulates. The eval logger
   // stream is narrow; capture into a narrow buffer only when a (wide) trace
   // sink was requested, else discard to a null stream.
@@ -220,8 +268,8 @@ inline CostProfile cost_profile(std::vector<EvalNodeDryRun> const& forest,
     cache.reset();  // drop per-term non-persistent scratch; keep persistent
   }
 
-  logger.eval.level = prev_level;
-  logger.eval.stream = prev_stream;
+  // logger_eval_guard's destructor restores logger.eval.{level,stream} at
+  // function exit (see above); no manual restore needed here.
 
   // If a wide trace sink was requested, transcode the captured narrow (UTF-8)
   // eval trace into it (the eval loop writes only to the narrow logger stream;
diff --git a/SeQuant/core/eval/eval.hpp b/SeQuant/core/eval/eval.hpp
index 8eec1d93a2..4d8fcdcb87 100644
--- a/SeQuant/core/eval/eval.hpp
+++ b/SeQuant/core/eval/eval.hpp
@@ -1491,6 +1491,13 @@ template <typename F, typename IndexPredicate = accept_any_index,
 ///        make_batched_custom_evaluator; defaults to make_no_scope_guard).
 /// \param peak      Optional PeakSink (same semantics as in
 ///        make_batched_custom_evaluator); defaults to null (no folding).
+///        NOTE: \p peak is the 4th positional argument, AFTER \p
+///        make_scope_guard -- a caller who wants the sink but not a custom
+///        scope guard must still pass the scope-guard factory explicitly
+///        (e.g. `make_evaluator(policy, leaf, make_no_scope_guard{},
+///        &sink)`); passing `&sink` in the 3rd slot silently binds it to
+///        \p make_scope_guard (via template deduction) and leaves \p peak
+///        null.
 template <class F, class ScopeGuardFactory = make_no_scope_guard>
 [[nodiscard]] auto make_evaluator(BatchPolicy const& policy, F yielder,
                                   ScopeGuardFactory make_scope_guard = {},

From 49d1c406179241242b138927434c8ce5a2736f82 Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Sun, 5 Jul 2026 14:13:19 -0400
Subject: [PATCH 40/78] dryrun: namespace test env vars DRYRUN_* ->
 SEQUANT_UT_DRYRUN_*

---
 tests/unit/test_eval_dryrun.cpp | 74 +++++++++++++++++----------------
 1 file changed, 38 insertions(+), 36 deletions(-)

diff --git a/tests/unit/test_eval_dryrun.cpp b/tests/unit/test_eval_dryrun.cpp
index 652c5cd780..7997660463 100644
--- a/tests/unit/test_eval_dryrun.cpp
+++ b/tests/unit/test_eval_dryrun.cpp
@@ -667,9 +667,10 @@ TEST_CASE("dryrun POST-transform PAO/K batch-axis verdict", "[dryrun-df]") {
   // mu~/K batch axis.
   double const peak_threshold = 40e9;  // 40 GB, matches the C60 run
   // Env overrides for the root-cause BISECT (default = faithful real C60
-  // config). DRYRUN_OCC/PNO/OSV vary extents; DRYRUN_PAO_TS/AUX_TS vary batch
-  // target sizes; DRYRUN_VW varies volatile_weight; DRYRUN_ROOFLINE=0 disables
-  // the roofline tie-break. Absent env var => real-config default.
+  // config). SEQUANT_UT_DRYRUN_OCC/PNO/OSV vary extents;
+  // SEQUANT_UT_DRYRUN_PAO_TS/AUX_TS vary batch target sizes;
+  // SEQUANT_UT_DRYRUN_VW varies volatile_weight; SEQUANT_UT_DRYRUN_ROOFLINE=0
+  // disables the roofline tie-break. Absent env var => real-config default.
   auto env_d = [](char const* k, double dflt) {
     char const* v = std::getenv(k);
     return v ? std::atof(v) : dflt;
@@ -678,18 +679,18 @@ TEST_CASE("dryrun POST-transform PAO/K batch-axis verdict", "[dryrun-df]") {
     char const* v = std::getenv(k);
     return v ? static_cast<std::size_t>(std::atoll(v)) : dflt;
   };
-  std::size_t const occ_ext = env_u("DRYRUN_OCC", 120u);
-  double const pno_mom = env_d("DRYRUN_PNO", 42.0);
-  double const osv_mom = env_d("DRYRUN_OSV", 310.0);
-  std::size_t const pao_ts = env_u("DRYRUN_PAO_TS", 256u);
-  std::size_t const aux_ts = env_u("DRYRUN_AUX_TS", 72u);
-  double const vol_weight = env_d("DRYRUN_VW", 20.0);
-  bool const use_roofline = env_u("DRYRUN_ROOFLINE", 1u) != 0;
-  // DRYRUN_AUX_ONLY=1 makes ONLY the DF aux (K) sliceable, NOT PAO (mu~) --
-  // reproduces MPQC's aux-only batching to check the proper (gC)^2 PPL
+  std::size_t const occ_ext = env_u("SEQUANT_UT_DRYRUN_OCC", 120u);
+  double const pno_mom = env_d("SEQUANT_UT_DRYRUN_PNO", 42.0);
+  double const osv_mom = env_d("SEQUANT_UT_DRYRUN_OSV", 310.0);
+  std::size_t const pao_ts = env_u("SEQUANT_UT_DRYRUN_PAO_TS", 256u);
+  std::size_t const aux_ts = env_u("SEQUANT_UT_DRYRUN_AUX_TS", 72u);
+  double const vol_weight = env_d("SEQUANT_UT_DRYRUN_VW", 20.0);
+  bool const use_roofline = env_u("SEQUANT_UT_DRYRUN_ROOFLINE", 1u) != 0;
+  // SEQUANT_UT_DRYRUN_AUX_ONLY=1 makes ONLY the DF aux (K) sliceable, NOT PAO
+  // (mu~) -- reproduces MPQC's aux-only batching to check the proper (gC)^2 PPL
   // factorization keeps the mu~-full giant (large realized peak = OOM) and
   // does NOT form the fully-sliceable 4-PAO integral.
-  bool const aux_only = env_u("DRYRUN_AUX_ONLY", 0u) != 0;
+  bool const aux_only = env_u("SEQUANT_UT_DRYRUN_AUX_ONLY", 0u) != 0;
   auto is_batchable = [aux_only](Index const& ix) {
     auto const k = ix.space().base_key();
     return aux_only ? (k == L"Κ") : (k == L"μ̃" || k == L"Κ");
@@ -1529,10 +1530,11 @@ TEST_CASE("dryrun perf-first vs peak-first factorization of the C60 giant term",
     auto node = binarize<EvalExprDryRun>(optimized, {}, bopts);
     SEQUANT_PRAGMA_IGNORE_DEPRECATED_END
 
-    // Optional full-tree dump (DRYRUN_PERF_TREE=1): every node's free indices
-    // and batch_axes (the indices SLICED, i.e. batched, at that node), in
-    // post-order-ish indentation, so the exact schedule is inspectable.
-    if (std::getenv("DRYRUN_PERF_TREE")) {
+    // Optional full-tree dump (SEQUANT_UT_DRYRUN_PERF_TREE=1): every node's
+    // free indices and batch_axes (the indices SLICED, i.e. batched, at that
+    // node), in post-order-ish indentation, so the exact schedule is
+    // inspectable.
+    if (std::getenv("SEQUANT_UT_DRYRUN_PERF_TREE")) {
       wchar_t const* on = (obj == ObjectiveFunction::DenseTimeSpaceBatched)
                               ? L"perf-first (DenseTimeSpaceBatched)"
                               : L"peak-first (DenseSpaceTimeBatched)";
@@ -1663,17 +1665,17 @@ TEST_CASE("dryrun perf-first vs peak-first factorization of the C60 giant term",
   //     constant-moment C60 giant. Observed perf peak_bytes ~= 387 GB,
   //     dominated by the GENUINE 4-PNO intermediate the perf-first schedule
   //     forms -- the CC doubles W node {a_1<i,i> a_2<i,i> a_3<i,i> a_4<i,i>}
-  //     with FOUR distinct PNO legs over one occ-pair (see DRYRUN_PERF_TREE
-  //     dump), sized occ^2 * M_4^4 = 120^2*42^4*8 = 358 GB (+ co-resident).
-  //     This is the CORRECT, moment-aware size (df_regime's csv_pno_moment[k]
-  //     are power means), NOT a naive-product artifact and NOT a mis-sized
-  //     twin R{a<i,i>,a<i,i>}: the sizing was made moment-aware and the twin
-  //     would be occ^2*M_2^2 ~= 0.2 GB. The Kappa axis is CONTRACTED at this
-  //     node, so batching cannot shrink the W (irreducible peak floor of the
-  //     flop-optimal factorization). A 100 GB..1 TB band brackets it with
-  //     comfortable margin and is non-flaky. NOTE: with real heavy-tailed PNO
-  //     moments (M_4 > 42) this rises further -- the OOM question Tasks 6-8
-  //     quantify for C60.
+  //     with FOUR distinct PNO legs over one occ-pair (see
+  //     SEQUANT_UT_DRYRUN_PERF_TREE dump), sized occ^2 * M_4^4 = 120^2*42^4*8 =
+  //     358 GB (+ co-resident). This is the CORRECT, moment-aware size
+  //     (df_regime's csv_pno_moment[k] are power means), NOT a naive-product
+  //     artifact and NOT a mis-sized twin R{a<i,i>,a<i,i>}: the sizing was made
+  //     moment-aware and the twin would be occ^2*M_2^2 ~= 0.2 GB. The Kappa
+  //     axis is CONTRACTED at this node, so batching cannot shrink the W
+  //     (irreducible peak floor of the flop-optimal factorization). A 100 GB..1
+  //     TB band brackets it with comfortable margin and is non-flaky. NOTE:
+  //     with real heavy-tailed PNO moments (M_4 > 42) this rises further -- the
+  //     OOM question Tasks 6-8 quantify for C60.
   CHECK(perf_first.cp.peak_bytes < 1e12);
   CHECK(perf_first.cp.peak_bytes > 1e11);
 }
@@ -2025,7 +2027,7 @@ TEST_CASE("cost_profile trace stream round-trips", "[dryrun][cost_profile]") {
   CostProfile const cp = cost_profile(forest, policy, cfg, regime, &trace);
 
   std::wstring const w = trace.str();
-  if (std::getenv("DRYRUN_DUMP_TRACE"))
+  if (std::getenv("SEQUANT_UT_DRYRUN_DUMP_TRACE"))
     std::wcerr << L"[round-trip] first 600 wide chars:\n"
                << w.substr(0, std::min<std::size_t>(600, w.size())) << L"\n";
 
@@ -2242,10 +2244,10 @@ TEST_CASE("dryrun gated cache vetoes free-batchable giant", "[dryrun][cache]") {
 // select it explicitly:
 //   ./unit_tests-sequant "[dryrun-trace]"
 // Env knobs (all optional):
-//   DRYRUN_OBJ         dense_time_space (default, perf-first) |
-//   dense_space_time DRYRUN_TRACE_FILE  output path (default
-//   /tmp/dryrun_residual_trace.txt) DRYRUN_MAX_TERMS   cap #summands (default 0
-//   = all) -- for a quick smoke run
+//   SEQUANT_UT_DRYRUN_OBJ         dense_time_space (default, perf-first) |
+//   dense_space_time SEQUANT_UT_DRYRUN_TRACE_FILE  output path (default
+//   /tmp/dryrun_residual_trace.txt) SEQUANT_UT_DRYRUN_MAX_TERMS   cap #summands
+//   (default 0 = all) -- for a quick smoke run
 TEST_CASE("dryrun whole-residual trace (PNO-CCSD doubles)",
           "[.][dryrun-trace]") {
   auto ctx = get_default_context().clone();
@@ -2276,13 +2278,13 @@ TEST_CASE("dryrun whole-residual trace (PNO-CCSD doubles)",
   REQUIRE(!terms.empty());
 
   // Objective (perf-first default; dense_space_time / dense_peak_size = peak).
-  char const* const obj_env = std::getenv("DRYRUN_OBJ");
+  char const* const obj_env = std::getenv("SEQUANT_UT_DRYRUN_OBJ");
   std::string const obj_s = obj_env ? obj_env : "dense_time_space";
   ObjectiveFunction const obj =
       (obj_s == "dense_space_time" || obj_s == "dense_peak_size")
           ? ObjectiveFunction::DenseSpaceTimeBatched
           : ObjectiveFunction::DenseTimeSpaceBatched;
-  char const* const max_env = std::getenv("DRYRUN_MAX_TERMS");
+  char const* const max_env = std::getenv("SEQUANT_UT_DRYRUN_MAX_TERMS");
   std::size_t const max_terms =
       max_env ? static_cast<std::size_t>(std::atoll(max_env)) : 0u;
   std::size_t const n_terms =
@@ -2351,7 +2353,7 @@ TEST_CASE("dryrun whole-residual trace (PNO-CCSD doubles)",
     return n->as_tensor().label() == L"t";
   };
 
-  char const* const file_env = std::getenv("DRYRUN_TRACE_FILE");
+  char const* const file_env = std::getenv("SEQUANT_UT_DRYRUN_TRACE_FILE");
   std::string const trace_path =
       file_env ? file_env : "/tmp/dryrun_residual_trace.txt";
 

From 059b82af1f830de7a6490b35eee91cc9ac6773f0 Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Mon, 6 Jul 2026 00:08:34 -0400
Subject: [PATCH 41/78] dryrun: rank-general CSV moment dispatch in SizeRegime

SizeRegime::inner_pow selected the PNO (rank-2) table for every proto-rank >= 2,
so a CSV-CCSDT rank-3 (triple) composite would be sized by the pair domain. Add
a csv_moment_by_rank map keyed by cluster rank (= number of proto indices) for
ranks >= 3; inner_pow now dispatches rank 1 -> OSV, rank 2 -> PNO, rank >= 3 ->
its own table if present, else falling back to the PNO table (preserving the
prior behavior). Ranks 1 and 2 keep their named arrays (csv_osv_moment /
csv_pno_moment), so existing SizeRegime consumers are unchanged.

Test: new "dryrun rank-general CSV moment dispatch" pins per-rank selection and
the rank-2 fallback for an unmeasured rank. Full [dryrun] suite passes.
---
 .../core/eval/backends/dryrun/size_regime.hpp | 19 ++++++++++--
 tests/unit/test_eval_dryrun.cpp               | 29 +++++++++++++++++++
 2 files changed, 46 insertions(+), 2 deletions(-)

diff --git a/SeQuant/core/eval/backends/dryrun/size_regime.hpp b/SeQuant/core/eval/backends/dryrun/size_regime.hpp
index c43561e66e..9faf1aa834 100644
--- a/SeQuant/core/eval/backends/dryrun/size_regime.hpp
+++ b/SeQuant/core/eval/backends/dryrun/size_regime.hpp
@@ -29,6 +29,15 @@ struct SizeRegime {
   std::array<double, 5> csv_pno_moment{1.0, 1.0, 1.0, 1.0, 1.0};
   std::array<double, 5> csv_osv_moment{1.0, 1.0, 1.0, 1.0, 1.0};
 
+  // Moment tables for CSV cluster ranks >= 3 (CSV-CCSDT triples and beyond),
+  // keyed by cluster rank (= number of proto indices). csv_moment_by_rank[r][k]
+  // is the k-th power mean of the rank-r cluster domain. A rank not present
+  // falls back to csv_pno_moment (the rank-2 table) in inner_pow(), preserving
+  // the pre-rank-general behavior where every proto-rank >= 2 used the PNO
+  // table. Ranks 1 and 2 are held by csv_osv_moment / csv_pno_moment above and
+  // are NOT expected here (an entry for 1 or 2 is ignored by inner_pow()).
+  std::map<std::size_t, std::array<double, 5>> csv_moment_by_rank;
+
   /// \return the flat extent of \p ix's space; throws \c std::out_of_range
   ///         if the space is not present in \c space_extent (fail loud rather
   ///         than silently defaulting to 1).
@@ -39,14 +48,20 @@ struct SizeRegime {
   /// \return the k-th power-mean moment for a proto-indexed CSV/PNO composite
   ///         index (\p k clamped to 0..4), or \c pow(extent, k) for a plain
   ///         (non-composite) index. Rank is determined by the number of proto
-  ///         indices: 2 => PNO (occupied pair), 1 => OSV (occupied single).
+  ///         indices: 1 => OSV (occupied single), 2 => PNO (occupied pair),
+  ///         >= 3 => the rank-specific csv_moment_by_rank table if present,
+  ///         else the PNO (rank-2) table.
   [[nodiscard]] double inner_pow(Index const& composite, std::size_t k) const {
     if (k > 4) k = 4;
     auto const& protos = composite.proto_indices();
     if (protos.empty())
       return std::pow(static_cast<double>(extent(composite)),
                       static_cast<double>(k));
-    return (protos.size() >= 2) ? csv_pno_moment[k] : csv_osv_moment[k];
+    auto const rank = protos.size();
+    if (rank <= 1) return csv_osv_moment[k];
+    if (rank == 2) return csv_pno_moment[k];
+    auto const it = csv_moment_by_rank.find(rank);
+    return (it != csv_moment_by_rank.end()) ? it->second[k] : csv_pno_moment[k];
   }
 
   [[nodiscard]] std::function<std::size_t(Index const&)> idx_to_extent() const {
diff --git a/tests/unit/test_eval_dryrun.cpp b/tests/unit/test_eval_dryrun.cpp
index 7997660463..ef3e4b717d 100644
--- a/tests/unit/test_eval_dryrun.cpp
+++ b/tests/unit/test_eval_dryrun.cpp
@@ -274,6 +274,35 @@ TEST_CASE("dryrun power-mean sizing contract", "[dryrun][sizing]") {
                                                     // artifact"
 }
 
+// Rank-general CSV moment dispatch (CSV-CCSDT and beyond): inner_pow() selects
+// the moment table by cluster rank (= number of proto indices). Rank 1 -> OSV,
+// rank 2 -> PNO, rank >= 3 -> the csv_moment_by_rank[rank] table if present,
+// else a fallback to the PNO (rank-2) table (preserving the pre-rank-general
+// behavior where every proto-rank >= 2 used the PNO table).
+TEST_CASE("dryrun rank-general CSV moment dispatch", "[dryrun][sizing]") {
+  SizeRegime r;
+  for (std::size_t k = 0; k <= 4; ++k) {
+    r.csv_osv_moment[k] = 3.0;   // rank-1 table (flat, distinct value)
+    r.csv_pno_moment[k] = 30.0;  // rank-2 table (flat, distinct value)
+  }
+  // rank-3 (triple) table, distinct from both rank-1 and rank-2.
+  r.csv_moment_by_rank[3] = {1.0, 100.0, 100.0, 100.0, 100.0};
+  auto ip = r.inner_pow_fn();
+
+  Index i1{L"i_1"}, i2{L"i_2"}, i3{L"i_3"};
+  Index osv{L"a_1", {i1}};               // rank-1 composite
+  Index pno{L"a_2", {i1, i2}};           // rank-2 composite
+  Index triple{L"a_3", {i1, i2, i3}};    // rank-3 composite
+  Index quad{L"a_4", {i1, i2, i3, i1}};  // rank-4 composite (no table)
+
+  // Each rank draws from its own table.
+  CHECK(ip(osv, 2) == Catch::Approx(3.0));
+  CHECK(ip(pno, 2) == Catch::Approx(30.0));
+  CHECK(ip(triple, 2) == Catch::Approx(100.0));
+  // A rank with no table falls back to the PNO (rank-2) table, NOT the OSV one.
+  CHECK(ip(quad, 2) == Catch::Approx(30.0));
+}
+
 // Sanity check for the probe's own plumbing (is_stand_in_batchable /
 // batch_policy / term_batch_axes / binarize round-trip), independent of the
 // real residual: with a tiny peak_threshold that makes every schedule

From e1436f76e3019905202ccd67c209f89b7f56d480 Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Mon, 6 Jul 2026 10:01:15 -0400
Subject: [PATCH 42/78] tests/dryrun: faithful df_regime overload +
 objective/moment/threshold sweep

Make the [dryrun-df] C60 harness a controlled experiment for the PNO-CCSD
schedule study:
- df_regime array overload takes the real per-nonnull-cluster power means
  M_1..M_4 (heavy tail) as measured by mpqc's PaoPnoRMP2, instead of the
  constant-domain scalar (M_k = mean for all k, which under-sizes
  multi-composite intermediates).
- env sweeps on [dryrun-df]: SEQUANT_UT_DRYRUN_OBJ (perf=dense_time_space vs
  peak=dense_space_time), SEQUANT_UT_DRYRUN_{PNO,OSV}_M2..M4 (real heavy tail),
  SEQUANT_UT_DRYRUN_PEAK_THR_GB (batching peak budget). All default to the prior
  constant-M1 / peak-first / 40 GB behavior, so absent env vars reproduce the
  old test exactly.
- report per-term and total nominal schedule FLOPS alongside the realized peak,
  so the flops-vs-peak tradeoff between factorizations is visible (the 4-PAO
  fully-sliced integral is memory-cheap but flops-heavy; only this surfaces it).

Used to establish: perf-first (dense_time_space) ignores peak_threshold and
forms the ~1.2 TB free-mu~ giant (C60 OOM); peak-first at a realistic threshold
slices mu~ and fits. Also surfaced a threshold non-monotonicity in the
gated select_root worth a separate look.
---
 tests/unit/test_eval_dryrun.cpp | 80 ++++++++++++++++++++++++++++++---
 1 file changed, 75 insertions(+), 5 deletions(-)

diff --git a/tests/unit/test_eval_dryrun.cpp b/tests/unit/test_eval_dryrun.cpp
index ef3e4b717d..0b890908a8 100644
--- a/tests/unit/test_eval_dryrun.cpp
+++ b/tests/unit/test_eval_dryrun.cpp
@@ -639,6 +639,29 @@ SizeRegime df_regime(std::size_t mu_tilde, std::size_t aux, std::size_t i_occ,
   return r;
 }
 
+// FAITHFUL variant: takes the real per-nonnull-cluster power means M_1..M_4
+// (heavy tail) as measured by mpqc's PaoPnoRMP2 -- the two lines it prints,
+// "PNO domain power means M_1..M_4 per pair" and "OSV domain power means
+// M_1..M_4 per orbital". Unlike the scalar overload above (constant domain,
+// M_k = mean for all k, which under-sizes multi-composite intermediates), this
+// preserves M_2 > M_1 > ... so a k-composite group is sized by mean(d^k), the
+// true block-sparse volume. pno_M[k]/osv_M[k] for k in [1,4]; index 0 unused
+// (kept 1). Rank >= 3 (CSV-CCSDT) is not populated here (CCSD is ranks 1-2).
+SizeRegime df_regime(std::size_t mu_tilde, std::size_t aux, std::size_t i_occ,
+                     std::array<double, 5> const& pno_M,
+                     std::array<double, 5> const& osv_M) {
+  SizeRegime r;
+  r.space_extent = {
+      {L"i", i_occ},
+      {L"μ̃", mu_tilde},
+      {L"Κ", aux},
+      {L"a", mu_tilde},
+  };
+  r.csv_pno_moment = pno_M;
+  r.csv_osv_moment = osv_M;
+  return r;
+}
+
 // Batchable = the two axes mpqc's runtime batches on the CSV path: PAO (mu~)
 // and DF aux (K). Both are non-proto base spaces (mu~ = PAO, K = DFBS aux).
 bool is_df_batchable(Index const& ix) {
@@ -694,7 +717,13 @@ TEST_CASE("dryrun POST-transform PAO/K batch-axis verdict", "[dryrun-df]") {
   // progress + timing to std::cerr (unbuffered) so a slow/pathological term is
   // visible; each term reports whether its largest free-mu~ intermediate got a
   // mu~/K batch axis.
-  double const peak_threshold = 40e9;  // 40 GB, matches the C60 run
+  // 40 GB matches the (too-tight) C60 run; override to explore realistic
+  // budgets where the mu~-sliced sensible schedule becomes feasible.
+  double const peak_threshold =
+      (std::getenv("SEQUANT_UT_DRYRUN_PEAK_THR_GB")
+           ? std::atof(std::getenv("SEQUANT_UT_DRYRUN_PEAK_THR_GB"))
+           : 40.0) *
+      1e9;
   // Env overrides for the root-cause BISECT (default = faithful real C60
   // config). SEQUANT_UT_DRYRUN_OCC/PNO/OSV vary extents;
   // SEQUANT_UT_DRYRUN_PAO_TS/AUX_TS vary batch target sizes;
@@ -715,6 +744,20 @@ TEST_CASE("dryrun POST-transform PAO/K batch-axis verdict", "[dryrun-df]") {
   std::size_t const aux_ts = env_u("SEQUANT_UT_DRYRUN_AUX_TS", 72u);
   double const vol_weight = env_d("SEQUANT_UT_DRYRUN_VW", 20.0);
   bool const use_roofline = env_u("SEQUANT_UT_DRYRUN_ROOFLINE", 1u) != 0;
+  // FAITHFUL heavy-tail moments: real M_2..M_4 (default to M_1 = the constant
+  // domain, so absent env vars reproduce the old scalar df_regime exactly).
+  // Feed the mpqc-printed "PNO/OSV domain power means M_1..M_4" here.
+  double const pno_m2 = env_d("SEQUANT_UT_DRYRUN_PNO_M2", pno_mom);
+  double const pno_m3 = env_d("SEQUANT_UT_DRYRUN_PNO_M3", pno_mom);
+  double const pno_m4 = env_d("SEQUANT_UT_DRYRUN_PNO_M4", pno_mom);
+  double const osv_m2 = env_d("SEQUANT_UT_DRYRUN_OSV_M2", osv_mom);
+  double const osv_m3 = env_d("SEQUANT_UT_DRYRUN_OSV_M3", osv_mom);
+  double const osv_m4 = env_d("SEQUANT_UT_DRYRUN_OSV_M4", osv_mom);
+  // Objective: "perf" = dense_time_space (perf-first, min-flops), else
+  // "peak" = dense_space_time (peak-first, min-flops s.t. peak<=threshold).
+  // Default "peak" reproduces the old DensePeakSizeBatched behavior.
+  char const* obj_env = std::getenv("SEQUANT_UT_DRYRUN_OBJ");
+  std::string const obj = obj_env ? std::string(obj_env) : std::string("peak");
   // SEQUANT_UT_DRYRUN_AUX_ONLY=1 makes ONLY the DF aux (K) sliceable, NOT PAO
   // (mu~) -- reproduces MPQC's aux-only batching to check the proper (gC)^2 PPL
   // factorization keeps the mu~-full giant (large realized peak = OOM) and
@@ -737,10 +780,24 @@ TEST_CASE("dryrun POST-transform PAO/K batch-axis verdict", "[dryrun-df]") {
   // The earlier water-8 occ/PNO (i=32, PNO=19, OSV=57) were as wrong as the
   // K=672; they under-scaled every intermediate and (via peak_threshold
   // pruning) changed the DP's axis choice.
-  auto regime = df_regime(/*mu_tilde=*/1800u, /*aux=*/4320u, /*i_occ=*/occ_ext,
-                          /*pno=*/pno_mom, /*osv=*/osv_mom);
+  auto regime = df_regime(
+      /*mu_tilde=*/1800u, /*aux=*/4320u, /*i_occ=*/occ_ext,
+      std::array<double, 5>{1.0, pno_mom, pno_m2, pno_m3, pno_m4},
+      std::array<double, 5>{1.0, osv_mom, osv_m2, osv_m3, osv_m4});
+  std::wcerr << L"[dryrun-df] moments: PNO M_1..M_4=" << pno_mom << L","
+             << pno_m2 << L"," << pno_m3 << L"," << pno_m4 << L"  OSV M_1..M_4="
+             << osv_mom << L"," << osv_m2 << L"," << osv_m3 << L"," << osv_m4
+             << L"  objective="
+             << (obj == "perf" ? L"perf(dense_time_space)"
+                               : L"peak(dense_space_time)")
+             << L"\n";
   auto memsize = sequant::opt::detail::memsize_counter(regime.idx_to_extent(),
                                                        regime.inner_pow_fn());
+  // Static NOMINAL flops per contraction node (slicing does not reduce total
+  // work, so this is the true schedule flops). The 4-PAO fully-sliced integral
+  // is memory-cheap but flops-catastrophic; only this metric surfaces it.
+  auto flops = sequant::opt::detail::flops_counter(regime.idx_to_extent(),
+                                                   regime.inner_pow_fn());
   auto has_free_mu_tilde = [](std::vector<Index> const& ixs) {
     for (auto const& ix : ixs)
       if (ix.space().base_key() == L"μ̃") return true;
@@ -749,6 +806,7 @@ TEST_CASE("dryrun POST-transform PAO/K batch-axis verdict", "[dryrun-df]") {
 
   std::size_t total_mu_nodes = 0, n_terms_with_giant = 0;
   std::size_t total_mu_nodes_with_mu_axis = 0, total_mu_nodes_with_k_only = 0;
+  double overall_flops = 0.0;  // summed schedule flops over all terms
   double overall_biggest = 0.0;
   bool overall_biggest_has_mu = false, overall_biggest_has_k = false;
   std::wstring overall_biggest_desc, overall_biggest_axes,
@@ -762,7 +820,9 @@ TEST_CASE("dryrun POST-transform PAO/K batch-axis verdict", "[dryrun-df]") {
     auto axes_map = std::make_shared<std::unordered_map<
         Expr const*, container::vector<container::svector<Index>>>>();
     OptimizeOptions opts;
-    opts.objective_function = ObjectiveFunction::DensePeakSizeBatched;
+    opts.objective_function = (obj == "perf")
+                                  ? ObjectiveFunction::DenseTimeSpaceBatched
+                                  : ObjectiveFunction::DenseSpaceTimeBatched;
     opts.idx_to_extent = regime.idx_to_extent();
     opts.inner_pow = regime.inner_pow_fn();
     opts.batch_policy.is_batchable_index = is_batchable;
@@ -825,6 +885,7 @@ TEST_CASE("dryrun POST-transform PAO/K batch-axis verdict", "[dryrun-df]") {
     bool term_biggest_has_mu = false;  // its free mu~ ESCAPED slicing
     bool term_biggest_has_k = false;   // its free K ESCAPED slicing
     std::size_t term_mu_nodes = 0;
+    double term_flops = 0.0;  // summed nominal contraction flops for this term
     // active maps a sliced index's FULL label -> a descriptor of the ANCESTOR
     // node that slices it (its result free-index signature + its batch_axes).
     // This is the node-dump: it turns "escaped={}" from an inference into a
@@ -880,6 +941,11 @@ TEST_CASE("dryrun POST-transform PAO/K batch-axis verdict", "[dryrun-df]") {
             }
           }
           if (!n.leaf()) {
+            // Nominal flops of THIS contraction: union of children's free
+            // indices and this node's result free indices (slicing does not
+            // change the flop count).
+            term_flops += flops(node_free_indices(*n.left()),
+                                node_free_indices(*n.right()), free_ixs);
             std::map<std::wstring, std::wstring> child_active = active;
             std::wstring const self_desc =
                 L"[free={" + describe_indices(node_free_indices(*n)) +
@@ -894,6 +960,7 @@ TEST_CASE("dryrun POST-transform PAO/K batch-axis verdict", "[dryrun-df]") {
           }
         };
     walk(node, {});
+    overall_flops += term_flops;
     if (term_mu_nodes > 0) ++n_terms_with_giant;
     if (term_biggest > overall_biggest) {
       overall_biggest = term_biggest;
@@ -909,13 +976,16 @@ TEST_CASE("dryrun POST-transform PAO/K batch-axis verdict", "[dryrun-df]") {
     std::cerr << " " << ms << "ms  free-mu~ nodes=" << term_mu_nodes
               << " biggest_realized=" << (term_biggest / 1e9)
               << "GB mu~escaped=" << (term_biggest_has_mu ? "YES" : "NO")
-              << " Kescaped=" << (term_biggest_has_k ? "YES" : "NO") << "\n";
+              << " Kescaped=" << (term_biggest_has_k ? "YES" : "NO")
+              << " flops=" << (term_flops / 1e12) << "T\n";
   }
 
   std::wcerr << L"\n=== POST-TRANSFORM VERDICT (REALIZED peak, mu~=1800, "
                 L"thr=40GB) ===\n"
              << L"terms with a free-mu~ intermediate: " << n_terms_with_giant
              << L"/" << terms.size() << L"\n"
+             << L"TOTAL SCHEDULE FLOPS (nominal, all terms): "
+             << (overall_flops / 1e12) << L" Tflop\n"
              << L"free-mu~ contraction nodes: " << total_mu_nodes << L"\n"
              << L"  ... with a free mu~ that ESCAPED slicing: "
              << total_mu_nodes_with_mu_axis << L"\n"

From b4d89feb87055f043992c0687f9d6505c3b3df32 Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Mon, 6 Jul 2026 12:04:10 -0400
Subject: [PATCH 43/78] optimize: gated select_root diagnostic (chosen vs
 global-min frontier cost)

Add a SEQUANT_SELROOT_DEBUG-gated stderr print in PeakBatchedModel::select_root
reporting the DP's OWN chosen frontier point cost (.flops = the roofline exec
cost, volatile-weighted -- the true objective), its peak, whether any point was
feasible, the frontier size, and the global-min .flops over the whole frontier.

This is the tool for calibrating batch:peak_threshold on real systems: summing
chosen_flops across a residual's terms at several thresholds shows the
threshold-vs-cost curve directly (in the DP's own metric, not a post-hoc proxy).
It is what disambiguated the C60 study -- the chosen cost is monotone in the
threshold, and a too-tight threshold (40 GB) sits ~38x above the global optimum
because every low-cost schedule is peak-infeasible. Zero overhead when the env
var is unset.
---
 SeQuant/core/optimize/cost_model.hpp | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/SeQuant/core/optimize/cost_model.hpp b/SeQuant/core/optimize/cost_model.hpp
index 5d3d6337bc..c938e97dd0 100644
--- a/SeQuant/core/optimize/cost_model.hpp
+++ b/SeQuant/core/optimize/cost_model.hpp
@@ -9,7 +9,9 @@
 #include <bit>
 #include <cmath>
 #include <concepts>
+#include <cstdlib>
 #include <functional>
+#include <iostream>
 #include <limits>
 #include <utility>
 
@@ -767,6 +769,20 @@ struct PeakBatchedModel {
           best = i;
         }
     }
+    // DIAGNOSTIC (gated): the DP's OWN chosen frontier cost (.flops is the
+    // roofline exec cost, volatile-weighted -- the true objective), plus the
+    // global-min .flops over the WHOLE frontier (feasible or not) so a
+    // non-min-feasible selection is visible. Sum the printed chosen_flops
+    // across terms to test threshold monotonicity of the DP's real objective.
+    if (best >= 0 && std::getenv("SEQUANT_SELROOT_DEBUG")) {
+      double gmin = std::numeric_limits<double>::max();
+      for (auto const& p : rootf) gmin = std::min(gmin, p.flops);
+      std::cerr << "[selroot] chosen_flops=" << rootf[best].flops
+                << " chosen_peak_gb=" << (peak_bytes(rootf[best].peak) / 1e9)
+                << " feasible=" << (any_feasible ? 1 : 0)
+                << " nfront=" << rootf.size() << " global_min_flops=" << gmin
+                << "\n";
+    }
     return best;
   }
 

From eca55baeed356086f3d90e5e24922dab070c3dba Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Mon, 6 Jul 2026 12:39:30 -0400
Subject: [PATCH 44/78] tests/dryrun: report roofline exec cost (the DP's real
 axis) in the df sweep

The [dryrun-df] sweep reported only nominal contraction flops, which are
batch-independent and can move non-monotonically with the peak threshold.
Add a per-term and overall roofline exec-cost accumulation matching the
DP's actual optimization axis (max(flops, mb*max(traffic, prefac*flops/
sqrt(fastmem/tiles))), mb=200) so the sweep prints the quantity the
optimizer minimizes, not just raw flops.
---
 tests/unit/test_eval_dryrun.cpp | 21 +++++++++++++++++++--
 1 file changed, 19 insertions(+), 2 deletions(-)

diff --git a/tests/unit/test_eval_dryrun.cpp b/tests/unit/test_eval_dryrun.cpp
index 0b890908a8..493686e3ea 100644
--- a/tests/unit/test_eval_dryrun.cpp
+++ b/tests/unit/test_eval_dryrun.cpp
@@ -807,6 +807,7 @@ TEST_CASE("dryrun POST-transform PAO/K batch-axis verdict", "[dryrun-df]") {
   std::size_t total_mu_nodes = 0, n_terms_with_giant = 0;
   std::size_t total_mu_nodes_with_mu_axis = 0, total_mu_nodes_with_k_only = 0;
   double overall_flops = 0.0;  // summed schedule flops over all terms
+  double overall_exec = 0.0;   // summed roofline exec cost (DP's real axis)
   double overall_biggest = 0.0;
   bool overall_biggest_has_mu = false, overall_biggest_has_k = false;
   std::wstring overall_biggest_desc, overall_biggest_axes,
@@ -886,6 +887,7 @@ TEST_CASE("dryrun POST-transform PAO/K batch-axis verdict", "[dryrun-df]") {
     bool term_biggest_has_k = false;   // its free K ESCAPED slicing
     std::size_t term_mu_nodes = 0;
     double term_flops = 0.0;  // summed nominal contraction flops for this term
+    double term_exec = 0.0;   // summed roofline exec cost for this term
     // active maps a sliced index's FULL label -> a descriptor of the ANCESTOR
     // node that slices it (its result free-index signature + its batch_axes).
     // This is the node-dump: it turns "escaped={}" from an inference into a
@@ -944,8 +946,20 @@ TEST_CASE("dryrun POST-transform PAO/K batch-axis verdict", "[dryrun-df]") {
             // Nominal flops of THIS contraction: union of children's free
             // indices and this node's result free indices (slicing does not
             // change the flop count).
-            term_flops += flops(node_free_indices(*n.left()),
-                                node_free_indices(*n.right()), free_ixs);
+            auto const lf = node_free_indices(*n.left());
+            auto const rf = node_free_indices(*n.right());
+            double const nf = flops(lf, rf, free_ixs);
+            term_flops += nf;
+            // Roofline exec cost = the DP's ACTUAL optimization axis (NOT raw
+            // flops): max(flops, mb * max(traffic, prefac*flops/sqrt(fastmem/
+            // tiles))), mb=200, fastmem=1e6, tiles=3, prefac=1. Traffic = the
+            // UNBATCHED operand+result footprint, so exec cost is batch-
+            // INDEPENDENT (batching moves only the peak). This is why raw flops
+            // can be non-monotone in the threshold while the DP's objective is
+            // monotone. Element units (matches the DP).
+            double const traffic = memsize(lf, rf, free_ixs);
+            double const Q = std::max(traffic, nf / std::sqrt(1e6 / 3.0));
+            term_exec += std::max(nf, 200.0 * Q);
             std::map<std::wstring, std::wstring> child_active = active;
             std::wstring const self_desc =
                 L"[free={" + describe_indices(node_free_indices(*n)) +
@@ -961,6 +975,7 @@ TEST_CASE("dryrun POST-transform PAO/K batch-axis verdict", "[dryrun-df]") {
         };
     walk(node, {});
     overall_flops += term_flops;
+    overall_exec += term_exec;
     if (term_mu_nodes > 0) ++n_terms_with_giant;
     if (term_biggest > overall_biggest) {
       overall_biggest = term_biggest;
@@ -986,6 +1001,8 @@ TEST_CASE("dryrun POST-transform PAO/K batch-axis verdict", "[dryrun-df]") {
              << L"/" << terms.size() << L"\n"
              << L"TOTAL SCHEDULE FLOPS (nominal, all terms): "
              << (overall_flops / 1e12) << L" Tflop\n"
+             << L"TOTAL ROOFLINE EXEC COST (the DP's real axis): "
+             << (overall_exec / 1e12) << L" (mb=200, batch-independent)\n"
              << L"free-mu~ contraction nodes: " << total_mu_nodes << L"\n"
              << L"  ... with a free mu~ that ESCAPED slicing: "
              << total_mu_nodes_with_mu_axis << L"\n"

From 430197c73308b46afe52460dbb32b952625a1876 Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Mon, 6 Jul 2026 12:39:52 -0400
Subject: [PATCH 45/78] optimize: model batch recomputation cost on the
 flops/exec axis (opt-in)

The batched cost model assumed WORK PARITY: slicing an axis shrinks peak
but never changes flops. That holds for axes a node CARRIES (slicing
partitions the work, total preserved), but not for axes an ancestor slices
that the node's result does NOT carry -- there the batched evaluator
re-executes the node once per tile (across-batch recompute; within-batch
sharing is cached, per eval.hpp "replays the build of every compatible
persistent final"). Work-parity under-costs schedules that recompute
across many sliced axes.

Add PeakBatchedModel::charge_batch_recompute: when set, a node at
ancestor-sliced-set B is charged nbatch(b)=ceil(extent/target) for each b
in B not open in the node. Context now carries per-axis nbatch. Default
false preserves the historical cost model exactly; wired in single_term
via the SEQUANT_CHARGE_RECOMPUTE env var for validation (TODO: promote to
an OptimizeOptions/BatchPolicy field).

Finding on the C60 giant: the competitive schedules slice axes they carry
(partitioning), so the recompute charge is small and does not by itself
redirect selection -- the 4-PAO's flops were already accounted correctly.
The C60 OOM is a peak/feasibility problem (the giant does not fit), fixed
by making mu~ batchable plus a realistic peak threshold, not by this
charge. The charge is a faithfulness fix, kept off by default.
---
 SeQuant/core/optimize/cost_model.hpp  | 41 ++++++++++++++++++++++++++-
 SeQuant/core/optimize/single_term.hpp |  6 ++++
 2 files changed, 46 insertions(+), 1 deletion(-)

diff --git a/SeQuant/core/optimize/cost_model.hpp b/SeQuant/core/optimize/cost_model.hpp
index c938e97dd0..d2e4c95fba 100644
--- a/SeQuant/core/optimize/cost_model.hpp
+++ b/SeQuant/core/optimize/cost_model.hpp
@@ -563,6 +563,18 @@ struct PeakBatchedModel {
   /// peak-first threshold-gated selection (unchanged).
   bool perf_first = false;
 
+  /// If true, charge the batch RECOMPUTATION cost on the flops/exec axis. The
+  /// batched evaluator re-executes each contraction per tile of the ancestor
+  /// batch axes its result does NOT carry (across-batch work is recomputed;
+  /// within-batch sharing is cached -- see eval.hpp "replays the build of every
+  /// compatible persistent final"). The default (false) assumes WORK PARITY
+  /// (batching is free on flops), which under-costs heavily-sliced families
+  /// (e.g. the 4-PAO integral) and lets peak-first pick them. When true, a node
+  /// at ancestor-sliced-set B is charged nbatch(b) for each b in B not open in
+  /// the node -- so a schedule that slices many axes it must recompute across
+  /// pays for it. Default false preserves the historical cost model.
+  bool charge_batch_recompute = false;
+
   /// One non-dominated (peak, flops) trade-off for a (subset, sliced-set \c B)
   /// cell. \c aprime is the sliced-set chosen at this node; the children are
   /// read at context \c C = B | aprime, at frontier indices \c lp_idx /
@@ -605,6 +617,11 @@ struct PeakBatchedModel {
     /// flops_of(lhs, rhs, result) = flop count of one binary contraction.
     std::function<double(IndexSet const&, IndexSet const&, IndexSet const&)>
         flops_of;
+    /// nbatch[k] = number of batch tiles of aux[k] = ceil(extent / target),
+    /// clamped to >= 1. Used to charge batch recomputation (see
+    /// charge_batch_recompute): a node inside an ancestor batch loop over
+    /// aux[k] that does not carry aux[k] is re-executed nbatch[k] times.
+    container::vector<double> nbatch;
 
     /// Context-restricted size of subset s under sliced-set ctx (the table is
     /// indexed by the part of ctx actually open in s; mirrors the oracle).
@@ -628,6 +645,15 @@ struct PeakBatchedModel {
     ctx.nt = network.tensors().size();
     ctx.aux = batchable_index_list(network, is_batchable);
     ctx.m = ctx.aux.size();
+    // Per-axis batch-tile count for the recompute charge: ceil(extent/target),
+    // >= 1. batch() returns the target tile size; a 0/absent target => 1 tile
+    // (no batching of that axis => no recompute).
+    ctx.nbatch.assign(ctx.m, 1.0);
+    for (std::size_t k = 0; k < ctx.m; ++k) {
+      double const ext = static_cast<double>(idxsz(ctx.aux[k]));
+      double const tgt = static_cast<double>(batch(ctx.aux[k]));
+      ctx.nbatch[k] = (tgt > 0.0) ? std::max(1.0, std::ceil(ext / tgt)) : 1.0;
+    }
     // accumulation_factor is charged per accumulation node (Ap != 0) and is
     // valid for any number of batchable indices: with nested accumulation the
     // per-node charges co-exist at the peak. Validated by the identity
@@ -677,6 +703,19 @@ struct PeakBatchedModel {
                              machine_balance, fast_mem_elems, block_tiles,
                              block_prefactor);
     for (std::size_t B = 0; B < ctx.nB; ++B) {
+      // Batch recomputation charge: this node sits inside the ancestor batch
+      // loops over the axes in B. For each b in B whose axis this node's result
+      // does NOT carry (b not open in n), the node is re-executed nbatch(b)
+      // times (across-batch recompute); axes it carries are partitioned (x1).
+      // Default off => rf==1 => historical work-parity cost.
+      double rf = 1.0;
+      if (charge_batch_recompute) {
+        std::size_t const esc =
+            B & ~ctx.open_aux[n];  // B axes n does not carry
+        for (std::size_t k = 0; k < ctx.m; ++k)
+          if (esc & (std::size_t{1} << k)) rf *= ctx.nbatch[k];
+      }
+      double const cflops_B = cflops * rf;
       // Batchable indices contracted at THIS node: open at children but not at
       // the parent. By default batching is applied ACROSS THE BOARD: slicing
       // the batch axis shrinks any intermediate carrying it regardless of
@@ -711,7 +750,7 @@ struct PeakBatchedModel {
             double const rpf = std::max({Llp + prr, szrp + pl, both});
             pareto_insert(acc[B], BFrontPoint{std::min(lpf, rpf),
                                               lp_st[C][li].flops +
-                                                  rp_st[C][ri].flops + cflops,
+                                                  rp_st[C][ri].flops + cflops_B,
                                               lp, rp, lpf <= rpf, Ap, li, ri});
           }
         if (Ap == 0) break;
diff --git a/SeQuant/core/optimize/single_term.hpp b/SeQuant/core/optimize/single_term.hpp
index 0aef921619..ac895a8b07 100644
--- a/SeQuant/core/optimize/single_term.hpp
+++ b/SeQuant/core/optimize/single_term.hpp
@@ -16,6 +16,7 @@
 #include <range/v3/view/filter.hpp>
 #include <range/v3/view/reverse.hpp>
 
+#include <cstdlib>
 #include <functional>
 
 namespace sequant::opt {
@@ -141,6 +142,11 @@ EvalSequence single_term_opt(
                            accumulation_factor,
                            cost.peak_threshold};
     model.perf_first = (Metric == ObjectiveFunction::DenseTimeSpaceBatched);
+    // Opt-in (env-gated) batch recomputation charge for validation; see
+    // PeakBatchedModel::charge_batch_recompute. TODO: promote to an
+    // OptimizeOptions/BatchPolicy field once validated.
+    model.charge_batch_recompute =
+        (std::getenv("SEQUANT_CHARGE_RECOMPUTE") != nullptr);
     if (out_axes) {
       auto [seq, axes] = run_single_term_opt_axes(model, network, tidxs);
       *out_axes = std::move(axes);

From 816c3503eb3e284b8ff6d5bdf9de94d9af35f2ad Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Mon, 6 Jul 2026 14:17:15 -0400
Subject: [PATCH 46/78] optimize: enable batch recomputation charge by default

The batch recomputation cost is a real cost of batching, so the cost model
should always reflect it. Flip PeakBatchedModel::charge_batch_recompute to
default true and drop the SEQUANT_CHARGE_RECOMPUTE env gating in
single_term (the flag remains as a programmatic escape hatch for work-
parity comparison). No SeQuant unit-test regressions: [optimize] 365
assertions/14 cases and the tagged [dryrun] unit tests stay green.
---
 SeQuant/core/optimize/cost_model.hpp  | 22 +++++++++++-----------
 SeQuant/core/optimize/single_term.hpp |  8 ++------
 2 files changed, 13 insertions(+), 17 deletions(-)

diff --git a/SeQuant/core/optimize/cost_model.hpp b/SeQuant/core/optimize/cost_model.hpp
index d2e4c95fba..768e255819 100644
--- a/SeQuant/core/optimize/cost_model.hpp
+++ b/SeQuant/core/optimize/cost_model.hpp
@@ -563,17 +563,17 @@ struct PeakBatchedModel {
   /// peak-first threshold-gated selection (unchanged).
   bool perf_first = false;
 
-  /// If true, charge the batch RECOMPUTATION cost on the flops/exec axis. The
-  /// batched evaluator re-executes each contraction per tile of the ancestor
-  /// batch axes its result does NOT carry (across-batch work is recomputed;
-  /// within-batch sharing is cached -- see eval.hpp "replays the build of every
-  /// compatible persistent final"). The default (false) assumes WORK PARITY
-  /// (batching is free on flops), which under-costs heavily-sliced families
-  /// (e.g. the 4-PAO integral) and lets peak-first pick them. When true, a node
-  /// at ancestor-sliced-set B is charged nbatch(b) for each b in B not open in
-  /// the node -- so a schedule that slices many axes it must recompute across
-  /// pays for it. Default false preserves the historical cost model.
-  bool charge_batch_recompute = false;
+  /// If true (the default), charge the batch RECOMPUTATION cost on the flops/
+  /// exec axis. The batched evaluator re-executes each contraction per tile of
+  /// the ancestor batch axes its result does NOT carry (across-batch work is
+  /// recomputed; within-batch sharing is cached -- see eval.hpp "replays the
+  /// build of every compatible persistent final"). A node at ancestor-sliced-
+  /// set B is charged nbatch(b) for each b in B not open in the node, so a
+  /// schedule that slices many axes it must recompute across pays for it. The
+  /// alternative (false) assumes WORK PARITY (batching is free on flops), which
+  /// under-costs heavily-sliced families and does not reflect the true cost of
+  /// batching; kept only as an escape hatch for comparison.
+  bool charge_batch_recompute = true;
 
   /// One non-dominated (peak, flops) trade-off for a (subset, sliced-set \c B)
   /// cell. \c aprime is the sliced-set chosen at this node; the children are
diff --git a/SeQuant/core/optimize/single_term.hpp b/SeQuant/core/optimize/single_term.hpp
index ac895a8b07..bb1b14391b 100644
--- a/SeQuant/core/optimize/single_term.hpp
+++ b/SeQuant/core/optimize/single_term.hpp
@@ -16,7 +16,6 @@
 #include <range/v3/view/filter.hpp>
 #include <range/v3/view/reverse.hpp>
 
-#include <cstdlib>
 #include <functional>
 
 namespace sequant::opt {
@@ -142,11 +141,8 @@ EvalSequence single_term_opt(
                            accumulation_factor,
                            cost.peak_threshold};
     model.perf_first = (Metric == ObjectiveFunction::DenseTimeSpaceBatched);
-    // Opt-in (env-gated) batch recomputation charge for validation; see
-    // PeakBatchedModel::charge_batch_recompute. TODO: promote to an
-    // OptimizeOptions/BatchPolicy field once validated.
-    model.charge_batch_recompute =
-        (std::getenv("SEQUANT_CHARGE_RECOMPUTE") != nullptr);
+    // charge_batch_recompute defaults to true (see PeakBatchedModel): the batch
+    // recomputation cost is always reflected on the flops/exec axis.
     if (out_axes) {
       auto [seq, axes] = run_single_term_opt_axes(model, network, tidxs);
       *out_axes = std::move(axes);

From 1aaf3728ca0a07f33c8eef6581de28511bb3bbeb Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Mon, 6 Jul 2026 14:25:50 -0400
Subject: [PATCH 47/78] tests/dryrun: drop the superseded pre-transform
 investigation layer

test_eval_dryrun.cpp had accreted a Phase-1 investigation layer built
against the PRE-transform residual (csv_ccsd_residual.txt: 4-index g, no DF
aux, generic base-virtual 'a' as a stand-in for mu~) whose stated purpose
was to exercise the DP-inspection plumbing until a post-transform fixture
existed. That fixture (csv_ccsd_doubles_residual_df.txt, real mu~ + K)
exists and the post-transform [dryrun-df]/[dryrun-perf]/[dryrun-eval] cases
now do the real batch-axis verdict, so the pre-transform layer is dead
weight. Remove:
  - TEST 'DP-inspection mechanics on pre-transform residual' (explicitly a
    stand-in, verdict-pending case, ~185 lines);
  - TEST 'residual fixture deserializes' (deserialized the old fixture);
  - TEST 'harness sanity: forced threshold annotates a batch axis'
    (synthetic-network plumbing check, now covered by the real cases);
  - dead helpers split_residual_members / is_stand_in_batchable;
  - the csv_ccsd_residual.txt fixture (no remaining references).
Rename the stand-in c60_regime -> probe_regime (its only remaining users
are the SizeRegime/memsize contract unit tests) and rewrite the stale file
header. Kept: the SizeRegime/CostModel/Result unit tests and every
post-transform batched-schedule case. Fast dryrun groups green (42
assertions/15 cases); TU compiles clean.
---
 tests/unit/data/csv_ccsd_residual.txt |   6 -
 tests/unit/test_eval_dryrun.cpp       | 384 ++------------------------
 2 files changed, 26 insertions(+), 364 deletions(-)
 delete mode 100644 tests/unit/data/csv_ccsd_residual.txt

diff --git a/tests/unit/data/csv_ccsd_residual.txt b/tests/unit/data/csv_ccsd_residual.txt
deleted file mode 100644
index ab9551cbfb..0000000000
--- a/tests/unit/data/csv_ccsd_residual.txt
+++ /dev/null
@@ -1,6 +0,0 @@
-==== Rs[0] ====
-2 ((g{i_1,i_2;a_21514,a_21515}:N-C-S * (C{a_21514;a_1<i_1>}:N-C-S * t{a_1<i_1>;i_1}:N-N-S)) * C{a_21515;a_2<i_2>}:N-C-S) * t{a_2<i_2>;i_2}:N-N-S - 1 ((g{i_1,i_2;a_21516,a_21517}:N-C-S * (C{a_21516;a_1<i_2>}:N-C-S * t{a_1<i_2>;i_2}:N-N-S)) * C{a_21517;a_2<i_1>}:N-C-S) * t{a_2<i_1>;i_1}:N-N-S + 2 (f{i_1;a_21518}:N-C-S * C{a_21518;a_1<i_1>}:N-C-S) * t{a_1<i_1>;i_1}:N-N-S - 1 ((g{i_1,i_2;a_21519,a_21520}:N-C-S * C{a_21519;a_1<i_1,i_2>}:N-C-S) * C{a_21520;a_2<i_1,i_2>}:N-C-S) * t{a_1<i_1,i_2>,a_2<i_1,i_2>;i_2,i_1}:N-N-S + 2 ((g{i_1,i_2;a_21521,a_21522}:N-C-S * C{a_21521;a_1<i_1,i_2>}:N-C-S) * C{a_21522;a_2<i_1,i_2>}:N-C-S) * t{a_1<i_1,i_2>,a_2<i_1,i_2>;i_1,i_2}:N-N-S
-==== Rs[1] ====
--1 (f{i_2;i_1}:N-C-S * (C{a_1;a_2<i_2>}:N-C-S * t{a_2<i_2>;i_2}:N-N-S)) * C{a_1<i_1>;a_1}:N-C-S + 2 (g{i_2,a_21523;a_21524,i_1}:N-C-S * (C{a_21524;a_2<i_2>}:N-C-S * t{a_2<i_2>;i_2}:N-N-S)) * C{a_1<i_1>;a_21523}:N-C-S - 1 ((g{i_2,a_21525;a_21526,a_21527}:N-C-S * (C{a_21527;a_3<i_2>}:N-C-S * t{a_3<i_2>;i_2}:N-N-S)) * (C{a_21526;a_2<i_1>}:N-C-S * t{a_2<i_1>;i_1}:N-N-S)) * C{a_1<i_1>;a_21525}:N-C-S + 2 ((g{i_2,a_21528;a_21529,a_21530}:N-C-S * (C{a_21529;a_2<i_2>}:N-C-S * t{a_2<i_2>;i_2}:N-N-S)) * (C{a_21530;a_3<i_1>}:N-C-S * t{a_3<i_1>;i_1}:N-N-S)) * C{a_1<i_1>;a_21528}:N-C-S - 2 ((((g{i_2,i_3;a_21532,a_21533}:N-C-S * (C{a_21532;a_2<i_1>}:N-C-S * t{a_2<i_1>;i_1}:N-N-S)) * C{a_21533;a_3<i_2,i_3>}:N-C-S) * t{a_3<i_2,i_3>,a_4<i_2,i_3>;i_3,i_2}:N-N-S) * C{a_1;a_4<i_2,i_3>}:N-C-S) * C{a_1<i_1>;a_1}:N-C-S + ((((g{i_2,i_3;a_21556,a_21557}:N-C-S * (C{a_21556;a_2<i_1>}:N-C-S * t{a_2<i_1>;i_1}:N-N-S)) * C{a_21557;a_3<i_2,i_3>}:N-C-S) * t{a_3<i_2,i_3>,a_4<i_2,i_3>;i_2,i_3}:N-N-S) * C{a_1;a_4<i_2,i_3>}:N-C-S) * C{a_1<i_1>;a_1}:N-C-S + ((g{i_2,i_3;a_21534,a_21535}:N-C-S * ((C{a_21534;a_2<i_1,i_2>}:N-C-S * t{a_2<i_1,i_2>,a_3<i_1,i_2>;i_1,i_2}:N-N-S) * C{a_21535;a_3<i_1,i_2>}:N-C-S)) * (C{a_1;a_4<i_3>}:N-C-S * t{a_4<i_3>;i_3}:N-N-S)) * C{a_1<i_1>;a_1}:N-C-S + 2 (g{i_2,a_21542;a_21543,a_21544}:N-C-S * ((C{a_21543;a_2<i_1,i_2>}:N-C-S * t{a_2<i_1,i_2>,a_3<i_1,i_2>;i_2,i_1}:N-N-S) * C{a_21544;a_3<i_1,i_2>}:N-C-S)) * C{a_1<i_1>;a_21542}:N-C-S - 1 (g{i_2,a_21560;a_21561,a_21562}:N-C-S * ((C{a_21561;a_2<i_1,i_2>}:N-C-S * t{a_2<i_1,i_2>,a_3<i_1,i_2>;i_1,i_2}:N-N-S) * C{a_21562;a_3<i_1,i_2>}:N-C-S)) * C{a_1<i_1>;a_21560}:N-C-S - 2 ((g{i_2,i_3;a_21563,a_21564}:N-C-S * ((C{a_21563;a_2<i_1,i_3>}:N-C-S * t{a_2<i_1,i_3>,a_3<i_1,i_3>;i_1,i_3}:N-N-S) * C{a_21564;a_3<i_1,i_3>}:N-C-S)) * (C{a_1;a_4<i_2>}:N-C-S * t{a_4<i_2>;i_2}:N-N-S)) * C{a_1<i_1>;a_1}:N-C-S - 1 (g{i_2,a_21538;i_1,a_21539}:N-C-S * (C{a_21539;a_2<i_2>}:N-C-S * t{a_2<i_2>;i_2}:N-N-S)) * C{a_1<i_1>;a_21538}:N-C-S + ((g{i_2,i_3;i_1,a_21540}:N-C-S * (C{a_21540;a_2<i_2>}:N-C-S * t{a_2<i_2>;i_2}:N-N-S)) * (C{a_1;a_3<i_3>}:N-C-S * t{a_3<i_3>;i_3}:N-N-S)) * C{a_1<i_1>;a_1}:N-C-S + (f{a_21545;a_21546}:N-C-S * (C{a_21546;a_2<i_1>}:N-C-S * t{a_2<i_1>;i_1}:N-N-S)) * C{a_1<i_1>;a_21545}:N-C-S + (((g{i_2,i_3;a_21547,a_21548}:N-C-S * (C{a_21548;a_3<i_2>}:N-C-S * t{a_3<i_2>;i_2}:N-N-S)) * (C{a_21547;a_2<i_1>}:N-C-S * t{a_2<i_1>;i_1}:N-N-S)) * (C{a_1;a_4<i_3>}:N-C-S * t{a_4<i_3>;i_3}:N-N-S)) * C{a_1<i_1>;a_1}:N-C-S - 2 ((((g{i_2,i_3;a_21554,a_21555}:N-C-S * (C{a_21554;a_2<i_3>}:N-C-S * t{a_2<i_3>;i_3}:N-N-S)) * C{a_21555;a_3<i_1,i_2>}:N-C-S) * t{a_3<i_1,i_2>,a_4<i_1,i_2>;i_2,i_1}:N-N-S) * C{a_1;a_4<i_1,i_2>}:N-C-S) * C{a_1<i_1>;a_1}:N-C-S + ((((g{i_2,i_3;a_21567,a_21568}:N-C-S * (C{a_21567;a_2<i_3>}:N-C-S * t{a_2<i_3>;i_3}:N-N-S)) * C{a_21568;a_3<i_1,i_2>}:N-C-S) * t{a_3<i_1,i_2>,a_4<i_1,i_2>;i_1,i_2}:N-N-S) * C{a_1;a_4<i_1,i_2>}:N-C-S) * C{a_1<i_1>;a_1}:N-C-S - 2 ((g{i_2,i_3;i_1,a_21549}:N-C-S * (C{a_21549;a_2<i_3>}:N-C-S * t{a_2<i_3>;i_3}:N-N-S)) * (C{a_1;a_3<i_2>}:N-C-S * t{a_3<i_2>;i_2}:N-N-S)) * C{a_1<i_1>;a_1}:N-C-S + 4 ((((g{i_2,i_3;a_21550,a_21551}:N-C-S * (C{a_21550;a_2<i_2>}:N-C-S * t{a_2<i_2>;i_2}:N-N-S)) * C{a_21551;a_3<i_1,i_3>}:N-C-S) * t{a_3<i_1,i_3>,a_4<i_1,i_3>;i_3,i_1}:N-N-S) * C{a_1;a_4<i_1,i_3>}:N-C-S) * C{a_1<i_1>;a_1}:N-C-S - 2 ((((g{i_2,i_3;a_21565,a_21566}:N-C-S * (C{a_21565;a_2<i_2>}:N-C-S * t{a_2<i_2>;i_2}:N-N-S)) * C{a_21566;a_3<i_1,i_3>}:N-C-S) * t{a_3<i_1,i_3>,a_4<i_1,i_3>;i_1,i_3}:N-N-S) * C{a_1;a_4<i_1,i_3>}:N-C-S) * C{a_1<i_1>;a_1}:N-C-S - 2 (((g{i_2,i_3;a_21558,a_21559}:N-C-S * (C{a_21558;a_2<i_2>}:N-C-S * t{a_2<i_2>;i_2}:N-N-S)) * (C{a_21559;a_3<i_1>}:N-C-S * t{a_3<i_1>;i_1}:N-N-S)) * (C{a_1;a_4<i_3>}:N-C-S * t{a_4<i_3>;i_3}:N-N-S)) * C{a_1<i_1>;a_1}:N-C-S - 1 ((f{i_2;a_21552}:N-C-S * (C{a_21552;a_2<i_1>}:N-C-S * t{a_2<i_1>;i_1}:N-N-S)) * (C{a_1;a_3<i_2>}:N-C-S * t{a_3<i_2>;i_2}:N-N-S)) * C{a_1<i_1>;a_1}:N-C-S - 2 (((g{i_2,i_3;i_1,a_21531}:N-C-S * C{a_21531;a_2<i_2,i_3>}:N-C-S) * t{a_2<i_2,i_3>,a_3<i_2,i_3>;i_3,i_2}:N-N-S) * C{a_1;a_3<i_2,i_3>}:N-C-S) * C{a_1<i_1>;a_1}:N-C-S + (((g{i_2,i_3;i_1,a_21541}:N-C-S * C{a_21541;a_2<i_2,i_3>}:N-C-S) * t{a_2<i_2,i_3>,a_3<i_2,i_3>;i_2,i_3}:N-N-S) * C{a_1;a_3<i_2,i_3>}:N-C-S) * C{a_1<i_1>;a_1}:N-C-S - 1 (((f{i_2;a_21536}:N-C-S * C{a_21536;a_2<i_1,i_2>}:N-C-S) * t{a_2<i_1,i_2>,a_3<i_1,i_2>;i_1,i_2}:N-N-S) * C{a_1;a_3<i_1,i_2>}:N-C-S) * C{a_1<i_1>;a_1}:N-C-S + 2 (((f{i_2;a_21537}:N-C-S * C{a_21537;a_2<i_1,i_2>}:N-C-S) * t{a_2<i_1,i_2>,a_3<i_1,i_2>;i_2,i_1}:N-N-S) * C{a_1;a_3<i_1,i_2>}:N-C-S) * C{a_1<i_1>;a_1}:N-C-S + f{a_21553;i_1}:N-C-S * C{a_1<i_1>;a_21553}:N-C-S
-==== Rs[2] ====
-4 (((g{i_3,a_21569;a_21570,a_21571}:N-C-S * (C{a_21570;a_3<i_3>}:N-C-S * t{a_3<i_3>;i_3}:N-N-S)) * C{a_2<i_1,i_2>;a_21569}:N-C-S) * C{a_21571;a_4<i_1,i_2>}:N-C-S) * t{a_1<i_1,i_2>,a_4<i_1,i_2>;i_1,i_2}:N-N-S - 2 (((g{i_3,a_21572;a_21573,a_21574}:N-C-S * (C{a_21573;a_3<i_1>}:N-C-S * t{a_3<i_1>;i_1}:N-N-S)) * ((C{a_21574;a_4<i_2,i_3>}:N-C-S * t{a_4<i_2,i_3>,a_5<i_2,i_3>;i_2,i_3}:N-N-S) * C{a_1;a_5<i_2,i_3>}:N-C-S)) * C{a_2<i_1,i_2>;a_21572}:N-C-S) * C{a_1<i_1,i_2>;a_1}:N-C-S + 2 ((g{i_3,i_4;i_2,a_21575}:N-C-S * ((C{a_21575;a_3<i_1,i_3>}:N-C-S * t{a_3<i_1,i_3>,a_4<i_1,i_3>;i_1,i_3}:N-N-S) * C{a_2;a_4<i_1,i_3>}:N-C-S)) * C{a_2<i_1,i_2>;a_2}:N-C-S) * (C{a_1<i_1,i_2>;a_1}:N-C-S * (C{a_1;a_5<i_4>}:N-C-S * t{a_5<i_4>;i_4}:N-N-S)) + 2 ((g{i_3,i_4;i_2,a_21576}:N-C-S * ((C{a_21576;a_3<i_1,i_3>}:N-C-S * t{a_3<i_1,i_3>,a_4<i_1,i_3>;i_3,i_1}:N-N-S) * C{a_1;a_4<i_1,i_3>}:N-C-S)) * C{a_1<i_1,i_2>;a_1}:N-C-S) * (C{a_2<i_1,i_2>;a_2}:N-C-S * (C{a_2;a_5<i_4>}:N-C-S * t{a_5<i_4>;i_4}:N-N-S)) + 2 (((g{i_3,i_4;a_21579,a_21580}:N-C-S * (C{a_21579;a_3<i_2>}:N-C-S * t{a_3<i_2>;i_2}:N-N-S)) * ((C{a_21580;a_4<i_1,i_4>}:N-C-S * t{a_4<i_1,i_4>,a_5<i_1,i_4>;i_1,i_4}:N-N-S) * C{a_1;a_5<i_1,i_4>}:N-C-S)) * C{a_1<i_1,i_2>;a_1}:N-C-S) * (C{a_2<i_1,i_2>;a_2}:N-C-S * (C{a_2;a_6<i_3>}:N-C-S * t{a_6<i_3>;i_3}:N-N-S)) - 4 (((g{i_3,i_4;a_21583,a_21584}:N-C-S * (C{a_21583;a_3<i_2>}:N-C-S * t{a_3<i_2>;i_2}:N-N-S)) * ((C{a_21584;a_4<i_1,i_4>}:N-C-S * t{a_4<i_1,i_4>,a_5<i_1,i_4>;i_4,i_1}:N-N-S) * C{a_1;a_5<i_1,i_4>}:N-C-S)) * C{a_1<i_1,i_2>;a_1}:N-C-S) * (C{a_2<i_1,i_2>;a_2}:N-C-S * (C{a_2;a_6<i_3>}:N-C-S * t{a_6<i_3>;i_3}:N-N-S)) - 2 ((g{i_3,a_21607;a_21608,i_2}:N-C-S * (C{a_21608;a_3<i_1>}:N-C-S * t{a_3<i_1>;i_1}:N-N-S)) * C{a_2<i_1,i_2>;a_21607}:N-C-S) * (C{a_1<i_1,i_2>;a_1}:N-C-S * (C{a_1;a_4<i_3>}:N-C-S * t{a_4<i_3>;i_3}:N-N-S)) + (g{i_3,i_4;i_1,i_2}:N-C-S * (C{a_1<i_1,i_2>;a_1}:N-C-S * (C{a_1;a_3<i_3>}:N-C-S * t{a_3<i_3>;i_3}:N-N-S))) * (C{a_2<i_1,i_2>;a_2}:N-C-S * (C{a_2;a_4<i_4>}:N-C-S * t{a_4<i_4>;i_4}:N-N-S)) + 2 ((g{i_3,i_4;i_2,a_21623}:N-C-S * (C{a_21623;a_3<i_1>}:N-C-S * t{a_3<i_1>;i_1}:N-N-S)) * (C{a_1<i_1,i_2>;a_1}:N-C-S * (C{a_1;a_4<i_4>}:N-C-S * t{a_4<i_4>;i_4}:N-N-S))) * (C{a_2<i_1,i_2>;a_2}:N-C-S * (C{a_2;a_5<i_3>}:N-C-S * t{a_5<i_3>;i_3}:N-N-S)) + 2 (((g{i_3,i_4;i_1,a_21674}:N-C-S * (C{a_21674;a_3<i_2>}:N-C-S * t{a_3<i_2>;i_2}:N-N-S)) * ((C{a_1;a_4<i_3,i_4>}:N-C-S * t{a_4<i_3,i_4>,a_5<i_3,i_4>;i_3,i_4}:N-N-S) * C{a_2;a_5<i_3,i_4>}:N-C-S)) * C{a_1<i_1,i_2>;a_1}:N-C-S) * C{a_2<i_1,i_2>;a_2}:N-C-S - 4 ((g{i_3,i_4;i_2,a_21626}:N-C-S * ((C{a_21626;a_3<i_1,i_4>}:N-C-S * t{a_3<i_1,i_4>,a_4<i_1,i_4>;i_4,i_1}:N-N-S) * C{a_1;a_4<i_1,i_4>}:N-C-S)) * C{a_1<i_1,i_2>;a_1}:N-C-S) * (C{a_2<i_1,i_2>;a_2}:N-C-S * (C{a_2;a_5<i_3>}:N-C-S * t{a_5<i_3>;i_3}:N-N-S)) + 2 (((g{i_3,i_4;a_21633,a_21634}:N-C-S * (C{a_21633;a_3<i_2>}:N-C-S * t{a_3<i_2>;i_2}:N-N-S)) * ((C{a_21634;a_4<i_1,i_3>}:N-C-S * t{a_4<i_1,i_3>,a_6<i_1,i_3>;i_1,i_3}:N-N-S) * C{a_2;a_6<i_1,i_3>}:N-C-S)) * C{a_2<i_1,i_2>;a_2}:N-C-S) * (C{a_1<i_1,i_2>;a_1}:N-C-S * (C{a_1;a_5<i_4>}:N-C-S * t{a_5<i_4>;i_4}:N-N-S)) + ((g{i_3,i_4;a_21637,a_21638}:N-C-S * ((C{a_21637;a_3<i_1,i_2>}:N-C-S * t{a_3<i_1,i_2>,a_4<i_1,i_2>;i_1,i_2}:N-N-S) * C{a_21638;a_4<i_1,i_2>}:N-C-S)) * (C{a_1<i_1,i_2>;a_1}:N-C-S * (C{a_1;a_5<i_3>}:N-C-S * t{a_5<i_3>;i_3}:N-N-S))) * (C{a_2<i_1,i_2>;a_2}:N-C-S * (C{a_2;a_6<i_4>}:N-C-S * t{a_6<i_4>;i_4}:N-N-S)) + 2 ((g{i_3,i_4;i_2,a_21642}:N-C-S * ((C{a_21642;a_3<i_1,i_4>}:N-C-S * t{a_3<i_1,i_4>,a_4<i_1,i_4>;i_1,i_4}:N-N-S) * C{a_1;a_4<i_1,i_4>}:N-C-S)) * C{a_1<i_1,i_2>;a_1}:N-C-S) * (C{a_2<i_1,i_2>;a_2}:N-C-S * (C{a_2;a_5<i_3>}:N-C-S * t{a_5<i_3>;i_3}:N-N-S)) - 2 ((g{i_3,a_21645;i_2,a_21646}:N-C-S * (C{a_21646;a_3<i_1>}:N-C-S * t{a_3<i_1>;i_1}:N-N-S)) * C{a_1<i_1,i_2>;a_21645}:N-C-S) * (C{a_2<i_1,i_2>;a_2}:N-C-S * (C{a_2;a_4<i_3>}:N-C-S * t{a_4<i_3>;i_3}:N-N-S)) - 4 (((g{i_3,i_4;a_21649,a_21650}:N-C-S * (C{a_21649;a_3<i_3>}:N-C-S * t{a_3<i_3>;i_3}:N-N-S)) * C{a_21650;a_4<i_1,i_2>}:N-C-S) * t{a_1<i_1,i_2>,a_4<i_1,i_2>;i_1,i_2}:N-N-S) * (C{a_2<i_1,i_2>;a_2}:N-C-S * (C{a_2;a_5<i_4>}:N-C-S * t{a_5<i_4>;i_4}:N-N-S)) - 2 ((g{i_3,a_21651;a_21652,a_21653}:N-C-S * ((C{a_21652;a_3<i_1,i_2>}:N-C-S * t{a_3<i_1,i_2>,a_4<i_1,i_2>;i_2,i_1}:N-N-S) * C{a_21653;a_4<i_1,i_2>}:N-C-S)) * C{a_1<i_1,i_2>;a_21651}:N-C-S) * (C{a_2<i_1,i_2>;a_2}:N-C-S * (C{a_2;a_5<i_3>}:N-C-S * t{a_5<i_3>;i_3}:N-N-S)) + 2 (((g{i_3,i_4;a_21654,a_21655}:N-C-S * (C{a_21654;a_3<i_4>}:N-C-S * t{a_3<i_4>;i_4}:N-N-S)) * C{a_21655;a_4<i_1,i_2>}:N-C-S) * t{a_1<i_1,i_2>,a_4<i_1,i_2>;i_1,i_2}:N-N-S) * (C{a_2<i_1,i_2>;a_2}:N-C-S * (C{a_2;a_5<i_3>}:N-C-S * t{a_5<i_3>;i_3}:N-N-S)) + 2 ((((g{i_3,i_4;a_21659,a_21660}:N-C-S * (C{a_21659;a_3<i_4>}:N-C-S * t{a_3<i_4>;i_4}:N-N-S)) * (C{a_21660;a_4<i_2>}:N-C-S * t{a_4<i_2>;i_2}:N-N-S)) * ((C{a_1;a_5<i_1,i_3>}:N-C-S * t{a_5<i_1,i_3>,a_6<i_1,i_3>;i_1,i_3}:N-N-S) * C{a_2;a_6<i_1,i_3>}:N-C-S)) * C{a_1<i_1,i_2>;a_1}:N-C-S) * C{a_2<i_1,i_2>;a_2}:N-C-S - 2 (((g{i_3,a_21656;a_21657,a_21658}:N-C-S * (C{a_21657;a_3<i_2>}:N-C-S * t{a_3<i_2>;i_2}:N-N-S)) * (C{a_21658;a_4<i_1>}:N-C-S * t{a_4<i_1>;i_1}:N-N-S)) * C{a_1<i_1,i_2>;a_21656}:N-C-S) * (C{a_2<i_1,i_2>;a_2}:N-C-S * (C{a_2;a_5<i_3>}:N-C-S * t{a_5<i_3>;i_3}:N-N-S)) - 2 ((f{i_3;a_21661}:N-C-S * C{a_21661;a_3<i_1,i_2>}:N-C-S) * t{a_1<i_1,i_2>,a_3<i_1,i_2>;i_1,i_2}:N-N-S) * (C{a_2<i_1,i_2>;a_2}:N-C-S * (C{a_2;a_4<i_3>}:N-C-S * t{a_4<i_3>;i_3}:N-N-S)) + (((g{i_3,i_4;a_21662,a_21663}:N-C-S * (C{a_21662;a_3<i_1>}:N-C-S * t{a_3<i_1>;i_1}:N-N-S)) * (C{a_21663;a_4<i_2>}:N-C-S * t{a_4<i_2>;i_2}:N-N-S)) * (C{a_1<i_1,i_2>;a_1}:N-C-S * (C{a_1;a_5<i_3>}:N-C-S * t{a_5<i_3>;i_3}:N-N-S))) * (C{a_2<i_1,i_2>;a_2}:N-C-S * (C{a_2;a_6<i_4>}:N-C-S * t{a_6<i_4>;i_4}:N-N-S)) + 2 (((g{i_3,i_4;a_21671,a_21672}:N-C-S * (C{a_21671;a_3<i_2>}:N-C-S * t{a_3<i_2>;i_2}:N-N-S)) * ((C{a_21672;a_4<i_1,i_3>}:N-C-S * t{a_4<i_1,i_3>,a_5<i_1,i_3>;i_3,i_1}:N-N-S) * C{a_1;a_5<i_1,i_3>}:N-C-S)) * C{a_1<i_1,i_2>;a_1}:N-C-S) * (C{a_2<i_1,i_2>;a_2}:N-C-S * (C{a_2;a_6<i_4>}:N-C-S * t{a_6<i_4>;i_4}:N-N-S)) - 2 (g{i_3,a_21673;i_2,i_1}:N-C-S * C{a_1<i_1,i_2>;a_21673}:N-C-S) * (C{a_2<i_1,i_2>;a_2}:N-C-S * (C{a_2;a_3<i_3>}:N-C-S * t{a_3<i_3>;i_3}:N-N-S)) + ((((g{i_3,i_4;a_21577,a_21578}:N-C-S * (C{a_21577;a_3<i_1>}:N-C-S * t{a_3<i_1>;i_1}:N-N-S)) * (C{a_21578;a_4<i_2>}:N-C-S * t{a_4<i_2>;i_2}:N-N-S)) * ((C{a_1;a_5<i_3,i_4>}:N-C-S * t{a_5<i_3,i_4>,a_6<i_3,i_4>;i_3,i_4}:N-N-S) * C{a_2;a_6<i_3,i_4>}:N-C-S)) * C{a_1<i_1,i_2>;a_1}:N-C-S) * C{a_2<i_1,i_2>;a_2}:N-C-S - 2 (((g{i_3,i_4;a_21581,a_21582}:N-C-S * ((C{a_21581;a_3<i_2,i_4>}:N-C-S * t{a_3<i_2,i_4>,a_6<i_2,i_4>;i_4,i_2}:N-N-S) * C{a_2;a_6<i_2,i_4>}:N-C-S)) * ((C{a_21582;a_4<i_1,i_3>}:N-C-S * t{a_4<i_1,i_3>,a_5<i_1,i_3>;i_3,i_1}:N-N-S) * C{a_1;a_5<i_1,i_3>}:N-C-S)) * C{a_1<i_1,i_2>;a_1}:N-C-S) * C{a_2<i_1,i_2>;a_2}:N-C-S + 2 (((g{i_3,i_4;a_21643,a_21644}:N-C-S * ((C{a_21643;a_3<i_1,i_4>}:N-C-S * t{a_3<i_1,i_4>,a_5<i_1,i_4>;i_4,i_1}:N-N-S) * C{a_1;a_5<i_1,i_4>}:N-C-S)) * ((C{a_21644;a_4<i_2,i_3>}:N-C-S * t{a_4<i_2,i_3>,a_6<i_2,i_3>;i_2,i_3}:N-N-S) * C{a_2;a_6<i_2,i_3>}:N-C-S)) * C{a_1<i_1,i_2>;a_1}:N-C-S) * C{a_2<i_1,i_2>;a_2}:N-C-S + 4 (((g{i_3,a_21589;a_21590,a_21591}:N-C-S * (C{a_21591;a_4<i_2>}:N-C-S * t{a_4<i_2>;i_2}:N-N-S)) * ((C{a_21590;a_3<i_1,i_3>}:N-C-S * t{a_3<i_1,i_3>,a_5<i_1,i_3>;i_3,i_1}:N-N-S) * C{a_1;a_5<i_1,i_3>}:N-C-S)) * C{a_2<i_1,i_2>;a_21589}:N-C-S) * C{a_1<i_1,i_2>;a_1}:N-C-S - 2 (((g{i_3,a_21664;a_21665,a_21666}:N-C-S * (C{a_21666;a_4<i_2>}:N-C-S * t{a_4<i_2>;i_2}:N-N-S)) * ((C{a_21665;a_3<i_1,i_3>}:N-C-S * t{a_3<i_1,i_3>,a_5<i_1,i_3>;i_1,i_3}:N-N-S) * C{a_1;a_5<i_1,i_3>}:N-C-S)) * C{a_2<i_1,i_2>;a_21664}:N-C-S) * C{a_1<i_1,i_2>;a_1}:N-C-S - 4 ((((g{i_3,i_4;a_21592,a_21593}:N-C-S * (C{a_21592;a_3<i_3>}:N-C-S * t{a_3<i_3>;i_3}:N-N-S)) * (C{a_21593;a_4<i_2>}:N-C-S * t{a_4<i_2>;i_2}:N-N-S)) * ((C{a_1;a_5<i_1,i_4>}:N-C-S * t{a_5<i_1,i_4>,a_6<i_1,i_4>;i_1,i_4}:N-N-S) * C{a_2;a_6<i_1,i_4>}:N-C-S)) * C{a_1<i_1,i_2>;a_1}:N-C-S) * C{a_2<i_1,i_2>;a_2}:N-C-S + 4 (((g{i_3,i_4;a_21597,a_21598}:N-C-S * ((C{a_21597;a_3<i_1,i_3>}:N-C-S * t{a_3<i_1,i_3>,a_5<i_1,i_3>;i_3,i_1}:N-N-S) * C{a_1;a_5<i_1,i_3>}:N-C-S)) * ((C{a_21598;a_4<i_2,i_4>}:N-C-S * t{a_4<i_2,i_4>,a_6<i_2,i_4>;i_4,i_2}:N-N-S) * C{a_2;a_6<i_2,i_4>}:N-C-S)) * C{a_1<i_1,i_2>;a_1}:N-C-S) * C{a_2<i_1,i_2>;a_2}:N-C-S - 4 (((g{i_3,i_4;a_21610,a_21611}:N-C-S * ((C{a_21610;a_3<i_1,i_3>}:N-C-S * t{a_3<i_1,i_3>,a_5<i_1,i_3>;i_3,i_1}:N-N-S) * C{a_1;a_5<i_1,i_3>}:N-C-S)) * ((C{a_21611;a_4<i_2,i_4>}:N-C-S * t{a_4<i_2,i_4>,a_6<i_2,i_4>;i_2,i_4}:N-N-S) * C{a_2;a_6<i_2,i_4>}:N-C-S)) * C{a_1<i_1,i_2>;a_1}:N-C-S) * C{a_2<i_1,i_2>;a_2}:N-C-S + ((g{i_3,i_4;i_1,i_2}:N-C-S * ((C{a_1;a_3<i_3,i_4>}:N-C-S * t{a_3<i_3,i_4>,a_4<i_3,i_4>;i_3,i_4}:N-N-S) * C{a_2;a_4<i_3,i_4>}:N-C-S)) * C{a_1<i_1,i_2>;a_1}:N-C-S) * C{a_2<i_1,i_2>;a_2}:N-C-S - 2 ((g{i_3,a_21601;i_1,a_21602}:N-C-S * ((C{a_21602;a_3<i_2,i_3>}:N-C-S * t{a_3<i_2,i_3>,a_4<i_2,i_3>;i_2,i_3}:N-N-S) * C{a_1;a_4<i_2,i_3>}:N-C-S)) * C{a_2<i_1,i_2>;a_21601}:N-C-S) * C{a_1<i_1,i_2>;a_1}:N-C-S - 2 ((f{i_3;i_2}:N-C-S * ((C{a_1;a_3<i_1,i_3>}:N-C-S * t{a_3<i_1,i_3>,a_4<i_1,i_3>;i_1,i_3}:N-N-S) * C{a_2;a_4<i_1,i_3>}:N-C-S)) * C{a_1<i_1,i_2>;a_1}:N-C-S) * C{a_2<i_1,i_2>;a_2}:N-C-S - 4 (((g{i_3,i_4;a_21603,a_21604}:N-C-S * ((C{a_21603;a_3<i_2,i_4>}:N-C-S * t{a_3<i_2,i_4>,a_4<i_2,i_4>;i_2,i_4}:N-N-S) * C{a_21604;a_4<i_2,i_4>}:N-C-S)) * ((C{a_1;a_5<i_1,i_3>}:N-C-S * t{a_5<i_1,i_3>,a_6<i_1,i_3>;i_1,i_3}:N-N-S) * C{a_2;a_6<i_1,i_3>}:N-C-S)) * C{a_1<i_1,i_2>;a_1}:N-C-S) * C{a_2<i_1,i_2>;a_2}:N-C-S - 2 ((g{i_3,a_21605;i_1,a_21606}:N-C-S * ((C{a_21606;a_3<i_2,i_3>}:N-C-S * t{a_3<i_2,i_3>,a_4<i_2,i_3>;i_3,i_2}:N-N-S) * C{a_2;a_4<i_2,i_3>}:N-C-S)) * C{a_1<i_1,i_2>;a_21605}:N-C-S) * C{a_2<i_1,i_2>;a_2}:N-C-S - 4 (((g{i_3,i_4;i_1,a_21609}:N-C-S * (C{a_21609;a_3<i_4>}:N-C-S * t{a_3<i_4>;i_4}:N-N-S)) * ((C{a_1;a_4<i_2,i_3>}:N-C-S * t{a_4<i_2,i_3>,a_5<i_2,i_3>;i_3,i_2}:N-N-S) * C{a_2;a_5<i_2,i_3>}:N-C-S)) * C{a_1<i_1,i_2>;a_1}:N-C-S) * C{a_2<i_1,i_2>;a_2}:N-C-S + 2 (((g{i_3,i_4;i_2,a_21612}:N-C-S * (C{a_21612;a_3<i_3>}:N-C-S * t{a_3<i_3>;i_3}:N-N-S)) * ((C{a_1;a_4<i_1,i_4>}:N-C-S * t{a_4<i_1,i_4>,a_5<i_1,i_4>;i_1,i_4}:N-N-S) * C{a_2;a_5<i_1,i_4>}:N-C-S)) * C{a_1<i_1,i_2>;a_1}:N-C-S) * C{a_2<i_1,i_2>;a_2}:N-C-S + (((g{i_3,i_4;a_21615,a_21616}:N-C-S * ((C{a_21615;a_3<i_1,i_2>}:N-C-S * t{a_3<i_1,i_2>,a_4<i_1,i_2>;i_1,i_2}:N-N-S) * C{a_21616;a_4<i_1,i_2>}:N-C-S)) * ((C{a_1;a_5<i_3,i_4>}:N-C-S * t{a_5<i_3,i_4>,a_6<i_3,i_4>;i_3,i_4}:N-N-S) * C{a_2;a_6<i_3,i_4>}:N-C-S)) * C{a_1<i_1,i_2>;a_1}:N-C-S) * C{a_2<i_1,i_2>;a_2}:N-C-S - 2 (((f{i_3;a_21617}:N-C-S * (C{a_21617;a_3<i_1>}:N-C-S * t{a_3<i_1>;i_1}:N-N-S)) * ((C{a_1;a_4<i_2,i_3>}:N-C-S * t{a_4<i_2,i_3>,a_5<i_2,i_3>;i_3,i_2}:N-N-S) * C{a_2;a_5<i_2,i_3>}:N-C-S)) * C{a_1<i_1,i_2>;a_1}:N-C-S) * C{a_2<i_1,i_2>;a_2}:N-C-S - 2 ((g{i_3,a_21618;a_21619,i_1}:N-C-S * ((C{a_21619;a_3<i_2,i_3>}:N-C-S * t{a_3<i_2,i_3>,a_4<i_2,i_3>;i_2,i_3}:N-N-S) * C{a_2;a_4<i_2,i_3>}:N-C-S)) * C{a_1<i_1,i_2>;a_21618}:N-C-S) * C{a_2<i_1,i_2>;a_2}:N-C-S + 2 (((g{i_3,i_4;a_21627,a_21628}:N-C-S * ((C{a_21627;a_3<i_2,i_3>}:N-C-S * t{a_3<i_2,i_3>,a_4<i_2,i_3>;i_2,i_3}:N-N-S) * C{a_21628;a_4<i_2,i_3>}:N-C-S)) * ((C{a_1;a_5<i_1,i_4>}:N-C-S * t{a_5<i_1,i_4>,a_6<i_1,i_4>;i_1,i_4}:N-N-S) * C{a_2;a_6<i_1,i_4>}:N-C-S)) * C{a_1<i_1,i_2>;a_1}:N-C-S) * C{a_2<i_1,i_2>;a_2}:N-C-S + (((g{i_3,i_4;a_21631,a_21632}:N-C-S * ((C{a_21631;a_3<i_1,i_3>}:N-C-S * t{a_3<i_1,i_3>,a_5<i_1,i_3>;i_1,i_3}:N-N-S) * C{a_1;a_5<i_1,i_3>}:N-C-S)) * ((C{a_21632;a_4<i_2,i_4>}:N-C-S * t{a_4<i_2,i_4>,a_6<i_2,i_4>;i_2,i_4}:N-N-S) * C{a_2;a_6<i_2,i_4>}:N-C-S)) * C{a_1<i_1,i_2>;a_1}:N-C-S) * C{a_2<i_1,i_2>;a_2}:N-C-S + 4 ((g{i_3,a_21635;a_21636,i_1}:N-C-S * ((C{a_21636;a_3<i_2,i_3>}:N-C-S * t{a_3<i_2,i_3>,a_4<i_2,i_3>;i_3,i_2}:N-N-S) * C{a_2;a_4<i_2,i_3>}:N-C-S)) * C{a_1<i_1,i_2>;a_21635}:N-C-S) * C{a_2<i_1,i_2>;a_2}:N-C-S - 2 (((g{i_3,a_21639;a_21640,a_21641}:N-C-S * (C{a_21640;a_3<i_1>}:N-C-S * t{a_3<i_1>;i_1}:N-N-S)) * ((C{a_21641;a_4<i_2,i_3>}:N-C-S * t{a_4<i_2,i_3>,a_5<i_2,i_3>;i_3,i_2}:N-N-S) * C{a_2;a_5<i_2,i_3>}:N-C-S)) * C{a_1<i_1,i_2>;a_21639}:N-C-S) * C{a_2<i_1,i_2>;a_2}:N-C-S + (((g{i_3,i_4;a_21647,a_21648}:N-C-S * ((C{a_21647;a_3<i_2,i_4>}:N-C-S * t{a_3<i_2,i_4>,a_5<i_2,i_4>;i_2,i_4}:N-N-S) * C{a_1;a_5<i_2,i_4>}:N-C-S)) * ((C{a_21648;a_4<i_1,i_3>}:N-C-S * t{a_4<i_1,i_3>,a_6<i_1,i_3>;i_1,i_3}:N-N-S) * C{a_2;a_6<i_1,i_3>}:N-C-S)) * C{a_1<i_1,i_2>;a_1}:N-C-S) * C{a_2<i_1,i_2>;a_2}:N-C-S + ((g{a_21667,a_21668;a_21669,a_21670}:N-C-S * ((C{a_21669;a_3<i_1,i_2>}:N-C-S * t{a_3<i_1,i_2>,a_4<i_1,i_2>;i_1,i_2}:N-N-S) * C{a_21670;a_4<i_1,i_2>}:N-C-S)) * C{a_1<i_1,i_2>;a_21667}:N-C-S) * C{a_2<i_1,i_2>;a_21668}:N-C-S + (((g{a_21585,a_21586;a_21587,a_21588}:N-C-S * (C{a_21587;a_3<i_1>}:N-C-S * t{a_3<i_1>;i_1}:N-N-S)) * (C{a_21588;a_4<i_2>}:N-C-S * t{a_4<i_2>;i_2}:N-N-S)) * C{a_1<i_1,i_2>;a_21585}:N-C-S) * C{a_2<i_1,i_2>;a_21586}:N-C-S - 2 (((g{i_3,a_21594;a_21595,a_21596}:N-C-S * (C{a_21596;a_4<i_3>}:N-C-S * t{a_4<i_3>;i_3}:N-N-S)) * C{a_2<i_1,i_2>;a_21594}:N-C-S) * C{a_21595;a_3<i_1,i_2>}:N-C-S) * t{a_1<i_1,i_2>,a_3<i_1,i_2>;i_1,i_2}:N-N-S + 2 ((g{a_21620,a_21621;i_1,a_21622}:N-C-S * (C{a_21622;a_3<i_2>}:N-C-S * t{a_3<i_2>;i_2}:N-N-S)) * C{a_1<i_1,i_2>;a_21620}:N-C-S) * C{a_2<i_1,i_2>;a_21621}:N-C-S + 2 (((((g{i_3,i_4;a_21599,a_21600}:N-C-S * C{a_21600;a_4<i_3,i_4>}:N-C-S) * t{a_4<i_3,i_4>,a_5<i_3,i_4>;i_3,i_4}:N-N-S) * C{a_2;a_5<i_3,i_4>}:N-C-S) * C{a_21599;a_3<i_1,i_2>}:N-C-S) * C{a_2<i_1,i_2>;a_2}:N-C-S) * t{a_1<i_1,i_2>,a_3<i_1,i_2>;i_1,i_2}:N-N-S - 4 (((((g{i_3,i_4;a_21613,a_21614}:N-C-S * C{a_21613;a_3<i_3,i_4>}:N-C-S) * t{a_3<i_3,i_4>,a_5<i_3,i_4>;i_3,i_4}:N-N-S) * C{a_2;a_5<i_3,i_4>}:N-C-S) * C{a_21614;a_4<i_1,i_2>}:N-C-S) * C{a_2<i_1,i_2>;a_2}:N-C-S) * t{a_1<i_1,i_2>,a_4<i_1,i_2>;i_1,i_2}:N-N-S + (g{a_21624,a_21625;i_1,i_2}:N-C-S * C{a_1<i_1,i_2>;a_21624}:N-C-S) * C{a_2<i_1,i_2>;a_21625}:N-C-S + 2 ((f{a_21629;a_21630}:N-C-S * C{a_2<i_1,i_2>;a_21629}:N-C-S) * C{a_21630;a_3<i_1,i_2>}:N-C-S) * t{a_1<i_1,i_2>,a_3<i_1,i_2>;i_1,i_2}:N-N-S
diff --git a/tests/unit/test_eval_dryrun.cpp b/tests/unit/test_eval_dryrun.cpp
index 493686e3ea..df122f4f3a 100644
--- a/tests/unit/test_eval_dryrun.cpp
+++ b/tests/unit/test_eval_dryrun.cpp
@@ -1,42 +1,20 @@
-// Task 1 (DryRun eval backend, Phase 1): infrastructure + DP-inspection
-// mechanics for the eventual go/no-go probe on the C60 batched-schedule
-// factorization.
+// DryRun eval backend tests: size model + batched-schedule cost/peak analysis
+// for PNO-CCSD, anchored on the real POST-transform C60 residual.
 //
-// SCOPE NOTE (two course corrections; see task-1-report.md for the full
-// history): the committed fixture `data/csv_ccsd_residual.txt` (mpqc's
-// `csv_eqn_Rs.serialized`) is a PRE-transform residual: every two-electron
-// integral `g` is still 4-index (`g{i,i;a,a}`-shaped), there is no auxiliary
-// DF ("K"/Kappa) index anywhere in it, and the non-proto `a_NNNNN` indices are
-// the GENERIC BASE VIRTUAL space, NOT the PAO ("mu~") space -- PAO and DF aux
-// are introduced downstream by mpqc's CSV->base-integral transform and
-// density-fitting refactorization, which run in mpqc's own pipeline against
-// mpqc's extended LCAO space registry, not the standalone SeQuant mbpt
-// registry this test has access to. So:
-//   - the two K-based memsize anchors from the cluster trace (~1.87 GB /
-//     ~186 GB) are NOT reproducible from this fixture, and this file does not
-//     attempt them (see the self-consistency case below instead);
-//   - a faithful PAO/K batch-axis GO/NO-GO VERDICT is NOT obtainable from this
-//     pre-transform fixture either, since the factorizer that produced the
-//     C60 trace ran on the POST-transform (mu~ + K) form. That verdict is
-//     deferred to a follow-up once a post-transform fixture is available.
-//
-// What this file DOES deliver and verify, against the real residual:
-//   1. the deserialize path works under the standalone mbpt context (mirrors
-//      test_optimize.cpp's context setup), and reports the term count;
-//   2. the DP-inspection MECHANICS work end-to-end: running optimize() with
-//      objective_function = DensePeakSizeBatched and a finite peak_threshold,
-//      using a generic (stand-in) batchable predicate over the base virtual
-//      space "a", and reading back per-node batch_axes() via
-//      OptimizeOptions::term_batch_axes -> BinarizationOptions::
-//      node_batch_axes -> binarize() -> EvalExpr::batch_axes(). This is the
-//      exact plumbing later tasks (and the eventual real verdict) will reuse;
-//      it is explicitly NOT a PAO/mu~ finding (see the log labelling below);
-//   3. a harness self-check with a tiny forced peak_threshold, proving the
-//      plumbing CAN produce a non-empty batch_axes annotation when the DP is
-//      forced to batch (rules out "the harness can't express batching" as an
-//      explanation for whatever the mechanics case observes);
-//   4. a self-consistency memsize check against SizeRegime's own extents/
-//      moments (replaces the unreachable cluster K-anchors).
+// Two groups:
+//   1. SizeRegime / CostModel / Result unit tests -- extent lookup, moment-
+//      aware (power-mean) composite sizing, rank-general CSV moment dispatch,
+//      and the DryRun Result primitives (prod/slice/mode_batches/size).
+//   2. Batched-schedule analysis on the real post-transform fixture
+//      data/csv_ccsd_doubles_residual_df.txt (the CSV-CCSD doubles residual
+//      dumped from mpqc AFTER the CSV->PAO base transform + DF refactorization,
+//      so it carries the real PAO index mu~, DF-aux K, 3-center g{mu~;i;K}, and
+//      CSV coefficients C{a<i>;mu~}). These cases optimize/binarize the
+//      residual under the faithful C60-scale SizeRegime + BatchPolicy and
+//      inspect the DP's batch-axis verdict, the perf-first vs peak-first
+//      factorization of the free-mu~ giant, the gated dry-run cache veto, and
+//      the scratch-folded batched peak via the shared cost_profile() entry
+//      point.
 
 // Flip Trace::Default -> Trace::On for this ENTIRE translation unit (must
 // precede every SeQuant/core/eval/eval.hpp inclusion, directly or
@@ -108,32 +86,12 @@ std::string slurp(std::string const& path) {
   return ss.str();
 }
 
-// The fixture is mpqc's raw debug dump: three "==== Rs[k] ====" header lines,
-// each immediately followed by one line holding the serialized residual
-// member k (a Sum of Products). Strip the headers; return the three
-// expression lines in order.
-std::vector<std::string> split_residual_members(std::string const& text) {
-  std::vector<std::string> members;
-  std::istringstream in(text);
-  std::string line;
-  while (std::getline(in, line)) {
-    if (line.empty() || line.rfind("====", 0) == 0) continue;
-    members.push_back(line);
-  }
-  return members;
-}
-
-// Stand-in regime for the pre-transform residual: extents are plausible
-// order-of-magnitude values (the real per-atom/per-basis extents live in
-// mpqc's post-transform pipeline, not reachable from a bare SeQuant unit
-// test -- see the file header). `a` is dual-purpose exactly as in mpqc's
-// ctx.idx_to_extent (cck.ipp): a bare (non-proto) occurrence is the generic
-// base virtual (sized by space_extent); a proto-indexed occurrence is a PNO
-// (2 protos) or OSV (1 proto) domain composite (sized by the moment tables).
-// NOTE: bare "a" here is NOT the PAO ("mu~") space (see file header) -- it is
-// used only as a stand-in batchable axis to exercise the DP-inspection
-// mechanics below.
-SizeRegime c60_regime() {
+// Small order-of-magnitude regime for the SizeRegime/memsize contract tests
+// below. `a` is dual-purpose exactly as in mpqc's ctx.idx_to_extent (cck.ipp):
+// a bare (non-proto) occurrence is the generic base virtual (sized by
+// space_extent); a proto-indexed occurrence is a PNO (2 protos) or OSV (1
+// proto) domain composite (sized by the moment tables).
+SizeRegime probe_regime() {
   SizeRegime r;
   r.space_extent = {
       {L"i", 120},   // active occupied (order-of-magnitude stand-in)
@@ -148,16 +106,6 @@ SizeRegime c60_regime() {
   return r;
 }
 
-// Stand-in batchable predicate for the mechanics check: a non-proto-indexed
-// index in the (generic base virtual) space "a". This is NOT a claim that "a"
-// is the PAO space -- see the file header. It only needs to pick SOME
-// contracted index so the DP-inspection round-trip (OptimizeOptions ->
-// term_batch_axes -> BinarizationOptions -> binarize -> EvalExpr::
-// batch_axes()) can be exercised end-to-end against the real residual.
-bool is_stand_in_batchable(Index const& ix) {
-  return ix.space().base_key() == L"a" && !ix.has_proto_indices();
-}
-
 // Free (external) indices of a binarized-tree node's result, read off its
 // EvalExpr tensor (scalar-result nodes return an empty vector).
 std::vector<Index> node_free_indices(EvalExpr const& n) {
@@ -180,7 +128,7 @@ std::wstring describe_indices(std::vector<Index> const& ixs) {
 }  // namespace
 
 TEST_CASE("dryrun size regime basic extents", "[dryrun-probe]") {
-  auto r = c60_regime();
+  auto r = probe_regime();
   // A bare occ index resolves to its space extent.
   auto i = Index{L"i_1"};
   CHECK(r.extent(i) == 120);
@@ -196,7 +144,7 @@ TEST_CASE("dryrun regime self-consistency (no cluster anchors needed)",
   // extents/moments, and confirm memsize_counter agrees. This validates the
   // size MODEL (extent lookup + inner_pow composite dispatch), independent of
   // whether the specific numeric extents match any particular cluster run.
-  auto r = c60_regime();
+  auto r = probe_regime();
   auto memsize = sequant::opt::detail::memsize_counter(r.idx_to_extent(),
                                                        r.inner_pow_fn());
 
@@ -234,7 +182,7 @@ TEST_CASE("dryrun regime self-consistency (no cluster anchors needed)",
 // over-counting by a further power of k. This pins the contract with a
 // heavy-tailed (non-constant-in-k) moment table so a future regression to
 // raw moments would be caught even though the CURRENT SizeRegime factories
-// in this file (c60_regime/df_regime) all use a constant domain, for which
+// in this file (probe_regime/df_regime) all use a constant domain, for which
 // M_k == d for every k and the bug would otherwise be invisible.
 TEST_CASE("dryrun power-mean sizing contract", "[dryrun][sizing]") {
   // Heavy-tailed PNO domain: power means strictly increasing in k.
@@ -303,286 +251,6 @@ TEST_CASE("dryrun rank-general CSV moment dispatch", "[dryrun][sizing]") {
   CHECK(ip(quad, 2) == Catch::Approx(30.0));
 }
 
-// Sanity check for the probe's own plumbing (is_stand_in_batchable /
-// batch_policy / term_batch_axes / binarize round-trip), independent of the
-// real residual: with a tiny peak_threshold that makes every schedule
-// infeasible except the sliced one, the DP MUST annotate a batch axis
-// somewhere. If this failed it would mean the harness itself cannot express
-// batching (rather than the mechanics case below observing a genuine
-// non-annotation for some other reason).
-TEST_CASE("dryrun harness sanity: forced threshold does annotate a batch axis",
-          "[dryrun-probe]") {
-  auto ctx = get_default_context().clone();
-  ctx.set_first_dummy_index_ordinal(1000000);
-  auto ctx_resetter = set_scoped_default_context(std::move(ctx));
-
-  auto r = c60_regime();
-
-  // 4-tensor network with a_1 shared between the two g's (the only batchable
-  // contraction), mirroring test_optimize.cpp's "binarize stamps per-node
-  // batch axes from optimize()" case but using the stand-in base-virtual
-  // ("a", non-proto) axis instead of a DF aux axis.
-  auto expr = deserialize<ExprPtr>(
-      "g{a_100;i_1;a_1} g{a_101;i_2;a_1} f{i_1;i_3} f{i_2;i_4}");
-  REQUIRE(static_cast<bool>(expr));
-
-  auto axes_map = std::make_shared<std::unordered_map<
-      Expr const*, container::vector<container::svector<Index>>>>();
-
-  OptimizeOptions opts;
-  opts.objective_function = ObjectiveFunction::DensePeakSizeBatched;
-  opts.idx_to_extent = r.idx_to_extent();
-  opts.inner_pow = r.inner_pow_fn();
-  opts.batch_policy.is_batchable_index = [](Index const& ix) {
-    return is_stand_in_batchable(ix);
-  };
-  opts.batch_policy.batch_target_size = [](Index const&) {
-    return std::size_t{20};
-  };
-  opts.batch_policy.peak_threshold = 1.0;  // tiny budget => force batching
-  opts.term_batch_axes = axes_map;
-
-  auto optimized = optimize(expr, opts);
-  REQUIRE(static_cast<bool>(optimized));
-
-  auto it = axes_map->find(optimized.get());
-  REQUIRE(it != axes_map->end());
-  auto const& node_axes = it->second;
-  REQUIRE(!node_axes.empty());
-
-  BinarizationOptions bopts;
-  bopts.node_batch_axes = node_axes;
-
-  SEQUANT_PRAGMA_IGNORE_DEPRECATED_BEGIN
-  auto node = binarize(optimized, {}, bopts);
-  SEQUANT_PRAGMA_IGNORE_DEPRECATED_END
-
-  bool any_annotated = false;
-  bool axis_found = false;
-  node.visit([&](auto const& n) {
-    if (n->batch_axes().empty()) return;
-    any_annotated = true;
-    for (auto const& ix : n->batch_axes())
-      if (is_stand_in_batchable(ix)) axis_found = true;
-  });
-  CHECK(any_annotated);
-  CHECK(axis_found);
-}
-
-TEST_CASE("dryrun residual fixture deserializes", "[dryrun-probe]") {
-  // The fixture's dummy-index ordinals (a_21514, ...) come from mpqc's
-  // globally-incrementing internal counter and can reach into the tens of
-  // thousands; raise first_dummy_index_ordinal well above that so the parser
-  // does not mistake them for SeQuant's own reserved temporary-index range
-  // (default threshold 100, set by test_main.cpp).
-  auto ctx = get_default_context().clone();
-  ctx.set_first_dummy_index_ordinal(1000000);
-  auto ctx_resetter = set_scoped_default_context(std::move(ctx));
-
-  auto const residual = slurp(std::string(SEQUANT_UNIT_TESTS_SOURCE_DIR) +
-                              "/data/csv_ccsd_residual.txt");
-  REQUIRE(!residual.empty());
-  auto members = split_residual_members(residual);
-  REQUIRE(members.size() == 3);
-
-  for (std::size_t k = 0; k < members.size(); ++k) {
-    auto expr = deserialize<ExprPtr>(members[k]);
-    bool const have_expr = static_cast<bool>(expr);
-    REQUIRE(have_expr);
-    std::size_t nterms =
-        expr->is<Sum>() ? expr->as<Sum>().summands().size() : 1;
-    INFO("Rs[" << k << "] term count = " << nterms);
-    CHECK(nterms > 0);
-    std::wcout << L"Rs[" << k << L"] terms=" << nterms << L"\n";
-  }
-}
-
-// DP-inspection MECHANICS check on the real (pre-transform) residual: run
-// optimize() with objective_function = DensePeakSizeBatched and a finite
-// peak_threshold, using the stand-in batchable predicate over the generic
-// base-virtual space "a" (NOT the PAO/mu~ space -- see file header), purely
-// to exercise the API end-to-end and confirm per-node batch_axes() can be
-// read back after optimize(). This is NOT a PAO/mu~ go/no-go verdict; that
-// verdict needs a post-transform (mu~ + K) fixture (follow-up).
-TEST_CASE(
-    "dryrun DP-inspection mechanics on pre-transform residual "
-    "(verdict pending post-transform fixture)",
-    "[dryrun-probe]") {
-  // See the ordinal-range comment in the "residual fixture deserializes"
-  // case above.
-  auto ctx = get_default_context().clone();
-  ctx.set_first_dummy_index_ordinal(1000000);
-  auto ctx_resetter = set_scoped_default_context(std::move(ctx));
-
-  auto const residual = slurp(std::string(SEQUANT_UNIT_TESTS_SOURCE_DIR) +
-                              "/data/csv_ccsd_residual.txt");
-  auto members = split_residual_members(residual);
-  REQUIRE(members.size() == 3);
-
-  auto r = c60_regime();
-
-  double biggest_bytes = 0.0;
-  std::wstring biggest_desc;
-  bool biggest_has_axis = false;
-  bool any_axis_anywhere = false;
-  std::size_t n_carrying_nodes = 0;
-  // Confirms the term_batch_axes read-back mechanism itself (not just that
-  // optimize() ran): at least one optimized summand must have a non-empty
-  // entry in the map, i.e. the DP actually recorded a per-node sliced-set
-  // vector for it (see SeQuantEngine::make_optimize_options /
-  // sequant.cpp's to_node for the same read-back shape in mpqc).
-  std::size_t n_summands_with_nonempty_axes_entry = 0;
-
-  auto memsize = sequant::opt::detail::memsize_counter(r.idx_to_extent(),
-                                                       r.inner_pow_fn());
-
-  for (std::size_t k = 0; k < members.size(); ++k) {
-    auto expr = deserialize<ExprPtr>(members[k]);
-    bool const have_expr = static_cast<bool>(expr);
-    REQUIRE(have_expr);
-
-    // One summand per Sum entry. IMPORTANT: mirror mpqc's own to_node
-    // (sequant.cpp, process_for_evaluation) and call optimize() SEPARATELY
-    // on each individual summand, rather than once on the whole Sum. Calling
-    // optimize() on a multi-summand Sum with the default
-    // opts.reorder == ReorderSum::Reorder makes optimize_impl's Sum branch
-    // run opt::reorder(new_sum, nodes) at the end, which returns a NEW Sum
-    // whose summand ExprPtr identities differ from the ones opt_pure_product
-    // recorded term_batch_axes against -- so a post-hoc
-    // axes_map->find(optimized_summand.get()) on the whole-Sum result always
-    // misses (I hit exactly this: it silently returned 0 non-empty entries
-    // for all 86 real summands, no crash, no assert -- see report). Per-term
-    // optimize() calls take the Product branch of optimize_impl directly, so
-    // the returned ExprPtr's identity IS the term_batch_axes key.
-    // deserialize() preserves the literal (deeply nested) parenthesization
-    // of the source text, e.g. "2 ((g * (C * t)) * C) * t" stays a Product
-    // whose own factors can themselves be Products; it is NOT auto-flattened
-    // to a single flat factor list. single_term_opt (and thus
-    // TensorNetwork::tensors().size(), which run_single_term_opt_axes's
-    // nt==1 shortcut keys off) only sees the network of GENUINE Tensor
-    // leaves after flattening -- test_optimize.cpp's own "threshold gates
-    // batching" test hits the exact same thing and re-flattens explicitly
-    // (Product::Flatten::Yes) before calling single_term_opt. Do the same
-    // here; without it every term looks like a trivial 1-or-2-tensor network
-    // to the DP (which is exactly what I originally observed: node_axes came
-    // back empty for all 86 real summands, even ones with genuine multi-GB
-    // PAO-role-carrying intermediates found by the manual node walk below).
-    auto flatten_product = [](ExprPtr const& e) -> ExprPtr {
-      if (!e->is<Product>()) return e;
-      auto const& p = e->as<Product>();
-      return ex<Product>(p.scalar(), p.factors(), Product::Flatten::Yes);
-    };
-
-    std::vector<ExprPtr> input_terms;
-    if (expr->is<Sum>()) {
-      for (auto const& s : expr->as<Sum>()) input_terms.push_back(s);
-    } else {
-      input_terms.push_back(expr);
-    }
-    for (auto& t : input_terms) t = flatten_product(t);
-
-    for (auto const& input_term : input_terms) {
-      auto axes_map = std::make_shared<std::unordered_map<
-          Expr const*, container::vector<container::svector<Index>>>>();
-
-      OptimizeOptions opts;
-      opts.objective_function = ObjectiveFunction::DensePeakSizeBatched;
-      opts.idx_to_extent = r.idx_to_extent();
-      opts.inner_pow = r.inner_pow_fn();
-      opts.batch_policy.is_batchable_index = [](Index const& ix) {
-        return is_stand_in_batchable(ix);
-      };
-      opts.batch_policy.batch_target_size = [](Index const&) {
-        return std::size_t{100};
-      };
-      opts.batch_policy.peak_threshold = 40e9;  // 40 GB, matches the C60 run
-      opts.term_batch_axes = axes_map;
-
-      auto term = optimize(input_term, opts);
-      bool const have_optimized = static_cast<bool>(term);
-      REQUIRE(have_optimized);
-
-      auto it = axes_map->find(term.get());
-      container::vector<container::svector<Index>> node_axes;
-      if (it != axes_map->end()) {
-        node_axes = it->second;
-        if (!node_axes.empty()) ++n_summands_with_nonempty_axes_entry;
-      }
-
-      BinarizationOptions bopts;
-      bopts.node_batch_axes = node_axes;
-
-      SEQUANT_PRAGMA_IGNORE_DEPRECATED_BEGIN
-      auto node = binarize(term, {}, bopts);
-      SEQUANT_PRAGMA_IGNORE_DEPRECATED_END
-
-      // visit_internal only: leaves (original tensor factors, e.g. "g"/"C")
-      // are never DP decision points and can never carry a batch-axis
-      // annotation, so including them would understate the DP's actual
-      // annotation rate on genuine contraction (intermediate) results.
-      node.visit_internal([&](auto const& n) {
-        auto free_ixs = node_free_indices(*n);
-        if (free_ixs.empty()) return;
-        bool has_axis_candidate = false;
-        for (auto const& ix : free_ixs)
-          if (is_stand_in_batchable(ix)) has_axis_candidate = true;
-        if (!has_axis_candidate) return;
-        ++n_carrying_nodes;
-
-        double const bytes =
-            memsize(free_ixs, std::vector<Index>{}, std::vector<Index>{}) * 8.0;
-
-        bool node_has_axis = false;
-        for (auto const& ax : n->batch_axes())
-          if (is_stand_in_batchable(ax)) node_has_axis = true;
-        if (node_has_axis) any_axis_anywhere = true;
-
-        std::wcout << L"[dryrun-probe] Rs[" << k << L"] node free={"
-                   << describe_indices(free_ixs) << L"} bytes=" << bytes
-                   << L" (" << (bytes / 1e9) << L" GB) batch_axes={"
-                   << describe_indices(container::vector<Index>(
-                          n->batch_axes().begin(), n->batch_axes().end()))
-                   << L"}\n";
-
-        if (bytes > biggest_bytes) {
-          biggest_bytes = bytes;
-          biggest_desc = describe_indices(free_ixs);
-          biggest_has_axis = node_has_axis;
-        }
-      });
-    }
-  }
-
-  INFO("largest stand-in-axis-carrying node: "
-       << std::string(biggest_desc.begin(), biggest_desc.end())
-       << " bytes=" << biggest_bytes);
-  std::wcout
-      << L"\n=== DP-INSPECTION MECHANICS (pre-transform residual; NOT a "
-         L"PAO/mu~ verdict) ===\n"
-      << L"stand-in-axis-carrying contraction nodes seen: " << n_carrying_nodes
-      << L"\n"
-      << L"summands with a non-empty term_batch_axes entry: "
-      << n_summands_with_nonempty_axes_entry << L"\n"
-      << L"any node annotated with the stand-in batch axis: "
-      << (any_axis_anywhere ? L"YES" : L"NO") << L"\n"
-      << L"largest stand-in-axis-carrying node: " << biggest_desc << L" bytes="
-      << biggest_bytes << L" (" << (biggest_bytes / 1e9) << L" GB)"
-      << L" -- got stand-in batch axis: " << (biggest_has_axis ? L"YES" : L"NO")
-      << L"\n"
-      << L"NOTE: 'a' here is the generic base virtual space, not PAO/mu~; "
-         L"the real PAO/K go/no-go verdict needs a post-transform fixture "
-         L"(follow-up).\n";
-
-  // Mechanics check only: confirms the round-trip runs and per-node
-  // batch_axes() is readable; does not assert a pass/fail verdict on whether
-  // any particular node got annotated (see file header).
-  REQUIRE(n_carrying_nodes > 0);
-  // Confirms the term_batch_axes read-back mechanism specifically: at least
-  // one real summand must have produced a non-empty per-node axes vector.
-  REQUIRE(n_summands_with_nonempty_axes_entry > 0);
-  SUCCEED();
-}
-
 // ===========================================================================
 // POST-TRANSFORM VERDICT: the actual PAO(mu~)/DF-aux(K) go/no-go probe.
 //
@@ -1051,7 +719,7 @@ using sequant::eval::dryrun::ResultDryRun;
 using sequant::eval::dryrun::ResultDryRunNested;
 
 // A small, self-consistent regime for the backend unit tests below (distinct
-// from c60_regime()/df_regime() above -- this one just needs a couple of
+// from probe_regime()/df_regime() above -- this one just needs a couple of
 // named spaces plus non-trivial PNO moments).
 SizeRegime backend_test_regime() {
   SizeRegime r;

From 533ad05043d63729e4090f4cb9a9abef403e4257 Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Mon, 6 Jul 2026 16:43:53 -0400
Subject: [PATCH 48/78] tests/dryrun: make [dryrun-perf] inspect any
 term/threshold + count PNO legs

Add env knobs to the perf-first-vs-peak-first case so it can answer 'is the
4-PNO PPL integral formed?' for any summand at any budget:
  - SEQUANT_UT_DRYRUN_LIST_TERMS=1 -- print every summand (to_latex) to locate
    the PPL/ladder term (term 38: two PAO-PAO DF g's + four C's + t^{ij}_{a3a4});
  - SEQUANT_UT_DRYRUN_TERM=N      -- select the summand (default 38);
  - SEQUANT_UT_DRYRUN_PEAK_THR_GB -- peak_threshold in GB (default 40, was
    hardcoded) so the real job budget (600) can be reproduced;
  - the PERF_TREE dump now also reports PNO/OSV composite free-leg counts, so a
    4-free-PNO node (the held-whole 4-PNO integral) is unmistakable.
Confirms: at 600 GB peak-first keeps max PNO-per-node = 2 (contracts t early,
never forms the 4-PNO integral), while perf-first forms the {a1 a2 a3 a4} node
(the 4-PNO integral, ~pno^4 per pair). Defaults unchanged; [dryrun-perf] green
(13 assertions).
---
 tests/unit/test_eval_dryrun.cpp | 35 ++++++++++++++++++++++++++++-----
 1 file changed, 30 insertions(+), 5 deletions(-)

diff --git a/tests/unit/test_eval_dryrun.cpp b/tests/unit/test_eval_dryrun.cpp
index df122f4f3a..a11c6dd730 100644
--- a/tests/unit/test_eval_dryrun.cpp
+++ b/tests/unit/test_eval_dryrun.cpp
@@ -1240,9 +1240,23 @@ TEST_CASE("dryrun perf-first vs peak-first factorization of the C60 giant term",
     auto const& p = e->as<Product>();
     return ex<Product>(p.scalar(), p.factors(), Product::Flatten::Yes);
   };
-  std::size_t const giant_idx = 38 < summands.size() ? 38 : 0;
+  // SEQUANT_UT_DRYRUN_LIST_TERMS=1 prints every summand's factor structure so
+  // the PPL/ladder term (the one whose early-K factorization would form a
+  // 4-PNO integral) can be located by eye.
+  if (std::getenv("SEQUANT_UT_DRYRUN_LIST_TERMS")) {
+    for (std::size_t s = 0; s < summands.size(); ++s)
+      std::wcerr << L"[term " << s << L"] "
+                 << to_latex(flatten_product(summands[s])) << L"\n";
+  }
+  // Term selector (default 38): SEQUANT_UT_DRYRUN_TERM.
+  std::size_t giant_idx = 38;
+  if (char const* te = std::getenv("SEQUANT_UT_DRYRUN_TERM"))
+    giant_idx = static_cast<std::size_t>(std::atoll(te));
+  if (giant_idx >= summands.size()) giant_idx = 0;
   ExprPtr giant = flatten_product(summands[giant_idx]);
   REQUIRE(giant);
+  std::wcerr << L"[dryrun-perf] selected term " << giant_idx << L" = "
+             << to_latex(giant) << L"\n";
 
   // FAITHFUL real C60 config (614336 job log), identical to [dryrun-eval].
   auto regime = df_regime(/*mu_tilde=*/1800u, /*aux=*/4320u, /*i_occ=*/120u,
@@ -1285,7 +1299,11 @@ TEST_CASE("dryrun perf-first vs peak-first factorization of the C60 giant term",
     };
     policy.is_volatile_leaf = [](Tensor const& t) { return t.label() == L"t"; };
     policy.accumulation_factor = 1.0;
-    policy.peak_threshold = 40e9;
+    policy.peak_threshold =
+        (std::getenv("SEQUANT_UT_DRYRUN_PEAK_THR_GB")
+             ? std::atof(std::getenv("SEQUANT_UT_DRYRUN_PEAK_THR_GB"))
+             : 40.0) *
+        1e9;
 
     auto axes_map = std::make_shared<std::unordered_map<
         Expr const*, container::vector<container::svector<Index>>>>();
@@ -1329,15 +1347,22 @@ TEST_CASE("dryrun perf-first vs peak-first factorization of the C60 giant term",
             auto const free = node_free_indices(*n);
             container::vector<Index> const bax(n->batch_axes().begin(),
                                                n->batch_axes().end());
-            std::size_t nmu = 0, nk = 0;
+            std::size_t nmu = 0, nk = 0, npno = 0, nosv = 0;
             for (auto const& ix : free) {
               if (ix.space().base_key() == L"μ̃") ++nmu;
               if (ix.space().base_key() == L"Κ") ++nk;
+              if (ix.has_proto_indices()) {
+                if (ix.proto_indices().size() >= 2)
+                  ++npno;  // 2-proto (or higher) = PNO composite
+                else
+                  ++nosv;  // 1-proto = OSV composite
+              }
             }
             std::wcerr << pad << (n.leaf() ? L"leaf  " : L"CONTRACT ")
                        << L"free={" << describe_indices(free) << L"} (mu~="
-                       << nmu << L" K=" << nk << L")  batch_axes={"
-                       << describe_indices(bax) << L"}\n";
+                       << nmu << L" K=" << nk << L" PNO=" << npno << L" OSV="
+                       << nosv << L")  batch_axes={" << describe_indices(bax)
+                       << L"}\n";
             if (!n.leaf()) {
               dump(n.left(), depth + 1);
               dump(n.right(), depth + 1);

From cf783a3b8f57b7c6a4d541470497c1014f063ce5 Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Mon, 6 Jul 2026 17:20:03 -0400
Subject: [PATCH 49/78] tests/dryrun: [dryrun-perf] uses the REAL measured CSV
 moments, not flat 42

The perf-first-vs-peak-first case hardwired the SCALAR df_regime(pno=42,
osv=310) -- a flat constant domain (M_k=42 for all k) -- so the 4-PNO PPL
node it reports was sized occ^2*42^4 = 387 GB, an under-count. Add named
constants kC60PnoM/kC60OsvM = the real heavy-tailed power means measured by
mpqc PaoPnoRMP2 (jobs 617609/617653/617809: PNO M_1..M_4 = 48.60/54.34/
59.63/64.35, OSV = 206.48/216.66/226.15/234.51) and feed them via the
FAITHFUL array df_regime overload. The 4-PNO node now sizes occ^2*M_4^4 ~=
2.0 TB (dense occ^2 pairs; ~0.86 TB at the screened ~6300 CC pairs) --
faithfully showing why perf-first OOMs C60. Peak-band assertion updated
1..4 TB; [dryrun-perf] green (13 assertions).
---
 tests/unit/test_eval_dryrun.cpp | 51 +++++++++++++++++++++------------
 1 file changed, 33 insertions(+), 18 deletions(-)

diff --git a/tests/unit/test_eval_dryrun.cpp b/tests/unit/test_eval_dryrun.cpp
index a11c6dd730..823ec729df 100644
--- a/tests/unit/test_eval_dryrun.cpp
+++ b/tests/unit/test_eval_dryrun.cpp
@@ -330,6 +330,20 @@ SizeRegime df_regime(std::size_t mu_tilde, std::size_t aux, std::size_t i_occ,
   return r;
 }
 
+// REAL measured C60 cc-pVDZ-F12 CSV size moments (mpqc PaoPnoRMP2 print, jobs
+// 617609/617653/617809): the k-th power means M_1..M_4 of the per-pair PNO
+// domain and per-orbital OSV domain. Index 0 unused (kept 1). These are the
+// FAITHFUL, heavy-tailed moments -- use them (via the array df_regime overload)
+// instead of a flat scalar so a k-composite intermediate is sized by mean(d^k),
+// e.g. the 4-PNO PPL integral by occ^2 * M_4^4 (~2 TB dense) rather than the
+// flat-42 under-count (~0.36 TB).
+constexpr std::array<double, 5> kC60PnoM{1.0, 48.597142857142856,
+                                         54.335293566742848, 59.625213617564981,
+                                         64.347555914574883};
+constexpr std::array<double, 5> kC60OsvM{1.0, 206.48333333333332,
+                                         216.66121788020425, 226.15064540004298,
+                                         234.51208523659201};
+
 // Batchable = the two axes mpqc's runtime batches on the CSV path: PAO (mu~)
 // and DF aux (K). Both are non-proto base spaces (mu~ = PAO, K = DFBS aux).
 bool is_df_batchable(Index const& ix) {
@@ -1258,9 +1272,11 @@ TEST_CASE("dryrun perf-first vs peak-first factorization of the C60 giant term",
   std::wcerr << L"[dryrun-perf] selected term " << giant_idx << L" = "
              << to_latex(giant) << L"\n";
 
-  // FAITHFUL real C60 config (614336 job log), identical to [dryrun-eval].
+  // FAITHFUL real C60 config: measured heavy-tailed CSV moments (kC60PnoM/
+  // kC60OsvM), NOT a flat scalar -- so the 4-PNO PPL node is sized occ^2*M_4^4
+  // (real ~2 TB dense) instead of the flat-42 under-count (~0.36 TB).
   auto regime = df_regime(/*mu_tilde=*/1800u, /*aux=*/4320u, /*i_occ=*/120u,
-                          /*pno=*/42.0, /*osv=*/310.0);
+                          kC60PnoM, kC60OsvM);
   auto memsize = sequant::opt::detail::memsize_counter(regime.idx_to_extent(),
                                                        regime.inner_pow_fn());
   auto ext_of = [](Index const& ix) -> double {
@@ -1470,23 +1486,22 @@ TEST_CASE("dryrun perf-first vs peak-first factorization of the C60 giant term",
   // (a) perf-first is flops-primary: it must not pick a higher-flops
   //     factorization than peak-first.
   CHECK(perf_first.cp.flops <= peak_first.cp.flops);
-  // (b) perf-first's modeled peak lands in a realistic band for this
-  //     constant-moment C60 giant. Observed perf peak_bytes ~= 387 GB,
-  //     dominated by the GENUINE 4-PNO intermediate the perf-first schedule
-  //     forms -- the CC doubles W node {a_1<i,i> a_2<i,i> a_3<i,i> a_4<i,i>}
-  //     with FOUR distinct PNO legs over one occ-pair (see
-  //     SEQUANT_UT_DRYRUN_PERF_TREE dump), sized occ^2 * M_4^4 = 120^2*42^4*8 =
-  //     358 GB (+ co-resident). This is the CORRECT, moment-aware size
+  // (b) perf-first's modeled peak is dominated by the GENUINE 4-PNO
+  //     intermediate the perf-first schedule forms -- the CC doubles W node
+  //     {a_1<i,i> a_2<i,i> a_3<i,i> a_4<i,i>} with FOUR distinct PNO legs over
+  //     one occ-pair (see SEQUANT_UT_DRYRUN_PERF_TREE dump). With the FAITHFUL
+  //     heavy-tailed moments (kC60PnoM), it is sized occ^2 * M_4^4 =
+  //     120^2 * 64.348^4 * 8 ~= 2.0 TB (dense occ^2 pairs; the screened ~6300
+  //     CC pairs would give ~0.86 TB). This is the CORRECT, moment-aware size
   //     (df_regime's csv_pno_moment[k] are power means), NOT a naive-product
-  //     artifact and NOT a mis-sized twin R{a<i,i>,a<i,i>}: the sizing was made
-  //     moment-aware and the twin would be occ^2*M_2^2 ~= 0.2 GB. The Kappa
-  //     axis is CONTRACTED at this node, so batching cannot shrink the W
-  //     (irreducible peak floor of the flop-optimal factorization). A 100 GB..1
-  //     TB band brackets it with comfortable margin and is non-flaky. NOTE:
-  //     with real heavy-tailed PNO moments (M_4 > 42) this rises further -- the
-  //     OOM question Tasks 6-8 quantify for C60.
-  CHECK(perf_first.cp.peak_bytes < 1e12);
-  CHECK(perf_first.cp.peak_bytes > 1e11);
+  //     artifact and NOT a mis-sized twin R{a<i,i>,a<i,i>} (which would be
+  //     occ^2*M_2^2 ~= 0.4 GB). The Kappa axis is CONTRACTED at this node, so
+  //     batching cannot shrink W -- it is the irreducible peak floor of the
+  //     flop-optimal factorization, and precisely why perf-first (which forms
+  //     it) OOMs C60 while peak-first (which does not) does not. A 1..4 TB band
+  //     brackets the real-moment value with margin and is non-flaky.
+  CHECK(perf_first.cp.peak_bytes < 4e12);
+  CHECK(perf_first.cp.peak_bytes > 1e12);
 }
 
 // Task 3: the opt-in scratch-fold peak sink captures the batched-inner peak the

From 2431923c8dfa3ae7edd0609afdb97d995cd5a1a8 Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Mon, 6 Jul 2026 18:41:19 -0400
Subject: [PATCH 50/78] tests/dryrun: single ProblemSize source of truth +
 correct pVDZ-F12 moments

Three cleanups in one:

1. DRY the problem sizes. Every post-transform test repeated the C60 literals
   (df_regime(1800,4320,120,...)) at its own call site. Introduce a constexpr
   ProblemSize struct (extents + PNO/OSV power means) and one instance
   kC60_pVDZF12, plus a df_regime(ProblemSize) overload; every fixed call site
   is now df_regime(kC60_pVDZF12). A moment re-measurement is a one-line edit.
   Remove the now-unused scalar df_regime(...,double,double) overload.

2. Correct the moments. The values 48.60/54.34/59.63/64.35 (PNO) and 206/234
   (OSV) came from job 617653, which was mis-configured with an aug-cc-pVTZ
   OBS. The true cc-pVDZ-F12 moments (job 617809) are PNO 42.03/46.04/49.77/
   53.15 and OSV 148.25/155.04/161.34/166.86. With these the perf-first 4-PNO
   PPL node measures occ^2*M_4^4 = 954 GB (was mis-stated 2 TB at the wrong
   M_4). All post-transform tests (incl. [dryrun-df] env defaults) now use the
   real moments, not the flat 42/310 stand-in.

3. Rename [dryrun-perf] -> [dryrun-objective]. "perf" only named one of the
   two objectives it compares; the test's point is that the objective function
   DETERMINES the factorization (perf-first forms the 4-PNO integral, peak-first
   does not). Title updated to say so.

All 21 dryrun cases green (120 assertions).
---
 tests/unit/test_eval_dryrun.cpp | 196 ++++++++++++++++----------------
 1 file changed, 95 insertions(+), 101 deletions(-)

diff --git a/tests/unit/test_eval_dryrun.cpp b/tests/unit/test_eval_dryrun.cpp
index 823ec729df..bcc81aa004 100644
--- a/tests/unit/test_eval_dryrun.cpp
+++ b/tests/unit/test_eval_dryrun.cpp
@@ -278,43 +278,13 @@ namespace {
 
 // Regime for the post-transform (mu~ + K) residual. Extents are per-index
 // domain sizes fed to the DP's idx_to_extent; proto-indexed "a" legs are
-// PNO/OSV composites sized by the moment tables (same dispatch as the
-// pre-transform regime). Defaults are water-8-scale (from the w8-batch-min
-// run: active occ = 32, DF aux cc-pvdz-ri = 672, avg PNOs/pair ~19); the
-// giant-relevant knob is the mu~ (PAO domain) extent, swept below.
-SizeRegime df_regime(std::size_t mu_tilde, std::size_t aux, std::size_t i_occ,
-                     double pno, double osv) {
-  SizeRegime r;
-  r.space_extent = {
-      {L"i", i_occ},
-      {L"μ̃", mu_tilde},
-      {L"Κ", aux},
-      {L"a", mu_tilde},  // bare "a" should not appear (all a are proto here)
-  };
-  // csv_{pno,osv}_moment[k] must be the k-th POWER MEAN M_k=(<d^k>)^(1/k) of
-  // the per-pair domain, NOT the k-th moment <d^k>. inner_aware_volume sizes a
-  // k-group of proto-sharing composites as the PRODUCT of inner_pow(c,k) over
-  // its k members, so M_k^k telescopes to <d^k> and (times outer occ^N) equals
-  // the true block volume Sum_pairs d^k. With only the scalar mean (no per-pair
-  // histogram), approximate the domain as constant -> M_k = mean for ALL k.
-  // pow(pno,k) (the k-th MOMENT) is wrong: for a k=2 result like
-  // R{a_1<i,i>,a_2<i,i>;i,i} it gives occ^2*pno^4 not occ^2*pno^2 (the 358 GB
-  // root artifact). k=1 single-composite giants are unaffected (pno^1==pno).
-  for (std::size_t k = 0; k <= 4; ++k) {
-    r.csv_pno_moment[k] = pno;
-    r.csv_osv_moment[k] = osv;
-  }
-  return r;
-}
-
-// FAITHFUL variant: takes the real per-nonnull-cluster power means M_1..M_4
-// (heavy tail) as measured by mpqc's PaoPnoRMP2 -- the two lines it prints,
-// "PNO domain power means M_1..M_4 per pair" and "OSV domain power means
-// M_1..M_4 per orbital". Unlike the scalar overload above (constant domain,
-// M_k = mean for all k, which under-sizes multi-composite intermediates), this
-// preserves M_2 > M_1 > ... so a k-composite group is sized by mean(d^k), the
-// true block-sparse volume. pno_M[k]/osv_M[k] for k in [1,4]; index 0 unused
-// (kept 1). Rank >= 3 (CSV-CCSDT) is not populated here (CCSD is ranks 1-2).
+// PNO/OSV composites sized by the moment tables. Takes the real per-nonnull-
+// cluster power means M_1..M_4 (heavy tail) as measured by mpqc's PaoPnoRMP2 --
+// the two lines it prints, "PNO domain power means M_1..M_4 per pair" and "OSV
+// domain power means M_1..M_4 per orbital". A per-k power mean (M_2 > M_1 >
+// ...) sizes a k-composite group as mean(d^k), the true block-sparse volume.
+// pno_M[k]/osv_M[k] for k in [1,4]; index 0 unused (kept 1). Rank >= 3
+// (CSV-CCSDT) is not populated here (CCSD is ranks 1-2).
 SizeRegime df_regime(std::size_t mu_tilde, std::size_t aux, std::size_t i_occ,
                      std::array<double, 5> const& pno_M,
                      std::array<double, 5> const& osv_M) {
@@ -330,19 +300,36 @@ SizeRegime df_regime(std::size_t mu_tilde, std::size_t aux, std::size_t i_occ,
   return r;
 }
 
-// REAL measured C60 cc-pVDZ-F12 CSV size moments (mpqc PaoPnoRMP2 print, jobs
-// 617609/617653/617809): the k-th power means M_1..M_4 of the per-pair PNO
-// domain and per-orbital OSV domain. Index 0 unused (kept 1). These are the
-// FAITHFUL, heavy-tailed moments -- use them (via the array df_regime overload)
-// instead of a flat scalar so a k-composite intermediate is sized by mean(d^k),
-// e.g. the 4-PNO PPL integral by occ^2 * M_4^4 (~2 TB dense) rather than the
-// flat-42 under-count (~0.36 TB).
-constexpr std::array<double, 5> kC60PnoM{1.0, 48.597142857142856,
-                                         54.335293566742848, 59.625213617564981,
-                                         64.347555914574883};
-constexpr std::array<double, 5> kC60OsvM{1.0, 206.48333333333332,
-                                         216.66121788020425, 226.15064540004298,
-                                         234.51208523659201};
+// One named (molecule, basis, parameter-set) problem size for the DryRun cost
+// model: base-space extents + the measured heavy-tailed CSV power means. Single
+// source of truth -- use df_regime(kFoo) at every call site instead of
+// repeating the literals, so a moment re-measurement is a one-line edit.
+struct ProblemSize {
+  std::size_t mu_tilde;         // PAO domain extent (= #AO)
+  std::size_t aux;              // DF aux (K) extent
+  std::size_t i_occ;            // active occupied extent
+  std::array<double, 5> pno_M;  // per-pair PNO power means M_0..M_4 (0 unused)
+  std::array<double, 5> osv_M;  // per-orbital OSV power means M_0..M_4
+};
+
+// C60, cc-pVDZ-F12, TCUTPNO=1e-8 / TCUTOSV=1e-9. Extents from the Owl job log;
+// PNO/OSV power means M_1..M_4 measured by mpqc PaoPnoRMP2 (job 617809 -- the
+// TRUE pVDZ-F12 values; NOTE the earlier 48.60/64.35 PNO + 206/234 OSV numbers
+// were from job 617653, which was mis-configured with an aug-cc-pVTZ OBS).
+inline constexpr ProblemSize kC60_pVDZF12{
+    /*mu_tilde=*/1800u,
+    /*aux=*/4320u,
+    /*i_occ=*/120u,
+    /*pno_M=*/
+    {1.0, 42.029069767441861, 46.039206412923569, 49.766252354482994,
+     53.151291880343109},
+    /*osv_M=*/
+    {1.0, 148.25, 155.04434849422921, 161.33527408797721, 166.85553430303926}};
+
+// Build a SizeRegime from a named ProblemSize.
+SizeRegime df_regime(ProblemSize const& p) {
+  return df_regime(p.mu_tilde, p.aux, p.i_occ, p.pno_M, p.osv_M);
+}
 
 // Batchable = the two axes mpqc's runtime batches on the CSV path: PAO (mu~)
 // and DF aux (K). Both are non-proto base spaces (mu~ = PAO, K = DFBS aux).
@@ -419,9 +406,10 @@ TEST_CASE("dryrun POST-transform PAO/K batch-axis verdict", "[dryrun-df]") {
     char const* v = std::getenv(k);
     return v ? static_cast<std::size_t>(std::atoll(v)) : dflt;
   };
-  std::size_t const occ_ext = env_u("SEQUANT_UT_DRYRUN_OCC", 120u);
-  double const pno_mom = env_d("SEQUANT_UT_DRYRUN_PNO", 42.0);
-  double const osv_mom = env_d("SEQUANT_UT_DRYRUN_OSV", 310.0);
+  std::size_t const occ_ext =
+      env_u("SEQUANT_UT_DRYRUN_OCC", kC60_pVDZF12.i_occ);
+  double const pno_mom = env_d("SEQUANT_UT_DRYRUN_PNO", kC60_pVDZF12.pno_M[1]);
+  double const osv_mom = env_d("SEQUANT_UT_DRYRUN_OSV", kC60_pVDZF12.osv_M[1]);
   std::size_t const pao_ts = env_u("SEQUANT_UT_DRYRUN_PAO_TS", 256u);
   std::size_t const aux_ts = env_u("SEQUANT_UT_DRYRUN_AUX_TS", 72u);
   double const vol_weight = env_d("SEQUANT_UT_DRYRUN_VW", 20.0);
@@ -429,12 +417,18 @@ TEST_CASE("dryrun POST-transform PAO/K batch-axis verdict", "[dryrun-df]") {
   // FAITHFUL heavy-tail moments: real M_2..M_4 (default to M_1 = the constant
   // domain, so absent env vars reproduce the old scalar df_regime exactly).
   // Feed the mpqc-printed "PNO/OSV domain power means M_1..M_4" here.
-  double const pno_m2 = env_d("SEQUANT_UT_DRYRUN_PNO_M2", pno_mom);
-  double const pno_m3 = env_d("SEQUANT_UT_DRYRUN_PNO_M3", pno_mom);
-  double const pno_m4 = env_d("SEQUANT_UT_DRYRUN_PNO_M4", pno_mom);
-  double const osv_m2 = env_d("SEQUANT_UT_DRYRUN_OSV_M2", osv_mom);
-  double const osv_m3 = env_d("SEQUANT_UT_DRYRUN_OSV_M3", osv_mom);
-  double const osv_m4 = env_d("SEQUANT_UT_DRYRUN_OSV_M4", osv_mom);
+  double const pno_m2 =
+      env_d("SEQUANT_UT_DRYRUN_PNO_M2", kC60_pVDZF12.pno_M[2]);
+  double const pno_m3 =
+      env_d("SEQUANT_UT_DRYRUN_PNO_M3", kC60_pVDZF12.pno_M[3]);
+  double const pno_m4 =
+      env_d("SEQUANT_UT_DRYRUN_PNO_M4", kC60_pVDZF12.pno_M[4]);
+  double const osv_m2 =
+      env_d("SEQUANT_UT_DRYRUN_OSV_M2", kC60_pVDZF12.osv_M[2]);
+  double const osv_m3 =
+      env_d("SEQUANT_UT_DRYRUN_OSV_M3", kC60_pVDZF12.osv_M[3]);
+  double const osv_m4 =
+      env_d("SEQUANT_UT_DRYRUN_OSV_M4", kC60_pVDZF12.osv_M[4]);
   // Objective: "perf" = dense_time_space (perf-first, min-flops), else
   // "peak" = dense_space_time (peak-first, min-flops s.t. peak<=threshold).
   // Default "peak" reproduces the old DensePeakSizeBatched behavior.
@@ -463,7 +457,8 @@ TEST_CASE("dryrun POST-transform PAO/K batch-axis verdict", "[dryrun-df]") {
   // K=672; they under-scaled every intermediate and (via peak_threshold
   // pruning) changed the DP's axis choice.
   auto regime = df_regime(
-      /*mu_tilde=*/1800u, /*aux=*/4320u, /*i_occ=*/occ_ext,
+      /*mu_tilde=*/kC60_pVDZF12.mu_tilde, /*aux=*/kC60_pVDZF12.aux,
+      /*i_occ=*/occ_ext,
       std::array<double, 5>{1.0, pno_mom, pno_m2, pno_m3, pno_m4},
       std::array<double, 5>{1.0, osv_mom, osv_m2, osv_m3, osv_m4});
   std::wcerr << L"[dryrun-df] moments: PNO M_1..M_4=" << pno_mom << L","
@@ -1005,8 +1000,7 @@ TEST_CASE(
   // mu~=1800, aux=4320, pao_target_size=256, aux_target_size=72,
   // volatile_weight=20, machine_balance=200, fast_mem_elems=1e6. SAME regime
   // and SAME batchable predicate the [dryrun-df] verdict case uses.
-  auto regime = df_regime(/*mu_tilde=*/1800u, /*aux=*/4320u, /*i_occ=*/120u,
-                          /*pno=*/42.0, /*osv=*/310.0);
+  auto regime = df_regime(kC60_pVDZF12);
   auto cm = std::make_shared<CostModel const>(regime);
 
   // ONE BatchPolicy object, reused verbatim for both optimize() and the
@@ -1228,8 +1222,10 @@ TEST_CASE(
 // survives the hard filter despite astronomically higher flops); perf-first is
 // flops-primary and must NEVER form it. This is the direct in-harness proof of
 // the fix, on ONE term (~seconds), without the [dryrun-df] full-sweep cost.
-TEST_CASE("dryrun perf-first vs peak-first factorization of the C60 giant term",
-          "[dryrun-perf]") {
+TEST_CASE(
+    "dryrun objective determines the C60 PPL factorization (perf-first forms "
+    "the 4-PNO integral, peak-first does not)",
+    "[dryrun-objective]") {
   auto ctx = get_default_context().clone();
   ctx.set_first_dummy_index_ordinal(1000000);
   auto isr = ctx.mutable_index_space_registry();
@@ -1269,20 +1265,19 @@ TEST_CASE("dryrun perf-first vs peak-first factorization of the C60 giant term",
   if (giant_idx >= summands.size()) giant_idx = 0;
   ExprPtr giant = flatten_product(summands[giant_idx]);
   REQUIRE(giant);
-  std::wcerr << L"[dryrun-perf] selected term " << giant_idx << L" = "
+  std::wcerr << L"[dryrun-objective] selected term " << giant_idx << L" = "
              << to_latex(giant) << L"\n";
 
-  // FAITHFUL real C60 config: measured heavy-tailed CSV moments (kC60PnoM/
-  // kC60OsvM), NOT a flat scalar -- so the 4-PNO PPL node is sized occ^2*M_4^4
-  // (real ~2 TB dense) instead of the flat-42 under-count (~0.36 TB).
-  auto regime = df_regime(/*mu_tilde=*/1800u, /*aux=*/4320u, /*i_occ=*/120u,
-                          kC60PnoM, kC60OsvM);
+  // FAITHFUL real C60 config: the measured heavy-tailed CSV moments in
+  // kC60_pVDZF12, NOT a flat scalar -- so the 4-PNO PPL node is sized
+  // occ^2 * M_4^4 (real, per the measured M_4) instead of a flat under-count.
+  auto regime = df_regime(kC60_pVDZF12);
   auto memsize = sequant::opt::detail::memsize_counter(regime.idx_to_extent(),
                                                        regime.inner_pow_fn());
   auto ext_of = [](Index const& ix) -> double {
     auto bk = ix.space().base_key();
-    if (bk == L"μ̃") return 1800.0;
-    if (bk == L"Κ") return 4320.0;
+    if (bk == L"μ̃") return double(kC60_pVDZF12.mu_tilde);
+    if (bk == L"Κ") return double(kC60_pVDZF12.aux);
     return 0.0;
   };
   auto tgt_of = [](Index const& ix) -> double {
@@ -1356,7 +1351,7 @@ TEST_CASE("dryrun perf-first vs peak-first factorization of the C60 giant term",
       wchar_t const* on = (obj == ObjectiveFunction::DenseTimeSpaceBatched)
                               ? L"perf-first (DenseTimeSpaceBatched)"
                               : L"peak-first (DenseSpaceTimeBatched)";
-      std::wcerr << L"\n[dryrun-perf] TREE for " << on << L":\n";
+      std::wcerr << L"\n[dryrun-objective] TREE for " << on << L":\n";
       std::function<void(std::remove_cvref_t<decltype(node)> const&, int)>
           dump = [&](auto const& n, int depth) {
             std::wstring const pad(2 * depth + 2, L' ');
@@ -1447,7 +1442,7 @@ TEST_CASE("dryrun perf-first vs peak-first factorization of the C60 giant term",
     wchar_t const* obj_name = (obj == ObjectiveFunction::DenseTimeSpaceBatched)
                                   ? L"perf-first (DenseTimeSpaceBatched)"
                                   : L"peak-first (DenseSpaceTimeBatched)";
-    std::wcerr << L"[dryrun-perf] " << obj_name << L": optimize " << opt_ms
+    std::wcerr << L"[dryrun-objective] " << obj_name << L": optimize " << opt_ms
                << L"ms  max free-mu~ on a node=" << a.max_free_mu
                << L"  largest realized free-mu~={" << a.largest_desc << L"}="
                << a.largest_realized_gb << L" GB\n               cost_profile: "
@@ -1468,7 +1463,7 @@ TEST_CASE("dryrun perf-first vs peak-first factorization of the C60 giant term",
                << a.cp.flops << L" peak_bytes=" << (a.cp.peak_bytes / 1e9)
                << L" GB\n";
   };
-  std::wcerr << L"\n=== [dryrun-perf] VERDICT (C60 giant, index 38) ===\n";
+  std::wcerr << L"\n=== [dryrun-objective] VERDICT (C60 giant, index 38) ===\n";
   report(L"peak-first (DenseSpaceTimeBatched)", peak_first);
   report(L"perf-first (DenseTimeSpaceBatched)", perf_first);
 
@@ -1490,23 +1485,24 @@ TEST_CASE("dryrun perf-first vs peak-first factorization of the C60 giant term",
   //     intermediate the perf-first schedule forms -- the CC doubles W node
   //     {a_1<i,i> a_2<i,i> a_3<i,i> a_4<i,i>} with FOUR distinct PNO legs over
   //     one occ-pair (see SEQUANT_UT_DRYRUN_PERF_TREE dump). With the FAITHFUL
-  //     heavy-tailed moments (kC60PnoM), it is sized occ^2 * M_4^4 =
-  //     120^2 * 64.348^4 * 8 ~= 2.0 TB (dense occ^2 pairs; the screened ~6300
-  //     CC pairs would give ~0.86 TB). This is the CORRECT, moment-aware size
+  //     measured moments (kC60_pVDZF12), it is sized occ^2 * M_4^4 =
+  //     120^2 * 53.151^4 * 8 ~= 0.92 TB (dense occ^2 pairs; the screened ~6300
+  //     CC pairs would give ~0.40 TB). This is the CORRECT, moment-aware size
   //     (df_regime's csv_pno_moment[k] are power means), NOT a naive-product
   //     artifact and NOT a mis-sized twin R{a<i,i>,a<i,i>} (which would be
-  //     occ^2*M_2^2 ~= 0.4 GB). The Kappa axis is CONTRACTED at this node, so
+  //     occ^2*M_2^2 ~= 0.3 GB). The Kappa axis is CONTRACTED at this node, so
   //     batching cannot shrink W -- it is the irreducible peak floor of the
   //     flop-optimal factorization, and precisely why perf-first (which forms
-  //     it) OOMs C60 while peak-first (which does not) does not. A 1..4 TB band
-  //     brackets the real-moment value with margin and is non-flaky.
-  CHECK(perf_first.cp.peak_bytes < 4e12);
-  CHECK(perf_first.cp.peak_bytes > 1e12);
+  //     it) OOMs C60 while peak-first (which does not) does not. A 0.5..2 TB
+  //     band brackets the real-moment value with margin and is non-flaky.
+  CHECK(perf_first.cp.peak_bytes < 2e12);
+  CHECK(perf_first.cp.peak_bytes > 5e11);
 }
 
 // Task 3: the opt-in scratch-fold peak sink captures the batched-inner peak the
-// OUTER cache.working_set_hwmark() misses. Reuse the [dryrun-perf] peak-first
-// (DenseSpaceTimeBatched) setup -- the objective whose batched-inner transient
+// OUTER cache.working_set_hwmark() misses. Reuse the [dryrun-objective]
+// peak-first (DenseSpaceTimeBatched) setup -- the objective whose batched-inner
+// transient
 // (~38.9 GB, materialized INSIDE a make_batched_scratch cache) dwarfs the
 // outer, cross-batch cached residency (~0.2 GB). A PeakSink passed to
 // make_evaluator folds each scratch cache's high-watermark into one global
@@ -1541,9 +1537,8 @@ TEST_CASE("dryrun scratch-fold captures batched peak", "[dryrun][peak]") {
   ExprPtr giant = flatten_product(summands[giant_idx]);
   REQUIRE(giant);
 
-  // FAITHFUL real C60 config (identical to [dryrun-perf]).
-  auto regime = df_regime(/*mu_tilde=*/1800u, /*aux=*/4320u, /*i_occ=*/120u,
-                          /*pno=*/42.0, /*osv=*/310.0);
+  // FAITHFUL real C60 config (identical to [dryrun-objective]).
+  auto regime = df_regime(kC60_pVDZF12);
   auto cm = std::make_shared<CostModel const>(regime);
 
   sequant::BatchPolicy policy;
@@ -1598,7 +1593,8 @@ TEST_CASE("dryrun scratch-fold captures batched peak", "[dryrun][peak]") {
   try {
     (void)sequant::evaluate<Trace::On>(node, DryRunLeafEvaluator{cm}, cache);
   } catch (std::exception const&) {
-    // mirror [dryrun-perf]: a DryRun sizing throw must not mask the sink read
+    // mirror [dryrun-objective]: a DryRun sizing throw must not mask the sink
+    // read
   }
   logger.eval.level = prev_level;
   logger.eval.stream = prev_stream;
@@ -1663,9 +1659,8 @@ TEST_CASE("cost_profile returns peak/flops/exec/n_ops",
   ExprPtr giant = flatten_product(summands[giant_idx]);
   REQUIRE(giant);
 
-  // FAITHFUL real C60 config (identical to [dryrun-perf] / [peak]).
-  auto regime = df_regime(/*mu_tilde=*/1800u, /*aux=*/4320u, /*i_occ=*/120u,
-                          /*pno=*/42.0, /*osv=*/310.0);
+  // FAITHFUL real C60 config (identical to [dryrun-objective] / [peak]).
+  auto regime = df_regime(kC60_pVDZF12);
 
   // ONE BatchPolicy, reused for optimize() and the replay evaluator (its
   // is_batchable_index MUST equal CacheConfig::is_batchable_index).
@@ -1802,7 +1797,7 @@ TEST_CASE("cost_profile trace stream round-trips", "[dryrun][cost_profile]") {
   ExprPtr giant = flatten_product(summands[giant_idx]);
   REQUIRE(giant);
 
-  auto regime = df_regime(1800u, 4320u, 120u, 42.0, 310.0);
+  auto regime = df_regime(kC60_pVDZF12);
 
   sequant::BatchPolicy policy;
   policy.is_batchable_index = is_df_batchable;
@@ -1871,9 +1866,9 @@ TEST_CASE("cost_profile trace stream round-trips", "[dryrun][cost_profile]") {
 // VETO caching of a free-batchable giant -- a node whose result carries a free
 // mu~/K axis the runtime slices over -- exactly as the real batched eval loop
 // does, instead of materializing it whole. The SIMPLE cache_manager(nodes) the
-// ad-hoc [dryrun-perf]/[dryrun-trace] sites use caches such a giant; the gated
-// build must not. We prove this by contrasting three configs over the SAME
-// binarized C60 giant term (index 38):
+// ad-hoc [dryrun-objective]/[dryrun-trace] sites use caches such a giant; the
+// gated build must not. We prove this by contrasting three configs over the
+// SAME binarized C60 giant term (index 38):
 //   ref:  no gate  (max_footprint=0, never batchable) -> giant IS cached
 //   axis: axis veto only (max_footprint=0, is_df_batchable) -> giant NOT cached
 //   task: axis veto + footprint gate (max_footprint=1e11, is_df_batchable)
@@ -1884,7 +1879,7 @@ TEST_CASE("cost_profile trace stream round-trips", "[dryrun][cost_profile]") {
 // a vetoed node is never registered, so it is not, and cannot become, resident;
 // this is a stronger/cleaner signal than working_set_hwmark, which only tracks
 // alive cached bytes and is confounded by batched-inner scratch -- see the
-// [dryrun-perf] INTERPRETATION notes).
+// [dryrun-objective] INTERPRETATION notes).
 TEST_CASE("dryrun gated cache vetoes free-batchable giant", "[dryrun][cache]") {
   auto ctx = get_default_context().clone();
   ctx.set_first_dummy_index_ordinal(1000000);
@@ -1914,9 +1909,8 @@ TEST_CASE("dryrun gated cache vetoes free-batchable giant", "[dryrun][cache]") {
   ExprPtr giant = flatten_product(summands[giant_idx]);
   REQUIRE(giant);
 
-  // FAITHFUL real C60 config (614336 job log), identical to [dryrun-perf].
-  auto regime = df_regime(/*mu_tilde=*/1800u, /*aux=*/4320u, /*i_occ=*/120u,
-                          /*pno=*/42.0, /*osv=*/310.0);
+  // FAITHFUL real C60 config (614336 job log), identical to [dryrun-objective].
+  auto regime = df_regime(kC60_pVDZF12);
   auto memsize = sequant::opt::detail::memsize_counter(regime.idx_to_extent(),
                                                        regime.inner_pow_fn());
 
@@ -2115,7 +2109,7 @@ TEST_CASE("dryrun whole-residual trace (PNO-CCSD doubles)",
       (max_terms > 0 && max_terms < terms.size()) ? max_terms : terms.size();
 
   // FAITHFUL real C60 config (614336 job log), identical to [dryrun-eval].
-  auto regime = df_regime(1800u, 4320u, 120u, 42.0, 310.0);
+  auto regime = df_regime(kC60_pVDZF12);
   sequant::BatchPolicy policy;
   policy.is_batchable_index = is_df_batchable;
   policy.batch_target_size = [](Index const& ix) -> std::size_t {

From 3fc9baeb077acde83435ecc48dc62d55750b835a Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Mon, 6 Jul 2026 19:06:50 -0400
Subject: [PATCH 51/78] tests/dryrun: cut [dryrun-trace], hide [dryrun-df] dev
 sweep

Two overlapping whole-residual harnesses, neither asserting correctness:
[dryrun-trace] replayed the forest through the shared cache and wrote a per-op
trace file; [dryrun-df] prints the per-term mu~/K batch-axis escape verdict.
The trace replay is already covered by the [dryrun][cost_profile] unit tests
and the trace file is a regenerable one-off, so cut [dryrun-trace] entirely.
Keep [dryrun-df]'s per-term verdict (uniquely useful C60 diagnostic, with the
env sweep knobs) but mark it hidden ([.]) since it is a dev sweep, not a
regression test -- select it explicitly with "[dryrun-df]". The standing
tests are now [dryrun-objective] (comparative) + [dryrun-eval] (runtime replay)
+ the SizeRegime/CostModel/Result unit tests + the [peak]/[cost_profile]/[cache]
infra tests. Visible dryrun suite green (120 assertions/21 cases).
---
 tests/unit/test_eval_dryrun.cpp | 184 ++------------------------------
 1 file changed, 7 insertions(+), 177 deletions(-)

diff --git a/tests/unit/test_eval_dryrun.cpp b/tests/unit/test_eval_dryrun.cpp
index bcc81aa004..6cdcb60087 100644
--- a/tests/unit/test_eval_dryrun.cpp
+++ b/tests/unit/test_eval_dryrun.cpp
@@ -340,7 +340,11 @@ bool is_df_batchable(Index const& ix) {
 
 }  // namespace
 
-TEST_CASE("dryrun POST-transform PAO/K batch-axis verdict", "[dryrun-df]") {
+// Hidden ([.]) whole-residual dev sweep (no correctness assertions): optimizes
+// every summand and prints, per term, whether its free-mu~ giant got a mu~/K
+// batch axis or escaped slicing. Select explicitly:
+//   ./unit_tests-sequant "[dryrun-df]"
+TEST_CASE("dryrun POST-transform PAO/K batch-axis verdict", "[.][dryrun-df]") {
   // Augment the default mbpt registry with PAO (mu~) and DF-aux (K) so the
   // post-transform fixture deserializes; raise the dummy-ordinal ceiling for
   // mpqc's high internal ordinals (mu~_1152, a_21674, ...).
@@ -1866,8 +1870,8 @@ TEST_CASE("cost_profile trace stream round-trips", "[dryrun][cost_profile]") {
 // VETO caching of a free-batchable giant -- a node whose result carries a free
 // mu~/K axis the runtime slices over -- exactly as the real batched eval loop
 // does, instead of materializing it whole. The SIMPLE cache_manager(nodes) the
-// ad-hoc [dryrun-objective]/[dryrun-trace] sites use caches such a giant; the
-// gated build must not. We prove this by contrasting three configs over the
+// ad-hoc [dryrun-objective] site uses caches such a giant; the gated
+// build must not. We prove this by contrasting three configs over the
 // SAME binarized C60 giant term (index 38):
 //   ref:  no gate  (max_footprint=0, never batchable) -> giant IS cached
 //   axis: axis veto only (max_footprint=0, is_df_batchable) -> giant NOT cached
@@ -2052,177 +2056,3 @@ TEST_CASE("dryrun gated cache vetoes free-batchable giant", "[dryrun][cache]") {
              << L"\n  small intermediate exists (task) = "
              << (task_cache.exists(small_node) ? L"YES" : L"no") << L"\n";
 }
-
-// Whole-residual dry-run trace: optimize+binarize EVERY summand of the
-// post-transform PNO-CCSD doubles residual, then replay them all through the
-// real eval loop and ONE SHARED CacheManager (so cross-term CSE / persistent
-// caching is exercised, as in MPQC's process_for_evaluation), with the per-op
-// trace ("Eval | ... result= ... hw= ...") written to a FILE. Hidden ([.])
-// because the batched DP runs per summand and the trace can be hundreds of MB;
-// select it explicitly:
-//   ./unit_tests-sequant "[dryrun-trace]"
-// Env knobs (all optional):
-//   SEQUANT_UT_DRYRUN_OBJ         dense_time_space (default, perf-first) |
-//   dense_space_time SEQUANT_UT_DRYRUN_TRACE_FILE  output path (default
-//   /tmp/dryrun_residual_trace.txt) SEQUANT_UT_DRYRUN_MAX_TERMS   cap #summands
-//   (default 0 = all) -- for a quick smoke run
-TEST_CASE("dryrun whole-residual trace (PNO-CCSD doubles)",
-          "[.][dryrun-trace]") {
-  auto ctx = get_default_context().clone();
-  ctx.set_first_dummy_index_ordinal(1000000);
-  auto isr = ctx.mutable_index_space_registry();
-  REQUIRE(isr != nullptr);
-  sequant::mbpt::add_pao_spaces(isr);  // mu~
-  sequant::mbpt::add_df_spaces(isr);   // K
-  auto ctx_resetter = set_scoped_default_context(std::move(ctx));
-
-  auto const body = slurp(std::string(SEQUANT_UNIT_TESTS_SOURCE_DIR) +
-                          "/data/csv_ccsd_doubles_residual_df.txt");
-  REQUIRE(!body.empty());
-  std::string line = body;
-  if (auto nl = line.find('\n'); nl != std::string::npos)
-    line = line.substr(0, nl);
-  auto expr = deserialize<ExprPtr>(line);
-  REQUIRE(static_cast<bool>(expr));
-  REQUIRE(expr->is<Sum>());
-  auto flatten_product = [](ExprPtr const& e) -> ExprPtr {
-    if (!e->is<Product>()) return e;
-    auto const& p = e->as<Product>();
-    return ex<Product>(p.scalar(), p.factors(), Product::Flatten::Yes);
-  };
-  std::vector<ExprPtr> terms;
-  for (auto const& s : expr->as<Sum>().summands())
-    terms.push_back(flatten_product(s));
-  REQUIRE(!terms.empty());
-
-  // Objective (perf-first default; dense_space_time / dense_peak_size = peak).
-  char const* const obj_env = std::getenv("SEQUANT_UT_DRYRUN_OBJ");
-  std::string const obj_s = obj_env ? obj_env : "dense_time_space";
-  ObjectiveFunction const obj =
-      (obj_s == "dense_space_time" || obj_s == "dense_peak_size")
-          ? ObjectiveFunction::DenseSpaceTimeBatched
-          : ObjectiveFunction::DenseTimeSpaceBatched;
-  char const* const max_env = std::getenv("SEQUANT_UT_DRYRUN_MAX_TERMS");
-  std::size_t const max_terms =
-      max_env ? static_cast<std::size_t>(std::atoll(max_env)) : 0u;
-  std::size_t const n_terms =
-      (max_terms > 0 && max_terms < terms.size()) ? max_terms : terms.size();
-
-  // FAITHFUL real C60 config (614336 job log), identical to [dryrun-eval].
-  auto regime = df_regime(kC60_pVDZF12);
-  sequant::BatchPolicy policy;
-  policy.is_batchable_index = is_df_batchable;
-  policy.batch_target_size = [](Index const& ix) -> std::size_t {
-    return ix.space().base_key() == L"μ̃" ? std::size_t{256} : std::size_t{72};
-  };
-  policy.is_volatile_leaf = [](Tensor const& t) { return t.label() == L"t"; };
-  policy.accumulation_factor = 1.0;
-  policy.peak_threshold = 40e9;
-
-  // Phase 1: optimize + binarize every summand; collect the DryRun trees so one
-  // shared cache can count cross-term repeats.
-  std::vector<EvalNodeDryRun> nodes;
-  nodes.reserve(n_terms);
-  for (std::size_t ti = 0; ti < n_terms; ++ti) {
-    std::cerr << "[dryrun-trace] optimizing summand " << (ti + 1) << "/"
-              << n_terms << " ..." << std::flush;
-    auto axes_map = std::make_shared<std::unordered_map<
-        Expr const*, container::vector<container::svector<Index>>>>();
-    OptimizeOptions opts;
-    opts.objective_function = obj;
-    opts.idx_to_extent = regime.idx_to_extent();
-    opts.inner_pow = regime.inner_pow_fn();
-    opts.batch_policy = policy;
-    opts.volatile_weight = 20.0;
-    opts.roofline.machine_balance = 200.0;
-    opts.roofline.fast_mem_elems = 1000000.0;
-    opts.term_batch_axes = axes_map;
-    auto t0 = std::chrono::steady_clock::now();
-    auto optimized = optimize(terms[ti], opts);
-    auto const ms = std::chrono::duration_cast<std::chrono::milliseconds>(
-                        std::chrono::steady_clock::now() - t0)
-                        .count();
-    std::cerr << " " << ms << "ms\n";
-    if (!static_cast<bool>(optimized)) continue;
-    auto it = axes_map->find(optimized.get());
-    container::vector<container::svector<Index>> node_axes;
-    if (it != axes_map->end()) node_axes = it->second;
-    BinarizationOptions bopts;
-    bopts.node_batch_axes = node_axes;
-    SEQUANT_PRAGMA_IGNORE_DEPRECATED_BEGIN
-    nodes.push_back(binarize<EvalExprDryRun>(optimized, {}, bopts));
-    SEQUANT_PRAGMA_IGNORE_DEPRECATED_END
-  }
-  REQUIRE(!nodes.empty());
-
-  // Phase 2: route the whole-residual forest through the single shared
-  // cost_profile() entry point (Task 4/5) -- replacing the ad-hoc
-  // cache_manager(nodes) + manual per-summand replay + logger juggling this
-  // case used before Task 5. cost_profile() builds the gated dry-run cache,
-  // forces the printing gate on, replays every summand (resetting per-term
-  // non-persistent scratch while keeping persistent cross-term CSE entries),
-  // folds the batched-scratch peak, and transcodes the narrow (UTF-8) eval
-  // trace into the requested wide trace stream. We point that stream at a FILE.
-  sequant::eval::dryrun::CacheConfig cfg;
-  cfg.max_footprint = 1e11;  // faithful footprint gate
-  cfg.min_repeats = 2;       // real CSE rule (cache only 2+ repeats)
-  cfg.is_volatile = [](EvalNodeDryRun const& n) {
-    if (!n.leaf() || !n->is_tensor()) return false;
-    return n->as_tensor().label() == L"t";
-  };
-
-  char const* const file_env = std::getenv("SEQUANT_UT_DRYRUN_TRACE_FILE");
-  std::string const trace_path =
-      file_env ? file_env : "/tmp/dryrun_residual_trace.txt";
-
-  // Capture the wide trace, then re-encode it to UTF-8 bytes for the file
-  // (a raw std::wofstream would re-narrow the multi-byte index labels via the
-  // classic-locale codecvt and mangle/truncate them).
-  std::wostringstream trace_capture;
-  sequant::eval::dryrun::CostProfile const cp =
-      sequant::eval::dryrun::cost_profile(nodes, policy, cfg, regime,
-                                          &trace_capture);
-
-  std::wstring const wtrace = trace_capture.str();
-  std::string utf8;
-  utf8.reserve(wtrace.size());
-  for (wchar_t const wc : wtrace) {
-    char32_t const cp32 = static_cast<char32_t>(wc);
-    if (cp32 < 0x80) {
-      utf8.push_back(static_cast<char>(cp32));
-    } else if (cp32 < 0x800) {
-      utf8.push_back(static_cast<char>(0xC0 | (cp32 >> 6)));
-      utf8.push_back(static_cast<char>(0x80 | (cp32 & 0x3F)));
-    } else if (cp32 < 0x10000) {
-      utf8.push_back(static_cast<char>(0xE0 | (cp32 >> 12)));
-      utf8.push_back(static_cast<char>(0x80 | ((cp32 >> 6) & 0x3F)));
-      utf8.push_back(static_cast<char>(0x80 | (cp32 & 0x3F)));
-    } else {
-      utf8.push_back(static_cast<char>(0xF0 | (cp32 >> 18)));
-      utf8.push_back(static_cast<char>(0x80 | ((cp32 >> 12) & 0x3F)));
-      utf8.push_back(static_cast<char>(0x80 | ((cp32 >> 6) & 0x3F)));
-      utf8.push_back(static_cast<char>(0x80 | (cp32 & 0x3F)));
-    }
-  }
-  {
-    std::ofstream trace_file(trace_path, std::ios::binary);
-    REQUIRE(trace_file.is_open());
-    trace_file.write(utf8.data(), static_cast<std::streamsize>(utf8.size()));
-  }
-  std::size_t const trace_bytes = utf8.size();
-
-  std::wcerr << L"\n=== [dryrun-trace] whole-residual trace written ===\n"
-             << L"objective    = "
-             << (obj == ObjectiveFunction::DenseTimeSpaceBatched
-                     ? L"dense_time_space (perf-first)"
-                     : L"dense_space_time (peak-first)")
-             << L"\nsummands     = " << nodes.size() << L" optimized"
-             << L"\nn_ops        = " << cp.n_ops << L"  peak_bytes="
-             << (cp.peak_bytes / 1e9) << L" GB" << L"\ntrace file   = "
-             << std::wstring(trace_path.begin(), trace_path.end()) << L" ("
-             << trace_bytes << L" bytes)\n";
-
-  CHECK(std::isfinite(cp.peak_bytes));
-  CHECK(cp.peak_bytes > 0.0);
-  CHECK(trace_bytes > 0);
-}

From 90c339af07e7d02cd5a02f0bd94ffc65989ba0d9 Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Tue, 7 Jul 2026 02:52:54 -0400
Subject: [PATCH 52/78] tests/dryrun: add [dryrun-perfcost] perf-vs-peak
 modelled cost sweep

Sweeps all 55 C60 residual terms under both objectives and reports the
summed-flops ratio (perf-first/peak-first) and max modelled peak per
objective -- the decision input for whether enabling dense_time_space
(perf-first) at scale is worth it. Test-only; no production change.
Result: ratio 0.142 (perf-first ~7x fewer flops), max peak 49.5 vs 5862 GB.
---
 tests/unit/test_eval_dryrun.cpp | 167 ++++++++++++++++++++++++++++++++
 1 file changed, 167 insertions(+)

diff --git a/tests/unit/test_eval_dryrun.cpp b/tests/unit/test_eval_dryrun.cpp
index 6cdcb60087..e6ef6656e8 100644
--- a/tests/unit/test_eval_dryrun.cpp
+++ b/tests/unit/test_eval_dryrun.cpp
@@ -1503,6 +1503,173 @@ TEST_CASE(
   CHECK(perf_first.cp.peak_bytes > 5e11);
 }
 
+// Task 1 (P0, dry-run cost-model comparison): perf-first
+// (DenseTimeSpaceBatched) vs peak-first (DenseSpaceTimeBatched) modelled
+// flops/peak, swept over ALL summands of the real C60 residual (not just the
+// index-38 giant the case above focuses on). This is the decision input for
+// whether enabling perf-first at scale is worth it: the summed-flops ratio
+// (perf-first total flops / peak-first total flops) is the modelled
+// per-iteration speedup ceiling, and the max modelled peak per objective
+// shows the memory spread. This is a MODELLED (flops) proxy, not a
+// wall-clock measurement -- see the note at the end of this case.
+TEST_CASE(
+    "dryrun perf-first vs peak-first modelled cost across all C60 residual "
+    "terms",
+    "[dryrun-perfcost]") {
+  auto ctx = get_default_context().clone();
+  ctx.set_first_dummy_index_ordinal(1000000);
+  auto isr = ctx.mutable_index_space_registry();
+  REQUIRE(isr != nullptr);
+  sequant::mbpt::add_pao_spaces(isr);  // mu~
+  sequant::mbpt::add_df_spaces(isr);   // K
+  auto ctx_resetter = set_scoped_default_context(std::move(ctx));
+
+  auto const body = slurp(std::string(SEQUANT_UNIT_TESTS_SOURCE_DIR) +
+                          "/data/csv_ccsd_doubles_residual_df.txt");
+  REQUIRE(!body.empty());
+  std::string line = body;
+  if (auto nl = line.find('\n'); nl != std::string::npos)
+    line = line.substr(0, nl);
+  auto expr = deserialize<ExprPtr>(line);
+  REQUIRE(static_cast<bool>(expr));
+  REQUIRE(expr->is<Sum>());
+  auto const& summands = expr->as<Sum>().summands();
+  REQUIRE(!summands.empty());
+  auto flatten_product = [](ExprPtr const& e) -> ExprPtr {
+    if (!e->is<Product>()) return e;
+    auto const& p = e->as<Product>();
+    return ex<Product>(p.scalar(), p.factors(), Product::Flatten::Yes);
+  };
+
+  // FAITHFUL real C60 config (same regime as [dryrun-objective] above): the
+  // measured heavy-tailed CSV moments in kC60_pVDZF12.
+  auto regime = df_regime(kC60_pVDZF12);
+
+  struct Analysis {
+    sequant::eval::dryrun::CostProfile cp;
+  };
+
+  // Optimize `giant` under `obj`, binarize, and return the modeled cost
+  // profile (flops/peak_bytes/exec_cost) via the single shared
+  // cost_profile() entry point -- the same policy/cache setup as
+  // [dryrun-objective]'s analyze() above, minus the per-node free-mu~
+  // structural walk (not needed for this aggregate sweep).
+  auto analyze = [&](ExprPtr const& giant, ObjectiveFunction obj) -> Analysis {
+    sequant::BatchPolicy policy;
+    policy.is_batchable_index = is_df_batchable;
+    policy.batch_target_size = [](Index const& ix) -> std::size_t {
+      return ix.space().base_key() == L"μ̃" ? std::size_t{256} : std::size_t{72};
+    };
+    policy.is_volatile_leaf = [](Tensor const& t) { return t.label() == L"t"; };
+    policy.accumulation_factor = 1.0;
+    policy.peak_threshold =
+        (std::getenv("SEQUANT_UT_DRYRUN_PEAK_THR_GB")
+             ? std::atof(std::getenv("SEQUANT_UT_DRYRUN_PEAK_THR_GB"))
+             : 40.0) *
+        1e9;
+
+    auto axes_map = std::make_shared<std::unordered_map<
+        Expr const*, container::vector<container::svector<Index>>>>();
+    OptimizeOptions opts;
+    opts.objective_function = obj;
+    opts.idx_to_extent = regime.idx_to_extent();
+    opts.inner_pow = regime.inner_pow_fn();
+    opts.batch_policy = policy;
+    opts.volatile_weight = 20.0;
+    opts.roofline.machine_balance = 200.0;
+    opts.roofline.fast_mem_elems = 1000000.0;
+    opts.term_batch_axes = axes_map;
+
+    auto optimized = optimize(giant, opts);
+    REQUIRE(static_cast<bool>(optimized));
+    auto it = axes_map->find(optimized.get());
+    container::vector<container::svector<Index>> node_axes;
+    if (it != axes_map->end()) node_axes = it->second;
+    BinarizationOptions bopts;
+    bopts.node_batch_axes = node_axes;
+    SEQUANT_PRAGMA_IGNORE_DEPRECATED_BEGIN
+    auto node = binarize<EvalExprDryRun>(optimized, {}, bopts);
+    SEQUANT_PRAGMA_IGNORE_DEPRECATED_END
+
+    sequant::eval::dryrun::CacheConfig cfg;
+    cfg.max_footprint = 1e11;
+    cfg.min_repeats = 1;
+    cfg.is_volatile = [](EvalNodeDryRun const& n) {
+      if (!n.leaf() || !n->is_tensor()) return false;
+      return n->as_tensor().label() == L"t";
+    };
+    Analysis a;
+    a.cp = sequant::eval::dryrun::cost_profile(
+        std::vector<EvalNodeDryRun>{node}, policy, cfg, regime,
+        /*trace=*/nullptr);
+    return a;
+  };
+
+  double total_peak_first_flops = 0.0, total_perf_first_flops = 0.0;
+  double max_peak_first_peak_gb = 0.0, max_perf_first_peak_gb = 0.0;
+  std::size_t n_ok = 0, n_skipped = 0;
+
+  std::wcerr << L"\n=== [dryrun-perfcost] per-term peak-first vs perf-first "
+                L"modelled cost (C60 residual, "
+             << summands.size() << L" terms) ===\n";
+
+  for (std::size_t t = 0; t < summands.size(); ++t) {
+    ExprPtr giant = flatten_product(summands[t]);
+    if (!giant) {
+      std::wcerr << L"perfcost term " << t << L": skipped (null term)\n";
+      ++n_skipped;
+      continue;
+    }
+
+    bool ok = true;
+    Analysis peak_first, perf_first;
+    try {
+      peak_first = analyze(giant, ObjectiveFunction::DenseSpaceTimeBatched);
+      perf_first = analyze(giant, ObjectiveFunction::DenseTimeSpaceBatched);
+    } catch (std::exception const&) {
+      ok = false;
+    } catch (...) {
+      ok = false;
+    }
+    if (!ok) {
+      std::wcerr << L"term " << t << L": skipped\n";
+      ++n_skipped;
+      continue;
+    }
+
+    ++n_ok;
+    double const peak_first_gb = peak_first.cp.peak_bytes / 1e9;
+    double const perf_first_gb = perf_first.cp.peak_bytes / 1e9;
+    std::wcerr << L"perfcost term " << t << L" | peak_first flops="
+               << peak_first.cp.flops << L" peak_GB=" << peak_first_gb
+               << L" | perf_first flops=" << perf_first.cp.flops << L" peak_GB="
+               << perf_first_gb << L"\n";
+
+    total_peak_first_flops += peak_first.cp.flops;
+    total_perf_first_flops += perf_first.cp.flops;
+    if (peak_first_gb > max_peak_first_peak_gb)
+      max_peak_first_peak_gb = peak_first_gb;
+    if (perf_first_gb > max_perf_first_peak_gb)
+      max_perf_first_peak_gb = perf_first_gb;
+  }
+
+  double const ratio = total_peak_first_flops > 0.0
+                           ? total_perf_first_flops / total_peak_first_flops
+                           : 0.0;
+  std::wcerr << L"perfcost TOTAL peak_first_flops=" << total_peak_first_flops
+             << L" perf_first_flops=" << total_perf_first_flops
+             << L" ratio(perf/peak)=" << ratio << L"\n";
+  std::wcerr << L"perfcost MAXPEAK peak_first=" << max_peak_first_peak_gb
+             << L" perf_first=" << max_perf_first_peak_gb << L"\n";
+  std::wcerr << L"perfcost: " << n_ok << L" of " << summands.size()
+             << L" terms analyzed, " << n_skipped << L" skipped\n";
+
+  // Deliverable is the printed table + ratio above (decision input for D1),
+  // not a pass/fail gate -- assert only basic sanity: at least one term
+  // produced a positive modelled flops count under the peak-first objective.
+  REQUIRE(total_peak_first_flops > 0.0);
+}
+
 // Task 3: the opt-in scratch-fold peak sink captures the batched-inner peak the
 // OUTER cache.working_set_hwmark() misses. Reuse the [dryrun-objective]
 // peak-first (DenseSpaceTimeBatched) setup -- the objective whose batched-inner

From 10a055290206ad2a19e58e199e997459c98eae25 Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Tue, 7 Jul 2026 16:45:48 -0400
Subject: [PATCH 53/78] eval: make the core evaluate() traversal iterative
 (explicit stack)

Replace the code-recursive descent in evaluate(node, le, cache) -- the only
evaluate overload with unbounded recursion (the layout/multi-root overloads
just wrap or loop over it) -- with an explicit std::deque work stack. Depth is
now bounded by the heap, not the C++ call stack, so a deep tree (a Sum or
product chain with many operands) no longer risks a stack overflow in the
traversal. The per-node cache key is EvalExpr's stored O(1) hash, so nothing in
the walk recurses.

The rewrite preserves behavior byte-identically:
 - Checked cache wrapper: a hit returns the phase-applied cached pointer; a miss
   on a mapped node schedules a store once computed (the store_after flag
   replaces the recursive evaluate<..., Unchecked> re-entry).
 - Custom-evaluator interception is consulted when a frame is first visited and
   a non-null result short-circuits the subtree (children never pushed) -- the
   subtree pruning batched eval relies on is unchanged.
 - leaf / Adjoint / Sum / Product dispatch, the shaped-product hook, de-nesting,
   canonicalization-phase multiplication, eager per-op release, and every trace
   log site (MultByPhase, custom-eval, leaf, binary, cache access/store) are
   carried over unchanged.

Verified against the eval oracle ([eval_tapp], [dryrun-eval] incl. the batched
custom-evaluator giant-term replay, [dryrun-leaf/result/nested/costmodel],
[EvalNode], [EvalExpr]): 247 assertions in 16 cases, identical to the
pre-refactor baseline.

Note: this makes the *traversal* stack-safe; binarize/EvalExpr construction and
FullBinaryNode's (unique_ptr-owned) destructor remain code-recursive and would
overflow first on a single very deep tree. Full-pipeline stack-safety for one
arbitrarily deep tree would need those addressed too; in current use the
residual is a vector of shallow summand trees.
---
 SeQuant/core/eval/eval.hpp | 387 +++++++++++++++++++++++--------------
 1 file changed, 239 insertions(+), 148 deletions(-)

diff --git a/SeQuant/core/eval/eval.hpp b/SeQuant/core/eval/eval.hpp
index 4d8fcdcb87..1c5d1ea649 100644
--- a/SeQuant/core/eval/eval.hpp
+++ b/SeQuant/core/eval/eval.hpp
@@ -21,6 +21,7 @@
 #include <any>
 #include <atomic>
 #include <chrono>
+#include <deque>
 #include <iostream>
 #include <optional>
 #include <stdexcept>
@@ -514,9 +515,20 @@ template <typename Node>
 /// \tparam EvalTrace If Trace::On, trace is written to the logger's stream.
 ///                   Default is to follow Trace::Default, which is itself
 ///                   equal to Trace::On or Trace::Off.
-/// \tparam Cache If CacheCache::Checked (default) the \p cache will be
-///               checked before evaluating. It is used to detect the base case
-///               for recursion to prevent infinite recursion.
+/// \tparam Cache If CacheCache::Checked (default) the root \p node is looked up
+///               in \p cache before evaluating; a hit short-circuits it. Child
+///               nodes are always evaluated Checked. Unchecked skips the lookup
+///               for the root only.
+///
+/// \note The traversal is iterative: it maintains its own explicit work stack
+///       (a `std::deque` of frames) rather than recursing, so evaluation depth
+///       is bounded by the heap, not the C++ call stack. This keeps deep trees
+///       (e.g. a Sum or product chain with thousands of operands) stack-safe.
+///       Custom-evaluator interception is preserved exactly: it is consulted
+///       when a frame is first visited and a non-null result short-circuits the
+///       subtree (its children are never pushed), so subtree pruning -- the
+///       mechanism batched eval relies on -- is unaffected.
+///
 /// \param node A node that can be evaluated using \p le as the leaf
 ///             evaluator.
 /// \param le The leaf evaluator that satisfies
@@ -531,170 +543,249 @@ template <Trace EvalTrace = Trace::Default,
 ResultPtr evaluate(Node const& node,  //
                    F const& le,       //
                    CacheManager<N, FHC>& cache) {
-  if constexpr (Cache == detail::CacheCheck::Checked) {  // return from cache if
-                                                         // found
-
-    auto mult_by_phase = [&node, &cache](ResultPtr res) {
-      auto phase = node->canon_phase();
-      if (phase == 1) return res;
-
-      ResultPtr post;
-      auto time = detail::timed_eval_inplace(
-          [&]() { post = res->mult_by_phase(phase); });
-
-      if constexpr (detail::trace(EvalTrace)) {
-        size_t hwmark = log::bytes(cache, post).value;
-        if (!cache.alive(node)) hwmark += log::bytes(res).value;
-        auto stat =
-            log::EvalStat{.mode = log::EvalMode::MultByPhase,
-                          .time = time,
-                          .mem_result = log::bytes(post),
-                          .mem_alloc = log::bytes(post),
-                          .mem_hwmark = {cache.note_working_set(hwmark)}};
-        log::eval(stat, std::format("{} * {}", phase, node->label()));
-      }
-      return post;
-    };
+  // Multiply a (possibly cached) result by its node's canonicalization phase.
+  // Formerly the `mult_by_phase` lambda local to the Checked wrapper.
+  auto apply_phase = [&cache](auto const& nd, ResultPtr res) -> ResultPtr {
+    auto phase = nd->canon_phase();
+    if (phase == 1) return res;
 
-    if (auto ptr = cache.access(node); ptr) {
-      if constexpr (detail::trace(EvalTrace))
-        log::cache(node, cache, log::label(node));
-
-      return mult_by_phase(ptr);
-    } else if (cache.exists(node)) {
-      auto ptr = cache.store(
-          node,
-          mult_by_phase(evaluate<EvalTrace, detail::CacheCheck::Unchecked>(
-              node, le, cache)));
-      if constexpr (detail::trace(EvalTrace))
-        log::cache(node, cache, log::label(node));
+    ResultPtr post;
+    auto time =
+        detail::timed_eval_inplace([&]() { post = res->mult_by_phase(phase); });
 
-      return mult_by_phase(ptr);
-    } else {
-      // do nothing
+    if constexpr (detail::trace(EvalTrace)) {
+      size_t hwmark = log::bytes(cache, post).value;
+      if (!cache.alive(nd)) hwmark += log::bytes(res).value;
+      auto stat = log::EvalStat{.mode = log::EvalMode::MultByPhase,
+                                .time = time,
+                                .mem_result = log::bytes(post),
+                                .mem_alloc = log::bytes(post),
+                                .mem_hwmark = {cache.note_working_set(hwmark)}};
+      log::eval(stat, std::format("{} * {}", phase, nd->label()));
     }
-  }
+    return post;
+  };
 
-  ResultPtr result;
-  ResultPtr left;
-  ResultPtr right;
-
-  log::Duration time;
-
-  // Custom-evaluator interception: before the standard scheme, a non-leaf node
-  // may be evaluated by the cache's custom evaluator (e.g. blocked over a
-  // contracted index to bound peak memory). A non-null result is used (and
-  // cached by the Checked wrapper) as-is; null declines to the standard scheme
-  // below. See CacheManager::custom_evaluator_type.
-  if (!node.leaf()) {
-    if (auto const& custom_eval = cache.custom_evaluator(); custom_eval) {
-      ResultPtr intercepted;
-      time = detail::timed_eval_inplace(
-          [&]() { intercepted = custom_eval(node, cache); });
-      if (intercepted) {
-        if constexpr (detail::trace(EvalTrace)) {
-          log::eval(log::EvalStat{.mode = log::eval_mode(node),
+  // One entry of the explicit evaluation stack. `stage` records how far a node
+  // has progressed; `left`/`right` hold its evaluated operands; `store_after`
+  // marks a Checked node that exists in the cache map but has not been stored
+  // yet, so its computed result must be cached (this replaces the recursive
+  // wrapper's `evaluate<..., Unchecked>` re-entry).
+  enum class Stage { Enter, NeedLeft, NeedRight, NeedLeftAdj };
+  struct Frame {
+    Node node;
+    bool checked;
+    Stage stage = Stage::Enter;
+    bool store_after = false;
+    ResultPtr left, right;
+  };
+
+  // Finalize a freshly computed Phase-B result: if this Checked node needs
+  // storing, cache it (phase-applied) and hand back the phase-applied cached
+  // pointer -- exactly the recursive Checked wrapper's store path. Otherwise
+  // pass the raw result through unchanged.
+  auto finish_phase_b = [&cache, &apply_phase](Frame const& f,
+                                               ResultPtr rb) -> ResultPtr {
+    if (!f.store_after) return rb;
+    auto ptr = cache.store(f.node, apply_phase(f.node, std::move(rb)));
+    if constexpr (detail::trace(EvalTrace))
+      log::cache(f.node, cache, log::label(f.node));
+    return apply_phase(f.node, ptr);
+  };
+
+  // A `std::deque` is used so that a reference to the top frame stays valid
+  // across push_back (which reallocates a `std::vector`).
+  std::deque<Frame> stk;
+  stk.push_back(
+      Frame{.node = node, .checked = (Cache == detail::CacheCheck::Checked)});
+
+  ResultPtr ret;  // result handed up by the frame that most recently finalized
+
+  // Deliver `r` to the parent frame and pop the just-completed frame.
+  auto finalize = [&stk, &ret](ResultPtr r) {
+    ret = std::move(r);
+    stk.pop_back();
+  };
+
+  while (!stk.empty()) {
+    Frame& f = stk.back();
+
+    switch (f.stage) {
+      case Stage::Enter: {
+        // --- Checked cache wrapper: a hit returns directly; a miss on a node
+        //     that exists in the map schedules a store once computed. ---
+        if (f.checked) {
+          if (auto ptr = cache.access(f.node); ptr) {
+            if constexpr (detail::trace(EvalTrace))
+              log::cache(f.node, cache, log::label(f.node));
+            finalize(apply_phase(f.node, ptr));
+            break;
+          }
+          f.store_after = cache.exists(f.node);
+        }
+
+        // --- Custom-evaluator interception (non-leaf only): a non-null result
+        //     short-circuits the subtree -- children are never pushed. This is
+        //     the subtree pruning batched eval relies on; see the class note. A
+        //     null return declines to the standard scheme below. ---
+        if (!f.node.leaf()) {
+          if (auto const& custom_eval = cache.custom_evaluator(); custom_eval) {
+            ResultPtr intercepted;
+            auto time = detail::timed_eval_inplace(
+                [&]() { intercepted = custom_eval(f.node, cache); });
+            if (intercepted) {
+              if constexpr (detail::trace(EvalTrace)) {
+                log::eval(
+                    log::EvalStat{.mode = log::eval_mode(f.node),
                                   .time = time,
                                   .mem_result = log::bytes(intercepted),
                                   .mem_alloc = log::bytes(intercepted),
                                   .mem_hwmark = {cache.note_working_set(
                                       log::bytes(cache, intercepted).value)}},
-                    log::label(node));
+                    log::label(f.node));
+              }
+              log::release_after_op();
+              finalize(finish_phase_b(f, std::move(intercepted)));
+              break;
+            }
+          }
         }
-        log::release_after_op();
-        return intercepted;
+
+        // --- Leaf. ---
+        if (f.node.leaf()) {
+          ResultPtr result;
+          auto time =
+              detail::timed_eval_inplace([&]() { result = le(f.node); });
+          if constexpr (detail::trace(EvalTrace)) {
+            log::eval(log::EvalStat{.mode = log::eval_mode(f.node),
+                                    .time = time,
+                                    .mem_result = log::bytes(result),
+                                    .mem_alloc = log::bytes(result),
+                                    .mem_hwmark = {cache.note_working_set(
+                                        log::bytes(cache, result).value)}},
+                      log::label(f.node));
+          }
+          log::release_after_op();
+          finalize(finish_phase_b(f, std::move(result)));
+          break;
+        }
+
+        // --- Internal node: request the left operand (always Checked). The
+        //     stage must advance before the push (push may grow the deque). ---
+        f.stage = (f.node->op_type() == EvalOp::Adjoint) ? Stage::NeedLeftAdj
+                                                         : Stage::NeedLeft;
+        stk.push_back(Frame{.node = f.node.left(), .checked = true});
+        break;
       }
-    }
-  }
 
-  if (node.leaf()) {
-    time = detail::timed_eval_inplace([&]() { result = le(node); });
-  } else if (node->op_type() == EvalOp::Adjoint) {
-    // Unary IR op: dispatch on left operand only; right is the Constant(1)
-    // sentinel kept around to preserve FullBinaryNode's invariant. We
-    // intentionally skip evaluating the sentinel — leaf evaluators that
-    // can't manufacture scalar constants (rare in practice but possible)
-    // would otherwise be invoked needlessly.
-    left = evaluate<EvalTrace>(node.left(), le, cache);
-    SEQUANT_ASSERT(left);
-    std::array<std::any, 2> const adj_ann{node.left()->annot(), node->annot()};
-    time =
-        detail::timed_eval_inplace([&]() { result = left->adjoint(adj_ann); });
-  } else {
-    left = evaluate<EvalTrace>(node.left(), le, cache);
-    right = evaluate<EvalTrace>(node.right(), le, cache);
-    SEQUANT_ASSERT(left);
-    SEQUANT_ASSERT(right);
-
-    std::array<std::any, 3> const ann{node.left()->annot(),
-                                      node.right()->annot(), node->annot()};
-    if (node->op_type() == EvalOp::Sum) {
-      time = detail::timed_eval_inplace(
-          [&]() { result = left->sum(*right, ann); });
-    } else {
-      SEQUANT_ASSERT(node->op_type() == EvalOp::Product);
-      // Consult the shaped-product hook (if set) before evaluating the product.
-      // The hook receives the node (wrapped in a std::any as a
-      // std::reference_wrapper so the full IR node is inspectable) plus the
-      // evaluated operands and annotations; a non-null return *replaces* the
-      // normal product (e.g. a shape-constrained emission of it), a null return
-      // declines and the standard prod() below runs.  An empty hook is never
-      // consulted; default-empty => byte-identical behavior.
-      auto const de_nest =
-          node.left()->tot() && node.right()->tot() && !node->tot();
-      if (auto const& hook = cache.shaped_product_hook(); hook) {
-        time = detail::timed_eval_inplace([&]() {
-          result = hook(std::any{std::cref(node)}, *left, *right, ann);
-        });
+      case Stage::NeedLeftAdj: {
+        // Unary IR op (Adjoint): only the left operand is evaluated; the right
+        // child is the Constant(1) sentinel kept to preserve FullBinaryNode's
+        // invariant, and is intentionally never pushed.
+        f.left = std::move(ret);
+        SEQUANT_ASSERT(f.left);
+        std::array<std::any, 2> const adj_ann{f.node.left()->annot(),
+                                              f.node->annot()};
+        ResultPtr result;
+        auto time = detail::timed_eval_inplace(
+            [&]() { result = f.left->adjoint(adj_ann); });
+
+        if constexpr (detail::trace(EvalTrace)) {
+          // `right` is null here (see log::bytes() null tolerance).
+          size_t hwmark = log::bytes(cache, result).value;
+          if (!cache.alive(f.node.left()) || f.node.left()->canon_phase() != 1)
+            hwmark += log::bytes(f.left).value;
+          log::eval(
+              log::EvalStat{.mode = log::eval_mode(f.node),
+                            .time = time,
+                            .mem_result = log::bytes(result),
+                            .mem_alloc = log::bytes(result),
+                            .mem_hwmark = {cache.note_working_set(hwmark)},
+                            .mem_left = log::bytes(f.left),
+                            .mem_right = log::bytes(f.right)},
+              log::label(f.node));
+        }
+        log::release_after_op();
+        finalize(finish_phase_b(f, std::move(result)));
+        break;
       }
-      if (!result) {
-        time = detail::timed_eval_inplace([&]() {
-          result =
-              left->prod(*right, ann, de_nest ? DeNest::True : DeNest::False);
-        });
+
+      case Stage::NeedLeft: {
+        f.left = std::move(ret);
+        SEQUANT_ASSERT(f.left);
+        f.stage = Stage::NeedRight;
+        stk.push_back(Frame{.node = f.node.right(), .checked = true});
+        break;
       }
-    }
-  }
 
-  SEQUANT_ASSERT(result);
+      case Stage::NeedRight: {
+        f.right = std::move(ret);
+        SEQUANT_ASSERT(f.left);
+        SEQUANT_ASSERT(f.right);
+
+        std::array<std::any, 3> const ann{
+            f.node.left()->annot(), f.node.right()->annot(), f.node->annot()};
+        ResultPtr result;
+        log::Duration time;
+        if (f.node->op_type() == EvalOp::Sum) {
+          time = detail::timed_eval_inplace(
+              [&]() { result = f.left->sum(*f.right, ann); });
+        } else {
+          SEQUANT_ASSERT(f.node->op_type() == EvalOp::Product);
+          // Consult the shaped-product hook (if set) before evaluating the
+          // product. The hook receives the node (wrapped in a std::any as a
+          // std::reference_wrapper so the full IR node is inspectable) plus the
+          // evaluated operands and annotations; a non-null return *replaces*
+          // the normal product (e.g. a shape-constrained emission of it), a
+          // null return declines and the standard prod() below runs. An empty
+          // hook is never consulted; default-empty => byte-identical behavior.
+          auto const de_nest =
+              f.node.left()->tot() && f.node.right()->tot() && !f.node->tot();
+          if (auto const& hook = cache.shaped_product_hook(); hook) {
+            time = detail::timed_eval_inplace([&]() {
+              result =
+                  hook(std::any{std::cref(f.node)}, *f.left, *f.right, ann);
+            });
+          }
+          if (!result) {
+            time = detail::timed_eval_inplace([&]() {
+              result = f.left->prod(*f.right, ann,
+                                    de_nest ? DeNest::True : DeNest::False);
+            });
+          }
+        }
 
-  // logging
-  if constexpr (detail::trace(EvalTrace)) {
-    if (node.leaf()) {
-      log::eval(log::EvalStat{.mode = log::eval_mode(node),
-                              .time = time,
-                              .mem_result = log::bytes(result),
-                              .mem_alloc = log::bytes(result),
-                              .mem_hwmark = {cache.note_working_set(
-                                  log::bytes(cache, result).value)}},
-                log::label(node));
-    } else {
-      // A cached child is *distinct* from the local left/right when its
-      // canon_phase != 1, because mult_by_phase allocates a fresh buffer
-      // while the cache still holds the pre-phase data. So only skip the
-      // local's bytes when the cache aliases the same buffer (phase == 1).
-      // Adjoint nodes evaluate only the left operand (the right child is the
-      // sentinel Constant(1) — see the Adjoint branch above), so `right` is
-      // null; log::bytes() tolerates a null shared_ptr for that reason.
-      size_t hwmark = log::bytes(cache, result).value;
-      if (!cache.alive(node.left()) || node.left()->canon_phase() != 1)
-        hwmark += log::bytes(left).value;
-      if (right &&
-          (!cache.alive(node.right()) || node.right()->canon_phase() != 1))
-        hwmark += log::bytes(right).value;
-      log::eval(log::EvalStat{.mode = log::eval_mode(node),
-                              .time = time,
-                              .mem_result = log::bytes(result),
-                              .mem_alloc = log::bytes(result),
-                              .mem_hwmark = {cache.note_working_set(hwmark)},
-                              .mem_left = log::bytes(left),
-                              .mem_right = log::bytes(right)},
-                log::label(node));
+        SEQUANT_ASSERT(result);
+
+        if constexpr (detail::trace(EvalTrace)) {
+          // A cached child is *distinct* from the local left/right when its
+          // canon_phase != 1, because apply_phase allocates a fresh buffer
+          // while the cache still holds the pre-phase data. So only skip the
+          // local's bytes when the cache aliases the same buffer (phase == 1).
+          size_t hwmark = log::bytes(cache, result).value;
+          if (!cache.alive(f.node.left()) || f.node.left()->canon_phase() != 1)
+            hwmark += log::bytes(f.left).value;
+          if (f.right && (!cache.alive(f.node.right()) ||
+                          f.node.right()->canon_phase() != 1))
+            hwmark += log::bytes(f.right).value;
+          log::eval(
+              log::EvalStat{.mode = log::eval_mode(f.node),
+                            .time = time,
+                            .mem_result = log::bytes(result),
+                            .mem_alloc = log::bytes(result),
+                            .mem_hwmark = {cache.note_working_set(hwmark)},
+                            .mem_left = log::bytes(f.left),
+                            .mem_right = log::bytes(f.right)},
+              log::label(f.node));
+        }
+        log::release_after_op();
+        finalize(finish_phase_b(f, std::move(result)));
+        break;
+      }
     }
   }
 
-  log::release_after_op();
-  return result;
+  return ret;
 }
 
 ///

From 7755751cf4c96beb1467064b95063f7c55b64088 Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Tue, 7 Jul 2026 17:26:12 -0400
Subject: [PATCH 54/78] binary_node: make deep_copy, transform_node, and the
 destructor iterative

FullBinaryNode owns its children by unique_ptr, so the implicitly-generated
destructor recursed to the tree's depth; deep_copy() and the free function
transform_node() likewise recursed. On a deep tree (a long contraction chain or
a nested Sum) these overflowed the C++ call stack at depth ~thousands, which is
why building/copying/destroying such a tree crashed before evaluation even ran.

Replace all three with explicit-stack iterative implementations:
 - ~FullBinaryNode() dismantles the subtree via a work list, detaching each
   node's children before it is destroyed so every node destruction is O(1).
 - deep_copy() and transform_node() do an iterative post-order build with an
   explicit frame stack (std::deque, so a top-frame reference survives
   push_back). transform_node applies its data map post-order; as a pure map its
   application order is immaterial, and its only callers (typed binarize<T> and
   the TA to_ta_node helper) are order-insensitive.

The tree fold (fold_left_to_node / the range-accumulate ctor) and the tree
visitors (detail::visit, parent-pointer based) were already iterative. size(),
operator==, and digraph/tikz remain recursive but are not on the deep-tree
build/eval/destroy path.

Adds a [FullBinaryNode][stack-safety] test that builds, copies, transform_nodes,
and destroys a depth-200000 tree (all O(N)); pre-refactor this overflowed the
stack. Full FullBinaryNode + eval suites remain green.
---
 SeQuant/core/binary_node.hpp    | 110 +++++++++++++++++++++++++++++---
 tests/unit/test_binary_node.cpp |  45 +++++++++++++
 2 files changed, 147 insertions(+), 8 deletions(-)

diff --git a/SeQuant/core/binary_node.hpp b/SeQuant/core/binary_node.hpp
index f656d62483..5d0acb51be 100644
--- a/SeQuant/core/binary_node.hpp
+++ b/SeQuant/core/binary_node.hpp
@@ -3,10 +3,12 @@
 
 #include <SeQuant/core/utility/macros.hpp>
 
+#include <deque>
 #include <memory>
 #include <sstream>
 #include <type_traits>
 #include <utility>
+#include <vector>
 
 #include <range/v3/numeric/accumulate.hpp>
 #include <range/v3/range/access.hpp>
@@ -240,9 +242,44 @@ class FullBinaryNode {
   FullBinaryNode<T>* parent_{nullptr};
 
   node_ptr deep_copy() const {
-    return leaf() ? std::make_unique<FullBinaryNode<T>>(data_)
-                  : std::make_unique<FullBinaryNode<T>>(
-                        data_, left_->deep_copy(), right_->deep_copy());
+    // Iterative post-order clone: build the copy bottom-up with an explicit
+    // stack so cloning a deep tree does not recurse to the tree's depth (which
+    // could overflow the C++ call stack).
+    struct Frame {
+      explicit Frame(FullBinaryNode const* s) : src{s} {}
+      FullBinaryNode const* src;
+      int stage = 0;
+      node_ptr left, right;
+    };
+    std::deque<Frame> stk;
+    stk.push_back(Frame{this});
+    node_ptr ret;
+    while (!stk.empty()) {
+      Frame& f = stk.back();
+      if (f.src->leaf()) {
+        ret = std::make_unique<FullBinaryNode<T>>(f.src->data_);
+        stk.pop_back();
+        continue;
+      }
+      switch (f.stage) {
+        case 0:
+          f.stage = 1;
+          stk.push_back(Frame{f.src->left_.get()});
+          break;
+        case 1:
+          f.left = std::move(ret);
+          f.stage = 2;
+          stk.push_back(Frame{f.src->right_.get()});
+          break;
+        default:
+          f.right = std::move(ret);
+          ret = std::make_unique<FullBinaryNode<T>>(
+              f.src->data_, std::move(f.left), std::move(f.right));
+          stk.pop_back();
+          break;
+      }
+    }
+    return ret;
   }
 
   template <typename Ptr>
@@ -360,6 +397,26 @@ class FullBinaryNode {
     return *this;
   }
 
+  ///
+  /// Destructor. Dismantles the subtree iteratively so that destroying a deep
+  /// tree does not recurse to the tree's depth: children are owned by
+  /// unique_ptr, so the implicitly-generated destructor would recurse and can
+  /// overflow the C++ call stack. Each node is detached from its children
+  /// before being destroyed, so every individual node destruction is O(1).
+  ~FullBinaryNode() {
+    if (!left_ && !right_) return;
+    std::vector<node_ptr> pending;
+    if (left_) pending.push_back(std::move(left_));
+    if (right_) pending.push_back(std::move(right_));
+    while (!pending.empty()) {
+      node_ptr n = std::move(pending.back());
+      pending.pop_back();
+      if (n->left_) pending.push_back(std::move(n->left_));
+      if (n->right_) pending.push_back(std::move(n->right_));
+      // n is destroyed here with both children already detached => O(1).
+    }
+  }
+
   ///
   /// \return Left node if this is an internal node, throws otherwise.
   ///
@@ -643,12 +700,49 @@ bool operator==(FullBinaryNode<T> const& lhs, FullBinaryNode<U> const& rhs) {
 template <typename T, typename F,
           typename = std::enable_if_t<std::is_invocable_v<F, T>>>
 auto transform_node(FullBinaryNode<T> const& node, F fun) {
-  if (node.leaf())
-    return FullBinaryNode(fun(*node));
-  else {
-    return FullBinaryNode(fun(*node), transform_node(node.left(), fun),
-                          transform_node(node.right(), fun));
+  using R = std::decay_t<std::invoke_result_t<F, T const&>>;
+  using RNode = FullBinaryNode<R>;
+  using rptr = typename RNode::node_ptr;
+  // Iterative post-order transform: build the transformed tree bottom-up with
+  // an explicit stack so transforming a deep tree does not recurse to the
+  // tree's depth (which could overflow the C++ call stack). `fun` is applied to
+  // each node's data exactly once; as a pure data map its application order is
+  // immaterial.
+  struct Frame {
+    explicit Frame(FullBinaryNode<T> const* s) : src{s} {}
+    FullBinaryNode<T> const* src;
+    int stage = 0;
+    rptr left, right;
+  };
+  std::deque<Frame> stk;
+  stk.push_back(Frame{&node});
+  rptr ret;
+  while (!stk.empty()) {
+    Frame& f = stk.back();
+    if (f.src->leaf()) {
+      ret = std::make_unique<RNode>(fun(**f.src));
+      stk.pop_back();
+      continue;
+    }
+    switch (f.stage) {
+      case 0:
+        f.stage = 1;
+        stk.push_back(Frame{&f.src->left()});
+        break;
+      case 1:
+        f.left = std::move(ret);
+        f.stage = 2;
+        stk.push_back(Frame{&f.src->right()});
+        break;
+      default:
+        f.right = std::move(ret);
+        ret = std::make_unique<RNode>(fun(**f.src), std::move(f.left),
+                                      std::move(f.right));
+        stk.pop_back();
+        break;
+    }
   }
+  return RNode{std::move(*ret)};
 }
 
 ///
diff --git a/tests/unit/test_binary_node.cpp b/tests/unit/test_binary_node.cpp
index ad6532f243..7a093238d1 100644
--- a/tests/unit/test_binary_node.cpp
+++ b/tests/unit/test_binary_node.cpp
@@ -8,6 +8,7 @@
 #include <cstddef>
 #include <string>
 #include <utility>
+#include <vector>
 
 #include <range/v3/view/all.hpp>
 #include <range/v3/view/iota.hpp>
@@ -346,3 +347,47 @@ TEST_CASE("binary_node", "[FullBinaryNode]") {
     }
   }
 }
+
+// Deep-tree operations must not recurse to the tree's depth: deep_copy,
+// transform_node, and the destructor are all iterative, so a chain thousands of
+// nodes deep -- which overflowed the pre-refactor recursive versions at depth
+// ~thousands (default ~8 MB stack) -- is handled by the heap instead. Built
+// iteratively (O(N) moves) with int data so the test stays cheap. visit() is
+// used to read the tree because it is an iterative (parent-pointer) walk;
+// size()/operator== are still recursive and would themselves overflow here.
+TEST_CASE("FullBinaryNode deep-tree ops are stack-safe",
+          "[FullBinaryNode][stack-safety]") {
+  using sequant::FullBinaryNode;
+  using sequant::transform_node;
+
+  constexpr int N = 200000;
+  FullBinaryNode<int> node{0};
+  for (int k = 1; k < N; ++k)
+    node = FullBinaryNode<int>{k, std::move(node), FullBinaryNode<int>{-k}};
+  // depth-N left-deep chain: root value N-1, leftmost leaf value 0; each
+  // internal node k has a right leaf -k. Node count = (N-1) internal + N
+  // leaves.
+
+  auto values = [](auto const& root) {
+    std::vector<std::decay_t<decltype(*root)>> v;
+    root.visit([&v](auto const& n) { v.push_back(*n); });
+    return v;
+  };
+
+  auto const orig = values(node);
+  REQUIRE(orig.size() == static_cast<std::size_t>(2 * N - 1));
+
+  // Copy ctor -> iterative deep_copy (would have overflowed).
+  FullBinaryNode<int> const copy = node;
+  CHECK(values(copy) == orig);
+
+  // transform_node -> iterative (would have overflowed).
+  auto const doubled =
+      transform_node(node, [](int v) { return static_cast<long>(2 * v); });
+  std::vector<long> expected;
+  expected.reserve(orig.size());
+  for (int v : orig) expected.push_back(2L * v);
+  CHECK(values(doubled) == expected);
+
+  // node, copy, doubled are destroyed here via the iterative destructor.
+}

From 4296286f66a94f59c0d492de0b5addaae000527d Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Tue, 7 Jul 2026 20:34:59 -0400
Subject: [PATCH 55/78] eval dryrun: pin external-occ sizing ratio on the PPL W
 giant

---
 tests/unit/test_eval_dryrun.cpp | 202 ++++++++++++++++++++++++++++++++
 1 file changed, 202 insertions(+)

diff --git a/tests/unit/test_eval_dryrun.cpp b/tests/unit/test_eval_dryrun.cpp
index e6ef6656e8..1df79972f3 100644
--- a/tests/unit/test_eval_dryrun.cpp
+++ b/tests/unit/test_eval_dryrun.cpp
@@ -1503,6 +1503,208 @@ TEST_CASE(
   CHECK(perf_first.cp.peak_bytes > 5e11);
 }
 
+// P1 gate spike (external-occ forest batching, mechanism b): PURE SIZING check.
+// Does the cost model's footprint of the perf-first PPL W giant respond to
+// slicing ONE external occupied index to a block? The external occ (the
+// residual's own output i,j) appears ONLY as protoindices of the output PNO
+// composites a<i,j>, never as a top-level slot and never contracted -- so the
+// question is whether inner_aware_volume, which pulls those protos into the
+// OUTER extent product (tot_indices; sized by idx_to_extent) while sizing the
+// PNO composites themselves by the k-th CSV power mean (independent of the occ
+// block), still shrinks the node when idx_to_extent is overridden to return
+// occ_block for one occ proto. If the occ lives in the outer product, the whole
+// footprint scales by occ_block/occ (GO). If the composite moment sizing
+// swallowed the occ (it does not, but this is the NO-GO hypothesis the spike
+// tests), the footprint would not move.
+//
+// This does NOT touch runtime, optimize() selection, or emit wiring. It sizes
+// ONE node's free-index set twice, with two extent functions. Hidden tag; run:
+//   ./tests/unit/unit_tests-sequant "[dryrun-occ-sizing]"
+TEST_CASE(
+    "dryrun external-occ slicing shrinks the PPL W footprint (P1 sizing gate)",
+    "[.][dryrun-occ-sizing]") {
+  auto ctx = get_default_context().clone();
+  ctx.set_first_dummy_index_ordinal(1000000);
+  auto isr = ctx.mutable_index_space_registry();
+  REQUIRE(isr != nullptr);
+  sequant::mbpt::add_pao_spaces(isr);  // mu~
+  sequant::mbpt::add_df_spaces(isr);   // K
+  auto ctx_resetter = set_scoped_default_context(std::move(ctx));
+
+  auto const body = slurp(std::string(SEQUANT_UNIT_TESTS_SOURCE_DIR) +
+                          "/data/csv_ccsd_doubles_residual_df.txt");
+  REQUIRE(!body.empty());
+  std::string line = body;
+  if (auto nl = line.find('\n'); nl != std::string::npos)
+    line = line.substr(0, nl);
+  auto expr = deserialize<ExprPtr>(line);
+  REQUIRE(static_cast<bool>(expr));
+  REQUIRE(expr->is<Sum>());
+  auto const& summands = expr->as<Sum>().summands();
+  REQUIRE(!summands.empty());
+  auto flatten_product = [](ExprPtr const& e) -> ExprPtr {
+    if (!e->is<Product>()) return e;
+    auto const& p = e->as<Product>();
+    return ex<Product>(p.scalar(), p.factors(), Product::Flatten::Yes);
+  };
+  // Same term as [dryrun-objective]: index 38 is the C60 PPL/ladder giant.
+  std::size_t giant_idx = 38;
+  if (giant_idx >= summands.size()) giant_idx = 0;
+  ExprPtr giant = flatten_product(summands[giant_idx]);
+  REQUIRE(giant);
+
+  // FAITHFUL real C60 config -- SAME regime the [dryrun-objective] case uses.
+  auto regime = df_regime(kC60_pVDZF12);
+
+  // Optimize + binarize the giant under the perf-first objective
+  // (DenseTimeSpaceBatched) with the SAME policy the [dryrun-objective] analyze
+  // uses, so we walk the exact tree that forms the occ^2 * PNO^4 W node.
+  sequant::BatchPolicy policy;
+  policy.is_batchable_index = is_df_batchable;
+  policy.batch_target_size = [](Index const& ix) -> std::size_t {
+    return ix.space().base_key() == L"μ̃" ? std::size_t{256} : std::size_t{72};
+  };
+  policy.is_volatile_leaf = [](Tensor const& t) { return t.label() == L"t"; };
+  policy.accumulation_factor = 1.0;
+  policy.peak_threshold = 40.0 * 1e9;
+
+  auto axes_map = std::make_shared<std::unordered_map<
+      Expr const*, container::vector<container::svector<Index>>>>();
+  OptimizeOptions opts;
+  opts.objective_function = ObjectiveFunction::DenseTimeSpaceBatched;
+  opts.idx_to_extent = regime.idx_to_extent();
+  opts.inner_pow = regime.inner_pow_fn();
+  opts.batch_policy = policy;
+  opts.volatile_weight = 20.0;
+  opts.roofline.machine_balance = 200.0;
+  opts.roofline.fast_mem_elems = 1000000.0;
+  opts.term_batch_axes = axes_map;
+
+  auto optimized = optimize(giant, opts);
+  REQUIRE(static_cast<bool>(optimized));
+  auto it = axes_map->find(optimized.get());
+  container::vector<container::svector<Index>> node_axes;
+  if (it != axes_map->end()) node_axes = it->second;
+  BinarizationOptions bopts;
+  bopts.node_batch_axes = node_axes;
+  SEQUANT_PRAGMA_IGNORE_DEPRECATED_BEGIN
+  auto node = binarize<EvalExprDryRun>(optimized, {}, bopts);
+  SEQUANT_PRAGMA_IGNORE_DEPRECATED_END
+
+  // Locate the GIANT PPL W node = the perf-first (gC)^2 ladder intermediate
+  // W(a1a2a3a4) whose FOUR PNO composite legs a<i,j> share one occ-pair, sized
+  // occ^2 * M_4^4 = ~0.92 TB (matches cost_profile's ~954 GB peak). The
+  // defining, batching-relevant property is that it carries NO free mu~ and NO
+  // free K -- those are contracted at/below it -- so mu~/K batching cannot
+  // shrink it and the external occ is its ONLY memory lever. (This is why a
+  // plain max-footprint pick is WRONG: the larger 3-center {mu~ a K} nodes ARE
+  // mu~/K-sliceable and are not the term that OOMs after batching.) Among the
+  // no-free-mu~/K nodes, take the max-footprint one; require >= 2 PNO legs so
+  // we land on the ladder intermediate, not a tiny scalar.
+  auto memsize_full = sequant::opt::detail::memsize_counter(
+      regime.idx_to_extent(), regime.inner_pow_fn());
+  auto free_has_bare = [](std::vector<Index> const& ixs, std::wstring_view bk) {
+    for (auto const& ix : ixs)
+      if (ix.space().base_key() == bk) return true;
+    return false;
+  };
+  auto count_pno = [](std::vector<Index> const& ixs) {
+    std::size_t n = 0;
+    for (auto const& ix : ixs)
+      if (ix.proto_indices().size() >= 2) ++n;
+    return n;
+  };
+  double giant_full_bytes = 0.0;
+  std::vector<Index> giant_free;
+  node.visit_internal([&](auto const& n) {
+    auto free_ixs = node_free_indices(*n);
+    if (free_has_bare(free_ixs, L"μ̃") || free_has_bare(free_ixs, L"Κ")) return;
+    if (count_pno(free_ixs) < 2) return;
+    double const bytes =
+        memsize_full(free_ixs, std::vector<Index>{}, std::vector<Index>{}) *
+        8.0;
+    if (bytes > giant_full_bytes) {
+      giant_full_bytes = bytes;
+      giant_free = free_ixs;
+    }
+  });
+  REQUIRE(giant_full_bytes > 0.0);
+
+  // The external occ indices on the giant node = the distinct proto indices of
+  // its composite legs whose base space is the active occupied ("i"). These are
+  // the residual's own output occ (i,j): never a top-level slot, never
+  // contracted, present only as PNO protos -- exactly the spectator axis the
+  // forest batching targets.
+  std::vector<Index> ext_occ;
+  for (auto const& ix : giant_free)
+    for (auto const& p : ix.proto_indices())
+      if (p.space().base_key() == L"i") {
+        bool seen = false;
+        for (auto const& e : ext_occ)
+          if (e.full_label() == p.full_label()) seen = true;
+        if (!seen) ext_occ.push_back(p);
+      }
+
+  std::wcerr << L"\n=== [dryrun-occ-sizing] P1 SIZING GATE (C60 giant, term "
+             << giant_idx << L") ===\n"
+             << L"giant node free indices = {" << describe_indices(giant_free)
+             << L"}\n"
+             << L"external occ protos found (" << ext_occ.size() << L") = {"
+             << describe_indices(ext_occ) << L"}\n";
+  REQUIRE(!ext_occ.empty());
+
+  // Slice exactly ONE external occ index to a block (rank-general design:
+  // batch an occupied INDEX, never a pair). occ_block = 10 (a plausible occ
+  // tile size; full occ extent = kC60_pVDZF12.i_occ = 120).
+  std::size_t const occ_block = 10;
+  Index const sliced = ext_occ.front();
+  std::wstring const sliced_label(sliced.full_label());
+  std::wcerr << L"slicing ONE external occ index {" << sliced_label
+             << L"} to occ_block=" << occ_block << L" (full occ extent="
+             << kC60_pVDZF12.i_occ << L")\n";
+
+  // Sliced extent function: identical to the regime's, except the ONE chosen
+  // external occ index returns min(full, occ_block).
+  auto full_ext = regime.idx_to_extent();
+  auto sliced_ext = [full_ext, sliced_label,
+                     occ_block](Index const& ix) -> std::size_t {
+    if (std::wstring(ix.full_label()) == sliced_label)
+      return std::min<std::size_t>(full_ext(ix), occ_block);
+    return full_ext(ix);
+  };
+  auto memsize_sliced =
+      sequant::opt::detail::memsize_counter(sliced_ext, regime.inner_pow_fn());
+
+  double const sliced_bytes =
+      memsize_sliced(giant_free, std::vector<Index>{}, std::vector<Index>{}) *
+      8.0;
+  double const ratio = sliced_bytes / giant_full_bytes;
+
+  std::wcerr << L"full   footprint = " << giant_full_bytes << L" bytes ("
+             << (giant_full_bytes / 1e9) << L" GB)\n"
+             << L"sliced footprint = " << sliced_bytes << L" bytes ("
+             << (sliced_bytes / 1e9) << L" GB)\n"
+             << L"sliced/full ratio = " << ratio
+             << L"  (expected ~ occ_block/occ = "
+             << (double(occ_block) / double(kC60_pVDZF12.i_occ)) << L")\n"
+             << L"VERDICT: external-occ slicing "
+             << (ratio < 0.6 ? L"SHRINKS the PPL W footprint => GO"
+                             : L"does NOT shrink the footprint => NO-GO")
+             << L"\n";
+
+  // GO criterion: the modelled footprint must scale EXACTLY with the sliced
+  // occ extent, not just "shrink". The outer (idx_to_extent) factor scales
+  // linearly in the sliced occ extent; the inner PNO M4^4 factor is untouched.
+  // So the footprint ratio is exactly occ_block/occ. Pin that, not just
+  // "smaller". If this fails, the finding is that the mechanism is not purely
+  // multiplicative as expected (NO-GO); report the measured ratio vs
+  // occ_block/occ.
+  double const expected_ratio =
+      static_cast<double>(occ_block) / static_cast<double>(kC60_pVDZF12.i_occ);
+  CHECK(sliced_bytes ==
+        Catch::Approx(giant_full_bytes * expected_ratio).epsilon(1e-9));
+}
+
 // Task 1 (P0, dry-run cost-model comparison): perf-first
 // (DenseTimeSpaceBatched) vs peak-first (DenseSpaceTimeBatched) modelled
 // flops/peak, swept over ALL summands of the real C60 residual (not just the

From 954a3425cd7ca8250706da2f839fa9cf84f33f9f Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Tue, 7 Jul 2026 20:49:40 -0400
Subject: [PATCH 56/78] optimize: recognize external occupied protoindices as
 batchable axes

---
 SeQuant/core/optimize/single_term_detail.hpp |  62 ++++++-
 tests/unit/test_eval_dryrun.cpp              | 165 +++++++++++++++++++
 2 files changed, 223 insertions(+), 4 deletions(-)

diff --git a/SeQuant/core/optimize/single_term_detail.hpp b/SeQuant/core/optimize/single_term_detail.hpp
index 3fe0335d60..aace132c36 100644
--- a/SeQuant/core/optimize/single_term_detail.hpp
+++ b/SeQuant/core/optimize/single_term_detail.hpp
@@ -10,6 +10,7 @@
 
 #include <SeQuant/core/algorithm.hpp>
 #include <SeQuant/core/container.hpp>
+#include <SeQuant/core/context.hpp>
 #include <SeQuant/core/expr.hpp>
 #include <SeQuant/core/optimize/options.hpp>
 #include <SeQuant/core/tensor_canonicalizer.hpp>
@@ -246,6 +247,15 @@ container::vector<double> subset_footprints(
 /// it.  The returned list assigns each index a stable bit position: index at
 /// position \c k is bit \c k of a sliced-set bitmask \c B.
 ///
+/// In addition to the top-level slots, a second pass admits the pure-occupied
+/// protoindices of composite (CSV/PNO/OSV tensor-of-tensor) legs. A composite
+/// leg carries its external occupied indices ONLY as protoindices -- they never
+/// appear as a top-level bra/ket/aux slot -- so the slot scan alone drops them.
+/// Admitting them lets the batched DP slice that external-occ spectator axis
+/// (mirrored in \ref subset_open_aux). The proto pass is guarded by index space
+/// (only pure-occupied protos are admitted) and short-circuits on non-composite
+/// indices, so PAO/aux/internal-occ recognition is unchanged.
+///
 /// \param network  The TensorNetwork to scan.
 /// \param is_batchable  Predicate returning true for indices in a batchable
 ///        space (e.g. a DF/RI auxiliary space).
@@ -255,11 +265,31 @@ inline container::vector<Index> batchable_index_list(
     std::function<bool(Index const&)> const& is_batchable) {
   container::vector<Index> aux;
   if (!is_batchable) return aux;
+  // Registry used to recognize the pure-occupied protoindices of composite
+  // legs. Guarded by has_vacocc: occupancy is defined relative to the
+  // vacuum-occupied space, so a registry without one (or no registry) admits no
+  // protos and leaves behavior byte-identical. is_pure_occupied is NOT used
+  // directly: its space reconstruction throws for proto quantum numbers absent
+  // from the registry; instead we replicate its core type-bitset test (a space
+  // is pure-occupied iff its type is at or below the vacuum-occupied type),
+  // which needs no space retrieval.
+  auto const isr = get_default_context().index_space_registry();
+  auto const vacocc = isr ? isr->vacuum_occupied_space(/*nulltype_ok=*/true)
+                          : IndexSpace::Type::null;
+  bool const has_vacocc = vacocc != IndexSpace::Type::null;
+  auto is_occ_proto = [&](Index const& p) {
+    return has_vacocc && p.space() &&
+           p.space().type().to_int32() <= vacocc.to_int32();
+  };
   for (auto&& t : network.tensors()) {
     auto tp = std::dynamic_pointer_cast<Tensor>(t);
-    for (auto&& ix : ranges::views::concat(tp->bra(), tp->ket(), tp->aux()))
+    for (auto&& ix : ranges::views::concat(tp->bra(), tp->ket(), tp->aux())) {
       if (is_batchable(ix) && ranges::find(aux, ix) == ranges::end(aux))
         aux.push_back(ix);
+      for (auto&& p : ix.proto_indices())
+        if (is_occ_proto(p) && ranges::find(aux, p) == ranges::end(aux))
+          aux.push_back(p);
+    }
   }
   return aux;
 }
@@ -453,12 +483,36 @@ container::vector<std::size_t> subset_open_aux(
   container::vector<OptRes> results(
       (std::size_t{1} << network.tensors().size()));
   init_results(network, tidxs, results);
+  // Occupied spectator axes admitted by batchable_index_list live only as
+  // protoindices of composite legs, never as a top-level open index, so the
+  // direct-membership test below never sees them. Recognize them the same way:
+  // such an axis is open in subset n iff some open index of n carries it as a
+  // protoindex. Non-occupied axes never enter this branch, so their (direct)
+  // recognition stays byte-identical.
+  auto const isr = get_default_context().index_space_registry();
+  auto const vacocc = isr ? isr->vacuum_occupied_space(/*nulltype_ok=*/true)
+                          : IndexSpace::Type::null;
+  bool const has_vacocc = vacocc != IndexSpace::Type::null;
+  auto is_occ_proto = [&](Index const& ax) {
+    return has_vacocc && ax.space() &&
+           ax.space().type().to_int32() <= vacocc.to_int32();
+  };
   container::vector<std::size_t> open_aux(results.size(), 0);
   for (std::size_t n = 0; n < results.size(); ++n) {
     for (std::size_t k = 0; k < aux_list.size(); ++k) {
-      if (ranges::find(results[n].indices, aux_list[k]) !=
-          ranges::end(results[n].indices))
-        open_aux[n] |= (std::size_t{1} << k);
+      Index const& ax = aux_list[k];
+      bool open = ranges::find(results[n].indices, ax) !=
+                  ranges::end(results[n].indices);
+      if (!open && is_occ_proto(ax)) {
+        for (auto const& ix : results[n].indices) {
+          auto const& pr = ix.proto_indices();
+          if (ranges::find(pr, ax) != ranges::end(pr)) {
+            open = true;
+            break;
+          }
+        }
+      }
+      if (open) open_aux[n] |= (std::size_t{1} << k);
     }
   }
   return open_aux;
diff --git a/tests/unit/test_eval_dryrun.cpp b/tests/unit/test_eval_dryrun.cpp
index 1df79972f3..6111c001d3 100644
--- a/tests/unit/test_eval_dryrun.cpp
+++ b/tests/unit/test_eval_dryrun.cpp
@@ -1705,6 +1705,171 @@ TEST_CASE(
         Catch::Approx(giant_full_bytes * expected_ratio).epsilon(1e-9));
 }
 
+// P1 recognition gate: prove the batched DP's batchable-axis scan
+// (batchable_index_list) now admits the external occupied protoindices carried
+// on the C60 giant's composite (PNO) legs. Before the proto-aware change,
+// batchable_index_list scanned only the top-level bra/ket/aux slots, so the
+// residual's external occ pair -- which lives ONLY as protoindices of the
+// composite legs and never as a top-level slot -- was dropped from
+// canon_indices_ and could never enter the batchable set. The forest-batching
+// feature needs it there. This is the recognition twin of the
+// [dryrun-occ-sizing] sizing gate: same C60 term, same optimize+binarize, same
+// giant-node locator and ext_occ extraction; it asserts on the batchable list,
+// not the footprint. Hidden tag; run:
+//   ./tests/unit/unit_tests-sequant "[dryrun-occ-recognize]"
+TEST_CASE(
+    "dryrun external occ is recognized as a batchable axis (P1 recognition "
+    "gate)",
+    "[.][dryrun-occ-recognize]") {
+  auto ctx = get_default_context().clone();
+  ctx.set_first_dummy_index_ordinal(1000000);
+  auto isr = ctx.mutable_index_space_registry();
+  REQUIRE(isr != nullptr);
+  sequant::mbpt::add_pao_spaces(isr);  // mu~
+  sequant::mbpt::add_df_spaces(isr);   // K
+  auto ctx_resetter = set_scoped_default_context(std::move(ctx));
+
+  auto const body = slurp(std::string(SEQUANT_UNIT_TESTS_SOURCE_DIR) +
+                          "/data/csv_ccsd_doubles_residual_df.txt");
+  REQUIRE(!body.empty());
+  std::string line = body;
+  if (auto nl = line.find('\n'); nl != std::string::npos)
+    line = line.substr(0, nl);
+  auto expr = deserialize<ExprPtr>(line);
+  REQUIRE(static_cast<bool>(expr));
+  REQUIRE(expr->is<Sum>());
+  auto const& summands = expr->as<Sum>().summands();
+  REQUIRE(!summands.empty());
+  auto flatten_product = [](ExprPtr const& e) -> ExprPtr {
+    if (!e->is<Product>()) return e;
+    auto const& p = e->as<Product>();
+    return ex<Product>(p.scalar(), p.factors(), Product::Flatten::Yes);
+  };
+  // Same term as [dryrun-occ-sizing]: index 38 is the C60 PPL/ladder giant.
+  std::size_t giant_idx = 38;
+  if (giant_idx >= summands.size()) giant_idx = 0;
+  ExprPtr giant = flatten_product(summands[giant_idx]);
+  REQUIRE(giant);
+
+  // FAITHFUL real C60 config -- SAME regime/policy as [dryrun-occ-sizing].
+  auto regime = df_regime(kC60_pVDZF12);
+
+  sequant::BatchPolicy policy;
+  policy.is_batchable_index = is_df_batchable;
+  policy.batch_target_size = [](Index const& ix) -> std::size_t {
+    return ix.space().base_key() == L"μ̃" ? std::size_t{256} : std::size_t{72};
+  };
+  policy.is_volatile_leaf = [](Tensor const& t) { return t.label() == L"t"; };
+  policy.accumulation_factor = 1.0;
+  policy.peak_threshold = 40.0 * 1e9;
+
+  auto axes_map = std::make_shared<std::unordered_map<
+      Expr const*, container::vector<container::svector<Index>>>>();
+  OptimizeOptions opts;
+  opts.objective_function = ObjectiveFunction::DenseTimeSpaceBatched;
+  opts.idx_to_extent = regime.idx_to_extent();
+  opts.inner_pow = regime.inner_pow_fn();
+  opts.batch_policy = policy;
+  opts.volatile_weight = 20.0;
+  opts.roofline.machine_balance = 200.0;
+  opts.roofline.fast_mem_elems = 1000000.0;
+  opts.term_batch_axes = axes_map;
+
+  auto optimized = optimize(giant, opts);
+  REQUIRE(static_cast<bool>(optimized));
+  auto it = axes_map->find(optimized.get());
+  container::vector<container::svector<Index>> node_axes;
+  if (it != axes_map->end()) node_axes = it->second;
+  BinarizationOptions bopts;
+  bopts.node_batch_axes = node_axes;
+  SEQUANT_PRAGMA_IGNORE_DEPRECATED_BEGIN
+  auto node = binarize<EvalExprDryRun>(optimized, {}, bopts);
+  SEQUANT_PRAGMA_IGNORE_DEPRECATED_END
+
+  // Locate the giant PPL W node (identical locator to [dryrun-occ-sizing]) and
+  // grab its intermediate tensor: the perf-first (gC)^2 ladder W whose four PNO
+  // composite legs share one occ pair, carries NO free mu~ and NO free K, and
+  // has >= 2 PNO legs. That tensor's composite legs carry the external occ pair
+  // as protoindices -- the spectator axis the forest batching targets.
+  auto memsize_full = sequant::opt::detail::memsize_counter(
+      regime.idx_to_extent(), regime.inner_pow_fn());
+  auto free_has_bare = [](std::vector<Index> const& ixs, std::wstring_view bk) {
+    for (auto const& ix : ixs)
+      if (ix.space().base_key() == bk) return true;
+    return false;
+  };
+  auto count_pno = [](std::vector<Index> const& ixs) {
+    std::size_t n = 0;
+    for (auto const& ix : ixs)
+      if (ix.proto_indices().size() >= 2) ++n;
+    return n;
+  };
+  double giant_full_bytes = 0.0;
+  ExprPtr giant_tensor;
+  node.visit_internal([&](auto const& n) {
+    if (!n->is_tensor()) return;
+    auto free_ixs = node_free_indices(*n);
+    if (free_has_bare(free_ixs, L"μ̃") || free_has_bare(free_ixs, L"Κ")) return;
+    if (count_pno(free_ixs) < 2) return;
+    double const bytes =
+        memsize_full(free_ixs, std::vector<Index>{}, std::vector<Index>{}) *
+        8.0;
+    if (bytes > giant_full_bytes) {
+      giant_full_bytes = bytes;
+      giant_tensor = n->as_tensor().clone();
+    }
+  });
+  REQUIRE(giant_full_bytes > 0.0);
+  REQUIRE(static_cast<bool>(giant_tensor));
+
+  // The external occ protos the recognition must surface (same extraction as
+  // [dryrun-occ-sizing]): distinct occupied ("i") protos of the giant's
+  // composite legs.
+  std::vector<Index> ext_occ;
+  for (auto const& ix : giant_tensor->as<Tensor>().const_braketaux_indices())
+    for (auto const& p : ix.proto_indices())
+      if (p.space().base_key() == L"i") {
+        bool seen = false;
+        for (auto const& e : ext_occ)
+          if (e.full_label() == p.full_label()) seen = true;
+        if (!seen) ext_occ.push_back(p);
+      }
+  REQUIRE(!ext_occ.empty());
+
+  // Build a one-tensor network from the giant W node and scan it exactly as the
+  // batched DP does (cost_model's build_context calls this same function with
+  // the same is_batchable predicate). is_df_batchable admits ONLY mu~/K; before
+  // the proto-aware change the returned list carries NO occupied index, so this
+  // gate FAILS. After it, the external occ pair must appear.
+  auto tn = TensorNetwork{container::vector<ExprPtr>{giant_tensor}};
+  auto batchable =
+      sequant::opt::detail::batchable_index_list(tn, is_df_batchable);
+
+  std::vector<Index> batchable_v(batchable.begin(), batchable.end());
+  std::wcerr << L"\n=== [dryrun-occ-recognize] P1 RECOGNITION GATE (C60 giant, "
+             << L"term " << giant_idx << L") ===\n"
+             << L"external occ protos on giant (" << ext_occ.size() << L") = {"
+             << describe_indices(ext_occ) << L"}\n"
+             << L"batchable_index_list (" << batchable_v.size() << L") = {"
+             << describe_indices(batchable_v) << L"}\n";
+
+  auto is_active_occ = [](Index const& ix) {
+    return ix.space().base_key() == L"i";
+  };
+  // The giant's external occ must now be a batchable axis, even though it has
+  // no top-level slot on the node.
+  CHECK(std::any_of(batchable.begin(), batchable.end(), is_active_occ));
+
+  // ...and the surfaced occ axis is exactly one of the giant's external occ
+  // protos, not some unrelated occupied index.
+  bool matches_ext = false;
+  for (auto const& b : batchable)
+    if (is_active_occ(b))
+      for (auto const& e : ext_occ)
+        if (b.full_label() == e.full_label()) matches_ext = true;
+  CHECK(matches_ext);
+}
+
 // Task 1 (P0, dry-run cost-model comparison): perf-first
 // (DenseTimeSpaceBatched) vs peak-first (DenseSpaceTimeBatched) modelled
 // flops/peak, swept over ALL summands of the real C60 residual (not just the

From a6a80ed7e2a387866f19b5515ff84ffde398a218 Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Tue, 7 Jul 2026 22:12:52 -0400
Subject: [PATCH 57/78] optimize: seed spectator external-occ into DP root
 frontier; size+report giant under occ-slice

---
 SeQuant/core/optimize/cost_model.hpp | 135 ++++++++++++++++++++++++++-
 tests/unit/test_eval_dryrun.cpp      | 119 ++++++++++++++++++++++-
 2 files changed, 249 insertions(+), 5 deletions(-)

diff --git a/SeQuant/core/optimize/cost_model.hpp b/SeQuant/core/optimize/cost_model.hpp
index 768e255819..a83ae62788 100644
--- a/SeQuant/core/optimize/cost_model.hpp
+++ b/SeQuant/core/optimize/cost_model.hpp
@@ -13,6 +13,7 @@
 #include <functional>
 #include <iostream>
 #include <limits>
+#include <optional>
 #include <utility>
 
 namespace sequant::opt::detail {
@@ -762,16 +763,51 @@ struct PeakBatchedModel {
   void finalize(Context& /*ctx*/, size_t /*n*/,
                 container::vector<State>& /*st*/) const {}
 
+  /// \brief True iff batchable axis bit \p k is a genuine external spectator of
+  /// this network: it is OPEN on the root result AND is contracted at NO node.
+  ///
+  /// A spectator is carried unchanged from the leaves up to the root: whenever
+  /// any tensor in a subset carries the axis, the axis stays OPEN in that
+  /// subset, so it never appears in any node's contracted-at-node set
+  /// (\c Acand = (open_aux[lp]|open_aux[rp]) & ~open_aux[n]) and slicing it is
+  /// purely a footprint change with identical work. The forest-batching seed
+  /// path asserts this before honoring a seed axis: seeding an axis that is
+  /// actually contracted somewhere would mis-size the nodes that contract it.
+  bool is_spectator_axis(Context const& ctx, std::size_t k) const {
+    std::size_t const root = (std::size_t{1} << ctx.nt) - 1;
+    // Must be carried on the root result (a genuine external index).
+    if (!((ctx.open_aux[root] >> k) & 1u)) return false;
+    // Leaves (single-tensor subsets) that carry axis k.
+    std::size_t leafmask = 0;
+    for (std::size_t b = 0; b < ctx.nt; ++b)
+      if ((ctx.open_aux[std::size_t{1} << b] >> k) & 1u)
+        leafmask |= (std::size_t{1} << b);
+    // Whenever the axis is AVAILABLE in a subset (some carrying leaf is in it)
+    // it must be OPEN in that subset -- else it is contracted at the node that
+    // forms that subset, i.e. not a pure spectator.
+    for (std::size_t n = 1; n <= root; ++n)
+      if ((leafmask & n) && !((ctx.open_aux[n] >> k) & 1u)) return false;
+    return true;
+  }
+
   /// Threshold-gated root-frontier selection shared by \ref reconstruct and
   /// \ref reconstruct_axes: among points whose peak (bytes) fits
   /// peak_threshold, pick fewest flops (ties by lower peak). If none fit, pick
   /// min peak (best effort). peak_threshold == +inf => all feasible => min
   /// flops => the non-batched schedule. Returns the chosen index into
-  /// \c st[root][0].
-  int select_root(Context const& ctx,
-                  container::vector<State> const& st) const {
+  /// \c st[root][root_B].
+  ///
+  /// \param root_B The batch context read at the ROOT. The default 0 (the
+  ///        empty sliced-set) is the historical behavior, kept byte-identical.
+  ///        The forest-batching seed path passes a non-zero mask to SEED a
+  ///        spectator external axis into the root frontier, so the whole tree
+  ///        is sized (and its peak reported) with that axis sliced --
+  ///        \c st[root][root_B] is already computed by the DP's B-loop; only
+  ///        which B the root selection reads changes.
+  int select_root(Context const& ctx, container::vector<State> const& st,
+                  std::size_t root_B = 0) const {
     std::size_t const root = (std::size_t{1} << ctx.nt) - 1;
-    auto const& rootf = st[root][0];
+    auto const& rootf = st[root][root_B];
     auto peak_bytes = [this](double peak_elems) {
       return peak_elems * numeric_size;
     };
@@ -936,6 +972,97 @@ double peak_cost_batched(
   return mn;
 }
 
+/// \brief Result of seeding a spectator external axis into the batched DP's
+/// ROOT frontier (forest batching, P1). The seed axis is contracted at NO node
+/// (a pure spectator carried on the root and every subtree holding a composite
+/// leg that bears it), so slicing it does NOT change total work (flops) but
+/// shrinks every intermediate that carries it -- in particular the perf-first
+/// PPL W giant -- by ~occ_block/occ. Carries both the unseeded (B=0) and seeded
+/// (B={k_seed}) root selections so a caller can report the drop, plus the
+/// chosen axis + block size for Task 4 to thread through the public optimize
+/// API.
+struct SeededBatchedResult {
+  double unseeded_peak_bytes = 0;
+  double seeded_peak_bytes = 0;
+  double unseeded_flops = 0;
+  double seeded_flops = 0;
+  std::optional<Index> seeded_axis;
+  std::size_t occ_block = 0;
+  bool spectator_ok = false;
+};
+
+/// \brief Runs the batched peak DP once and reports the ROOT-frontier selection
+/// at B=0 (unseeded) and at B={k_seed} (the seed axis sliced into the root
+/// batch context), under the model's own (perf-first or peak-first) selector.
+///
+/// The spectator external axis (e.g. the residual's own external occupied
+/// index, carried only as a composite protoindex) is admitted to \c ctx.aux by
+/// \ref batchable_index_list's proto pass regardless of the base
+/// \c is_batchable predicate; but \ref sliced_footprints only shrinks an axis
+/// for which \c is_batchable is true. This routine therefore extends the
+/// predicate (and gives the seed axis a block-sized batch target \p occ_block)
+/// so the DP tables actually slice the seed axis when its bit is set. Every
+/// other axis is untouched, and B=0 never sets the seed bit (the spectator is
+/// contracted nowhere, so it never enters any node's \c Acand and hence never
+/// enters any child context at B=0), so the unseeded (B=0) selection is
+/// byte-identical to \p base_model's.
+///
+/// \p seed_axis MUST be a genuine external spectator (asserted via
+/// \ref PeakBatchedModel::is_spectator_axis): carried on the root and
+/// contracted at no node. Seeding a contracted axis would mis-size the nodes
+/// that contract it, so this asserts rather than silently mis-report.
+template <typename TIdxs, typename IdxToSz>
+SeededBatchedResult seeded_root_peak_batched(
+    PeakBatchedModel<IdxToSz> base_model, TensorNetwork const& network,
+    TIdxs const& tidxs, Index const& seed_axis, std::size_t occ_block) {
+  SeededBatchedResult out;
+  out.occ_block = occ_block;
+  std::wstring const seed_label(seed_axis.full_label());
+
+  auto base_batchable = base_model.is_batchable;
+  auto base_batch = base_model.batch;
+  base_model.is_batchable = [base_batchable, seed_label](Index const& ix) {
+    return (base_batchable && base_batchable(ix)) ||
+           std::wstring(ix.full_label()) == seed_label;
+  };
+  base_model.batch = [base_batch, seed_label, occ_block](Index const& ix) {
+    if (std::wstring(ix.full_label()) == seed_label) return occ_block;
+    return base_batch ? base_batch(ix) : std::size_t{0};
+  };
+
+  auto ctx = base_model.build_context(network, tidxs);
+  // Locate the seed axis's bit in ctx.aux.
+  std::size_t k_seed = ctx.m;  // sentinel == not found
+  for (std::size_t k = 0; k < ctx.m; ++k)
+    if (std::wstring(ctx.aux[k].full_label()) == seed_label) {
+      k_seed = k;
+      break;
+    }
+  SEQUANT_ASSERT(k_seed < ctx.m &&
+                 "seed axis not recognized as a batchable axis");
+  // SAFEGUARD: only honor a genuine external spectator.
+  out.spectator_ok = base_model.is_spectator_axis(ctx, k_seed);
+  SEQUANT_ASSERT(out.spectator_ok &&
+                 "seed axis is not a pure external spectator "
+                 "(open on the root AND contracted at no node)");
+  out.seeded_axis = ctx.aux[k_seed];
+
+  auto st = solve_single_term(base_model, network, tidxs, ctx);
+  std::size_t const root = (std::size_t{1} << ctx.nt) - 1;
+  std::size_t const seed = std::size_t{1} << k_seed;
+
+  int const best0 = base_model.select_root(ctx, st, 0);
+  int const bestS = base_model.select_root(ctx, st, seed);
+  SEQUANT_ASSERT(best0 >= 0 && bestS >= 0);
+  auto const& p0 = st[root][0][best0];
+  auto const& pS = st[root][seed][bestS];
+  out.unseeded_peak_bytes = p0.peak * base_model.numeric_size;
+  out.seeded_peak_bytes = pS.peak * base_model.numeric_size;
+  out.unseeded_flops = p0.flops;
+  out.seeded_flops = pS.flops;
+  return out;
+}
+
 /// \brief Independent memory-simulation recomputation of the chosen batched
 /// reconstruction's model-A peak. Builds \ref PeakBatchedModel, runs
 /// \ref solve_single_term for the back-pointer table, and recomputes the
diff --git a/tests/unit/test_eval_dryrun.cpp b/tests/unit/test_eval_dryrun.cpp
index 6111c001d3..f17de1df3a 100644
--- a/tests/unit/test_eval_dryrun.cpp
+++ b/tests/unit/test_eval_dryrun.cpp
@@ -1306,7 +1306,8 @@ TEST_CASE(
   // cost_profile() entry point (Task 4) to get the modeled peak/flops/exec via
   // the gated-cache replay -- replacing the ad-hoc manual replay + hwmark read
   // this case used before Task 5, so there is ONE peak/flops code path.
-  auto analyze = [&](ObjectiveFunction obj) -> Analysis {
+  auto analyze = [&](ObjectiveFunction obj, bool seed_external_occ = false,
+                     std::size_t occ_block = 0) -> Analysis {
     sequant::BatchPolicy policy;
     policy.is_batchable_index = is_df_batchable;
     policy.batch_target_size = [](Index const& ix) -> std::size_t {
@@ -1452,11 +1453,112 @@ TEST_CASE(
                << a.largest_realized_gb << L" GB\n               cost_profile: "
                << L"n_ops=" << a.cp.n_ops << L" flops=" << a.cp.flops
                << L" peak_bytes=" << (a.cp.peak_bytes / 1e9) << L" GB\n";
+
+    // ---- P1 forest-batching seed: size+report the giant under an occ-slice --
+    // Reuse the [dryrun-occ-sizing] giant-node locator + ext_occ extraction to
+    // find the ONE external spectator occ carried on the perf-first PPL W node,
+    // then run the batched DP with that occ SEEDED into the root frontier and
+    // OVERRIDE the reported peak with the seeded root point. flops (a static,
+    // batch-invariant walk of the SAME factorization) is left untouched:
+    // partitioning a spectator axis is work-neutral.
+    if (seed_external_occ) {
+      auto memsize_full = sequant::opt::detail::memsize_counter(
+          regime.idx_to_extent(), regime.inner_pow_fn());
+      auto free_has_bare = [](std::vector<Index> const& ixs,
+                              std::wstring_view bk) {
+        for (auto const& ix : ixs)
+          if (ix.space().base_key() == bk) return true;
+        return false;
+      };
+      auto count_pno = [](std::vector<Index> const& ixs) {
+        std::size_t nn = 0;
+        for (auto const& ix : ixs)
+          if (ix.proto_indices().size() >= 2) ++nn;
+        return nn;
+      };
+      double giant_full_bytes = 0.0;
+      std::vector<Index> giant_free;
+      node.visit_internal([&](auto const& nn) {
+        auto free_ixs = node_free_indices(*nn);
+        if (free_has_bare(free_ixs, L"μ̃") || free_has_bare(free_ixs, L"Κ"))
+          return;
+        if (count_pno(free_ixs) < 2) return;
+        double const bytes =
+            memsize_full(free_ixs, std::vector<Index>{}, std::vector<Index>{}) *
+            8.0;
+        if (bytes > giant_full_bytes) {
+          giant_full_bytes = bytes;
+          giant_free = free_ixs;
+        }
+      });
+      REQUIRE(giant_full_bytes > 0.0);
+      std::vector<Index> ext_occ;
+      for (auto const& ix : giant_free)
+        for (auto const& p : ix.proto_indices())
+          if (p.space().base_key() == L"i") {
+            bool seen = false;
+            for (auto const& e : ext_occ)
+              if (e.full_label() == p.full_label()) seen = true;
+            if (!seen) ext_occ.push_back(p);
+          }
+      REQUIRE(!ext_occ.empty());
+
+      // Build the giant's TensorNetwork (mirrors single_term_opt) and run the
+      // batched DP with the SAME perf-first params optimize() used, seeding the
+      // ONE external occ index into the ROOT batch context.
+      REQUIRE(giant->is<Product>());
+      container::svector<ExprPtr> gtensors;
+      for (auto const& f : giant->as<Product>().factors())
+        if (f->is<Tensor>()) gtensors.push_back(f);
+      TensorNetwork gtn{gtensors};
+
+      using BModel = sequant::opt::detail::PeakBatchedModel<
+          std::function<std::size_t(Index const&)>>;
+      BModel model{regime.idx_to_extent(),
+                   is_df_batchable,
+                   [](Index const& ix) -> std::size_t {
+                     return ix.space().base_key() == L"μ̃" ? std::size_t{256}
+                                                          : std::size_t{72};
+                   },
+                   [](Tensor const& t) { return t.label() == L"t"; },
+                   regime.inner_pow_fn(),
+                   /*volatile_weight=*/20.0,
+                   /*machine_balance=*/200.0,
+                   /*fast_mem_elems=*/1000000.0,
+                   /*block_tiles=*/3.0,
+                   /*block_prefactor=*/1.0,
+                   /*batch_persistent_only=*/false,
+                   /*peak_flops_tolerance=*/0.0,
+                   /*accumulation_factor=*/1.0,
+                   /*peak_threshold=*/40.0 * 1e9,
+                   /*numeric_size=*/8.0,
+                   /*perf_first=*/true};
+      container::svector<Index> const gtidxs{};
+      auto sr = sequant::opt::detail::seeded_root_peak_batched(
+          model, gtn, gtidxs, ext_occ.front(), occ_block);
+      std::wcerr << L"[dryrun-objective] SEED spectator occ {"
+                 << std::wstring(sr.seeded_axis ? sr.seeded_axis->full_label()
+                                                : std::wstring{L"?"})
+                 << L"} occ_block=" << sr.occ_block << L" spectator_ok="
+                 << (sr.spectator_ok ? 1 : 0) << L"\n   DP peak unseeded="
+                 << (sr.unseeded_peak_bytes / 1e9) << L" GB seeded="
+                 << (sr.seeded_peak_bytes / 1e9) << L" GB  flops unseeded="
+                 << sr.unseeded_flops << L" seeded=" << sr.seeded_flops
+                 << L"\n";
+      // The reported peak becomes the seeded root point; flops is work-neutral
+      // and stays the SAME cost_profile value the unseeded run has.
+      a.cp.peak_bytes = sr.seeded_peak_bytes;
+    }
     return a;
   };
 
   auto peak_first = analyze(ObjectiveFunction::DenseSpaceTimeBatched);
   auto perf_first = analyze(ObjectiveFunction::DenseTimeSpaceBatched);
+  // P1 go/no-go: the SAME perf-first factorization, with the spectator external
+  // occ seeded into the DP root frontier so its giant is sized under an
+  // occ-slice (occ_block=10, full occ extent 120).
+  auto perf_first_occ =
+      analyze(ObjectiveFunction::DenseTimeSpaceBatched, true, 10);
 
   auto report = [](wchar_t const* tag, Analysis const& a) {
     std::wcerr << tag << L": 4-PAO node formed = "
@@ -1501,6 +1603,21 @@ TEST_CASE(
   //     band brackets the real-moment value with margin and is non-flaky.
   CHECK(perf_first.cp.peak_bytes < 2e12);
   CHECK(perf_first.cp.peak_bytes > 5e11);
+
+  // (c) P1 GO/NO-GO (external-occ forest batching). Seeding the ONE external
+  //     spectator occ (the residual's own output index, carried only as a PNO
+  //     protoindex on the giant W) into the DP ROOT batch context sizes the
+  //     whole tree with that occ sliced to occ_block=10 (full occ extent 120).
+  //     Since the occ is contracted at NO node it is a pure spectator: slicing
+  //     it is work-neutral (identical flops) and shrinks the giant W by
+  //     ~occ_block/occ. The SELECTED (not merely isolatable) perf-first
+  //     schedule's reported peak must therefore drop below 0.2x the unseeded
+  //     0.5-2 TB PPL W, at equal flops. If select_root does NOT pick the
+  //     occ-sliced realization, this is a NO-GO (do not force it).
+  CHECK(perf_first.cp.peak_bytes > 5e11);
+  CHECK(perf_first_occ.cp.peak_bytes < 0.2 * perf_first.cp.peak_bytes);
+  CHECK(perf_first_occ.cp.flops ==
+        Catch::Approx(perf_first.cp.flops).epsilon(1e-9));
 }
 
 // P1 gate spike (external-occ forest batching, mechanism b): PURE SIZING check.

From aac7d3ebedf404494278741a64bfd3d1aad66567 Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Tue, 7 Jul 2026 22:20:25 -0400
Subject: [PATCH 58/78] eval dryrun: gate P1 go/no-go within one peak model;
 assert DP flops work-neutral

---
 tests/unit/test_eval_dryrun.cpp | 28 +++++++++++++++++++++-------
 1 file changed, 21 insertions(+), 7 deletions(-)

diff --git a/tests/unit/test_eval_dryrun.cpp b/tests/unit/test_eval_dryrun.cpp
index f17de1df3a..f35f59a792 100644
--- a/tests/unit/test_eval_dryrun.cpp
+++ b/tests/unit/test_eval_dryrun.cpp
@@ -1297,6 +1297,13 @@ TEST_CASE(
     // 4: gated-cache peak replay + static flops/exec walk), replacing the
     // ad-hoc manual replay + hwmark read this case used before Task 5.
     sequant::eval::dryrun::CostProfile cp;
+    // P1 seed-path result (populated only when seed_external_occ=true): the
+    // honest WITHIN-MODEL (DP-staged) unseeded/seeded peak_bytes and flops.
+    // Unlike `cp`, which mixes an unseeded cost_profile()-replay hwmark with
+    // (when seeded) an OVERRIDDEN peak_bytes, both sr.unseeded_* and
+    // sr.seeded_* come from the SAME PeakBatchedModel/DP so they are
+    // comparable to each other.
+    sequant::opt::detail::SeededBatchedResult sr;
   };
 
   // Optimize the giant under `obj`, binarize, and walk the tree computing per
@@ -1548,6 +1555,7 @@ TEST_CASE(
       // The reported peak becomes the seeded root point; flops is work-neutral
       // and stays the SAME cost_profile value the unseeded run has.
       a.cp.peak_bytes = sr.seeded_peak_bytes;
+      a.sr = sr;
     }
     return a;
   };
@@ -1610,14 +1618,20 @@ TEST_CASE(
   //     whole tree with that occ sliced to occ_block=10 (full occ extent 120).
   //     Since the occ is contracted at NO node it is a pure spectator: slicing
   //     it is work-neutral (identical flops) and shrinks the giant W by
-  //     ~occ_block/occ. The SELECTED (not merely isolatable) perf-first
-  //     schedule's reported peak must therefore drop below 0.2x the unseeded
-  //     0.5-2 TB PPL W, at equal flops. If select_root does NOT pick the
-  //     occ-sliced realization, this is a NO-GO (do not force it).
+  //     ~occ_block/occ. Gate WITHIN one peak model: both sr.unseeded_peak_bytes
+  //     and sr.seeded_peak_bytes come from the SAME DP-staged
+  //     PeakBatchedModel/seeded_root_peak_batched() run (unlike cp.peak_bytes,
+  //     which for the unseeded case is an unrelated cost_profile()-replay
+  //     hwmark). If select_root does NOT pick the occ-sliced realization, this
+  //     is a NO-GO (do not force it).
   CHECK(perf_first.cp.peak_bytes > 5e11);
-  CHECK(perf_first_occ.cp.peak_bytes < 0.2 * perf_first.cp.peak_bytes);
-  CHECK(perf_first_occ.cp.flops ==
-        Catch::Approx(perf_first.cp.flops).epsilon(1e-9));
+  auto const& sr = perf_first_occ.sr;
+  CHECK(sr.seeded_peak_bytes < 0.2 * sr.unseeded_peak_bytes);
+  // flops proof: partitioning a pure spectator axis must be EXACTLY
+  // work-neutral (same DP factorization, same total flops) -- exact integer
+  // equality, not an Approx across two independently-computed cost_profile()
+  // values (which would be equal by construction and prove nothing).
+  CHECK(sr.seeded_flops == sr.unseeded_flops);
 }
 
 // P1 gate spike (external-occ forest batching, mechanism b): PURE SIZING check.

From 12168253403e80a7a4b4d4fbea2fc6fdfb4b7f1b Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Tue, 7 Jul 2026 22:37:01 -0400
Subject: [PATCH 59/78] optimize: emit external-occ batch axis as a
 forest-level signal

---
 SeQuant/core/optimize/optimize.cpp | 102 +++++++++++++++++++++++++++++
 SeQuant/core/optimize/optimize.hpp |  61 +++++++++++++++++
 tests/unit/test_optimize.cpp       |  61 +++++++++++++++++
 3 files changed, 224 insertions(+)

diff --git a/SeQuant/core/optimize/optimize.cpp b/SeQuant/core/optimize/optimize.cpp
index 4241203bb7..420139ab7c 100644
--- a/SeQuant/core/optimize/optimize.cpp
+++ b/SeQuant/core/optimize/optimize.cpp
@@ -1,14 +1,18 @@
 #include <SeQuant/core/binary_node.hpp>
 #include <SeQuant/core/complex.hpp>
 #include <SeQuant/core/container.hpp>
+#include <SeQuant/core/context.hpp>
 #include <SeQuant/core/eval/eval_expr.hpp>
 #include <SeQuant/core/expr.hpp>
 #include <SeQuant/core/hash.hpp>
 #include <SeQuant/core/index.hpp>
+#include <SeQuant/core/index_space_registry.hpp>
+#include <SeQuant/core/optimize/cost_model.hpp>
 #include <SeQuant/core/optimize/optimize.hpp>
 #include <SeQuant/core/optimize/single_term.hpp>
 #include <SeQuant/core/optimize/sum.hpp>
 #include <SeQuant/core/runtime.hpp>
+#include <SeQuant/core/tensor_network.hpp>
 #include <SeQuant/core/utility/indices.hpp>
 #include <SeQuant/core/utility/macros.hpp>
 
@@ -18,10 +22,12 @@
 #include <range/v3/range/conversion.hpp>
 #include <range/v3/view/iota.hpp>
 
+#include <algorithm>
 #include <cstddef>
 #include <cstdlib>
 #include <functional>
 #include <iostream>
+#include <optional>
 #include <string>
 #include <string_view>
 #include <utility>
@@ -260,6 +266,88 @@ ExprPtr optimize_impl(ExprPtr const& expr, OptimizeOptions const& opts,
   return expr->clone();
 }
 
+/// Task 4 (forest batching): decide whether \p expr's optimized form should be
+/// evaluated blocked over a spectator external OCCUPIED axis, and if so which
+/// axis and block size. Returns std::nullopt unless ALL of the trigger
+/// conditions hold (see the doc of the public 3-argument \ref optimize). The
+/// perf-first PeakBatchedModel is built EXACTLY as single_term_opt's
+/// DenseTimeSpaceBatched arm builds it, so the chosen factorization the caller
+/// keeps and this analysis agree.
+std::optional<ExternalBatchAxis> compute_external_batch_axis(
+    ExprPtr const& expr, OptimizeOptions const& opts,
+    std::size_t occ_block_target) {
+  // (i) disabled.
+  if (occ_block_target == 0) return std::nullopt;
+  // (ii) perf-first batched objective only. peak_threshold is NOT a
+  // factorization gate for this objective; it is consulted below only to decide
+  // WHEN to emit the axis.
+  if (opts.objective_function != ObjectiveFunction::DenseTimeSpaceBatched)
+    return std::nullopt;
+  // (iii) a single tensor Product with at least one factorization (>= 3
+  // tensors); anything else has no giant to batch.
+  if (!expr->is<Product>()) return std::nullopt;
+  container::svector<ExprPtr> tensors;
+  for (auto const& f : expr->as<Product>().factors())
+    if (f->is<Tensor>()) tensors.push_back(f);
+  if (tensors.size() < 3) return std::nullopt;
+  TensorNetwork net{tensors};
+
+  // Build the perf-first batched model with the same knobs single_term.hpp's
+  // DenseTimeSpaceBatched arm uses (idxsz, batch policy, inner_pow, roofline,
+  // accumulation_factor, peak_threshold); perf_first is set to true.
+  using Model = opt::detail::PeakBatchedModel<index_to_extent_t>;
+  Model model{opts.idx_to_extent,
+              opts.batch_policy.is_batchable_index,
+              opts.batch_policy.batch_target_size,
+              opts.batch_policy.is_volatile_leaf,
+              opts.inner_pow,
+              opts.volatile_weight,
+              opts.roofline.machine_balance,
+              opts.roofline.fast_mem_elems,
+              opts.roofline.block_tiles,
+              opts.roofline.block_prefactor,
+              opts.batch_policy.persistent_only,
+              opts.peak_flops_tolerance,
+              opts.batch_policy.accumulation_factor,
+              opts.batch_policy.peak_threshold};
+  model.perf_first = true;
+
+  container::svector<Index> const tidxs{};
+  auto ctx = model.build_context(net, tidxs);
+
+  // (iii, cont.) find a genuine external-occupied spectator axis: open on the
+  // root, contracted at no node (is_spectator_axis), and in a pure-occupied
+  // space. The proto pass of batchable_index_list admits such a protoindex to
+  // ctx.aux regardless of is_batchable, so it is discoverable here.
+  auto isr = get_default_context().index_space_registry();
+  std::optional<Index> occ_axis;
+  for (std::size_t k = 0; k < ctx.m; ++k) {
+    if (isr && !isr->is_pure_occupied(ctx.aux[k].space())) continue;
+    if (!model.is_spectator_axis(ctx, k)) continue;
+    occ_axis = ctx.aux[k];
+    break;
+  }
+  if (!occ_axis) return std::nullopt;
+
+  // Snap the requested block down to the axis extent.
+  std::size_t const ext =
+      opts.idx_to_extent ? opts.idx_to_extent(*occ_axis) : occ_block_target;
+  std::size_t const block =
+      ext > 0 ? std::min(occ_block_target, ext) : occ_block_target;
+
+  // Seed the axis into the DP root frontier to size the tree under the occ
+  // slice, and read the UNSEEDED peak for the trigger gate.
+  auto sr = opt::detail::seeded_root_peak_batched(model, net, tidxs, *occ_axis,
+                                                  block);
+
+  // (iv) only emit when the term actually needs batching to fit the budget:
+  // the unseeded (whole) peak exceeds peak_threshold. (+inf default => never.)
+  if (!(sr.unseeded_peak_bytes > opts.batch_policy.peak_threshold))
+    return std::nullopt;
+
+  return ExternalBatchAxis{sr.seeded_axis.value_or(*occ_axis), block};
+}
+
 }  // namespace
 
 ExprPtr optimize(ExprPtr const& expr, OptimizeOptions opts) {
@@ -268,6 +356,20 @@ ExprPtr optimize(ExprPtr const& expr, OptimizeOptions opts) {
                        /*parallel_outer=*/true);
 }
 
+OptimizeResult optimize(ExprPtr const& expr, OptimizeOptions opts,
+                        std::size_t occ_block_target) {
+  if (!opts.idx_to_extent) opts.idx_to_extent = default_idx_to_size();
+  OptimizeResult res;
+  res.expr = optimize_impl(expr, opts, opts.reorder == ReorderSum::Reorder,
+                           /*parallel_outer=*/true);
+  // The forest signal is derived from the ORIGINAL term's tensor network (the
+  // batched DP is order-independent), so it does not depend on the chosen
+  // parenthesization above.
+  res.external_batch_axis =
+      compute_external_batch_axis(expr, opts, occ_block_target);
+  return res;
+}
+
 ResultExpr& optimize(ResultExpr& expr, OptimizeOptions opts) {
   expr.expression() = optimize(expr.expression(), std::move(opts));
   return expr;
diff --git a/SeQuant/core/optimize/optimize.hpp b/SeQuant/core/optimize/optimize.hpp
index caa6952d44..cb50c1d0d0 100644
--- a/SeQuant/core/optimize/optimize.hpp
+++ b/SeQuant/core/optimize/optimize.hpp
@@ -2,10 +2,39 @@
 #define SEQUANT_OPTIMIZE_OPTIMIZE_HPP
 
 #include <SeQuant/core/expr_fwd.hpp>
+#include <SeQuant/core/index.hpp>
 #include <SeQuant/core/optimize/options.hpp>
 
+#include <cstddef>
+#include <optional>
+
 namespace sequant {
 
+/// A forest-level batching signal: the single spectator external index (e.g. a
+/// CC residual's own external OCCUPIED index, carried only as a composite
+/// protoindex on the output PNOs and therefore contracted at NO node) over
+/// which the whole optimized term should be evaluated in blocks of
+/// \c block_size, so every intermediate carrying that axis shrinks by
+/// ~block_size/extent while total work is unchanged (partitioning a spectator
+/// is work-neutral). Because a never-contracted axis has no eval node to hang
+/// on, this is reported per optimized term rather than as a per-node
+/// \c EvalExpr::batch_axes entry; the runtime (P3) and MPQC (P4) read it here.
+struct ExternalBatchAxis {
+  /// The spectator external axis to block over.
+  Index axis;
+  /// The per-block extent (== the requested occ_block_target, snapped down to
+  /// the axis extent).
+  std::size_t block_size = 0;
+};
+
+/// Result of the forest-batching optimize overload: the optimized expression
+/// plus an optional \ref ExternalBatchAxis (empty when no external-occ batching
+/// was selected).
+struct OptimizeResult {
+  ExprPtr expr;
+  std::optional<ExternalBatchAxis> external_batch_axis;
+};
+
 /// Optimize the expression for lower evaluation cost.
 ///
 /// \param expr  Expression to be optimized.
@@ -16,6 +45,38 @@ namespace sequant {
 /// \return Optimized expression.
 ExprPtr optimize(ExprPtr const& expr, OptimizeOptions opts = {});
 
+/// Forest-batching overload: optimize \p expr, and additionally report an
+/// optional \ref ExternalBatchAxis --- the spectator external OCCUPIED axis
+/// over which the whole term should be evaluated in blocks of \p
+/// occ_block_target (snapped down to the axis extent).
+///
+/// The axis is emitted only when ALL of the following hold:
+///   (i)   \p occ_block_target > 0 (0 = disabled; then \c external_batch_axis
+///         is empty and the optimized expression is byte-identical to the
+///         2-argument overload);
+///   (ii)  \p opts.objective_function == \c DenseTimeSpaceBatched (the
+///         perf-first batched objective);
+///   (iii) \p expr is a single tensor Product with a genuine spectator external
+///         occupied axis (open on the root, contracted at no node); and
+///   (iv)  the perf-first factorization's UNSEEDED peak exceeds
+///         \p opts.batch_policy.peak_threshold --- i.e. the term actually needs
+///         batching to fit the budget. (perf-first ignores \c peak_threshold
+///         for FACTORIZATION selection; it is consulted here only to decide
+///         WHEN to emit the axis.)
+/// Otherwise \c external_batch_axis is empty.
+///
+/// The chosen factorization (\c OptimizeResult::expr) is identical to what the
+/// 2-argument overload produces under the same \p opts; only the extra signal
+/// is computed.
+///
+/// \param expr             Expression to be optimized.
+/// \param opts             Optimization parameters; see \ref OptimizeOptions.
+/// \param occ_block_target Requested per-block extent of the external occupied
+///                         axis (0 = disabled).
+/// \return The optimized expression paired with the optional forest signal.
+OptimizeResult optimize(ExprPtr const& expr, OptimizeOptions opts,
+                        std::size_t occ_block_target);
+
 /// \copydoc optimize(ExprPtr const&, OptimizeOptions)
 ResultExpr& optimize(ResultExpr& expr, OptimizeOptions opts = {});
 
diff --git a/tests/unit/test_optimize.cpp b/tests/unit/test_optimize.cpp
index ffd6a48d59..dc4bee7e20 100644
--- a/tests/unit/test_optimize.cpp
+++ b/tests/unit/test_optimize.cpp
@@ -1977,6 +1977,67 @@ TEST_CASE("PPL: form 4-PNO W vs fold-t (peak-neutral, flop tie-break)",
   CHECK(tbat_w_tight == flops_w);
 }
 
+// Task 4 (forest batching, G4): the public optimize() surfaces the chosen
+// spectator external-occupied axis + block size as a forest-level signal
+// (ExternalBatchAxis) that the runtime (P3) and MPQC (P4) read. The PPL
+// residual carries its external occ (i_1,i_2) ONLY as a composite protoindex on
+// the output PNOs a<i,i> (never a contracted top-level slot), so no eval node
+// hangs it -- it is emitted per optimized term instead. The perf-first
+// DenseTimeSpaceBatched factorization forms the 4-PNO W giant (~40 MB here);
+// with a budget it exceeds, optimize() reports the occ axis sliced to
+// occ_block_target=10.
+TEST_CASE("optimize emits an external batch axis for the PPL term",
+          "[optimize][external-occ]") {
+  using namespace sequant;
+  auto ctx_resetter = set_scoped_default_context(get_default_context().clone());
+  auto reg = get_default_context().mutable_index_space_registry();
+  mbpt::add_df_spaces(reg);
+  mbpt::add_pao_spaces(reg);
+  mbpt::add_ao_spaces(reg);
+  for (auto&& [k, v] :
+       std::initializer_list<std::pair<std::wstring_view, size_t>>{
+           {L"i", 16}, {L"a", 12}, {L"μ̃", 170}, {L"Κ", 472}})
+    reg->retrieve_ptr(k)->approximate_size(v);
+  auto aux = reg->retrieve(L"Κ");
+
+  // Same PPL residual as the form-W test above: R_ij^{a1 a2} = (a1 a3|a2 a4)
+  // t_ij^{a3 a4}, DF-factored, i_1/i_2 external occ carried only as protos.
+  auto prod = deserialize(
+      L"C{a_1<i_1,i_2>;μ̃_1} g{μ̃_1;μ̃_2;Κ_1} C{μ̃_2;a_3<i_1,i_2>} "
+      L"C{a_2<i_1,i_2>;μ̃_3} g{μ̃_3;μ̃_4;Κ_1} C{μ̃_4;a_4<i_1,i_2>} "
+      L"t{a_3<i_1,i_2>,a_4<i_1,i_2>;i_1,i_2}");
+
+  OptimizeOptions opts;
+  opts.objective_function = ObjectiveFunction::DenseTimeSpaceBatched;
+  opts.reorder = ReorderSum::NoReorder;
+  opts.idx_to_extent = [](Index const& ix) -> std::size_t {
+    return ix.nonnull() ? ix.space().approximate_size() : std::size_t{1};
+  };
+  opts.inner_pow = [](Index const&, std::size_t) -> double { return 12.0; };
+  opts.batch_policy.is_batchable_index = [aux](Index const& ix) {
+    return ix.space() == aux;
+  };
+  opts.batch_policy.batch_target_size = [](Index const&) -> std::size_t {
+    return 236;
+  };
+  opts.batch_policy.is_volatile_leaf = [](Tensor const& t) {
+    return t.label() == L"t";
+  };
+  // A budget the unseeded 4-PNO W giant (~40 MB) exceeds: 1 MB.
+  opts.batch_policy.peak_threshold = 1.0e6;
+
+  auto res = optimize(prod, opts, /*occ_block_target=*/10);
+  REQUIRE(res.external_batch_axis.has_value());
+  CHECK(res.external_batch_axis->axis.space().base_key() == L"i");
+  CHECK(res.external_batch_axis->block_size == 10);
+  REQUIRE(static_cast<bool>(res.expr));
+
+  // occ_block_target == 0 disables the signal (the default 2-arg optimize path
+  // is byte-identical; the [optimize] suite is its regression witness).
+  auto res_off = optimize(prod, opts, /*occ_block_target=*/0);
+  CHECK_FALSE(res_off.external_batch_axis.has_value());
+}
+
 // Quadratic-bubble (g·t2·t2) exchange term in PNO/CSV basis: the two competing
 // factorizations of one residual contribution.
 //

From f2ae97c2774a6b0e5c20971cd5901fb7a4968d6f Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Tue, 7 Jul 2026 22:58:24 -0400
Subject: [PATCH 60/78] optimize: domain-neutral spectator-index batching
 config on BatchPolicy

---
 SeQuant/core/batch_policy.hpp      |  6 ++++
 SeQuant/core/optimize/optimize.cpp | 36 ++++++++++++------------
 SeQuant/core/optimize/optimize.hpp | 44 +++++++++++++++---------------
 tests/unit/test_optimize.cpp       | 18 ++++++++----
 4 files changed, 59 insertions(+), 45 deletions(-)

diff --git a/SeQuant/core/batch_policy.hpp b/SeQuant/core/batch_policy.hpp
index def23cd992..c5dfe26e16 100644
--- a/SeQuant/core/batch_policy.hpp
+++ b/SeQuant/core/batch_policy.hpp
@@ -22,6 +22,12 @@ struct BatchPolicy {
   std::function<std::size_t(Index const&)> batch_target_size = {};
   std::function<bool(Tensor const&)> is_volatile_leaf = {};
 
+  /// If true, an external/spectator index -- open on the whole network's result
+  /// yet contracted at no node -- is eligible for batching; its per-slice size
+  /// comes from \c batch_target_size(ix) like any batchable index. Default
+  /// false = no spectator batching (byte-identical to non-spectator behavior).
+  bool batch_spectator_indices = false;
+
   /// If true, restrict batching to persistent (amplitude-independent) subtrees,
   /// declining to batch any subtree that contains a volatile leaf. If false
   /// (the default), batch ACROSS THE BOARD: slicing the batch axis shrinks any
diff --git a/SeQuant/core/optimize/optimize.cpp b/SeQuant/core/optimize/optimize.cpp
index 420139ab7c..3b3e06d64e 100644
--- a/SeQuant/core/optimize/optimize.cpp
+++ b/SeQuant/core/optimize/optimize.cpp
@@ -267,17 +267,16 @@ ExprPtr optimize_impl(ExprPtr const& expr, OptimizeOptions const& opts,
 }
 
 /// Task 4 (forest batching): decide whether \p expr's optimized form should be
-/// evaluated blocked over a spectator external OCCUPIED axis, and if so which
-/// axis and block size. Returns std::nullopt unless ALL of the trigger
-/// conditions hold (see the doc of the public 3-argument \ref optimize). The
-/// perf-first PeakBatchedModel is built EXACTLY as single_term_opt's
-/// DenseTimeSpaceBatched arm builds it, so the chosen factorization the caller
-/// keeps and this analysis agree.
+/// evaluated blocked over a spectator external axis, and if so which axis and
+/// block size. Returns std::nullopt unless ALL of the trigger conditions hold
+/// (see the doc of the public \ref optimize_result). The perf-first
+/// PeakBatchedModel is built EXACTLY as single_term_opt's DenseTimeSpaceBatched
+/// arm builds it, so the chosen factorization the caller keeps and this
+/// analysis agree.
 std::optional<ExternalBatchAxis> compute_external_batch_axis(
-    ExprPtr const& expr, OptimizeOptions const& opts,
-    std::size_t occ_block_target) {
+    ExprPtr const& expr, OptimizeOptions const& opts) {
   // (i) disabled.
-  if (occ_block_target == 0) return std::nullopt;
+  if (!opts.batch_policy.batch_spectator_indices) return std::nullopt;
   // (ii) perf-first batched objective only. peak_threshold is NOT a
   // factorization gate for this objective; it is consulted below only to decide
   // WHEN to emit the axis.
@@ -329,11 +328,16 @@ std::optional<ExternalBatchAxis> compute_external_batch_axis(
   }
   if (!occ_axis) return std::nullopt;
 
-  // Snap the requested block down to the axis extent.
+  // The per-block extent for the spectator comes from batch_target_size, like
+  // any batchable index; snap it down to the axis extent.
+  std::size_t const target =
+      opts.batch_policy.batch_target_size
+          ? opts.batch_policy.batch_target_size(*occ_axis)
+          : 0;
+  if (target == 0) return std::nullopt;
   std::size_t const ext =
-      opts.idx_to_extent ? opts.idx_to_extent(*occ_axis) : occ_block_target;
-  std::size_t const block =
-      ext > 0 ? std::min(occ_block_target, ext) : occ_block_target;
+      opts.idx_to_extent ? opts.idx_to_extent(*occ_axis) : target;
+  std::size_t const block = ext > 0 ? std::min(target, ext) : target;
 
   // Seed the axis into the DP root frontier to size the tree under the occ
   // slice, and read the UNSEEDED peak for the trigger gate.
@@ -356,8 +360,7 @@ ExprPtr optimize(ExprPtr const& expr, OptimizeOptions opts) {
                        /*parallel_outer=*/true);
 }
 
-OptimizeResult optimize(ExprPtr const& expr, OptimizeOptions opts,
-                        std::size_t occ_block_target) {
+OptimizeResult optimize_result(ExprPtr const& expr, OptimizeOptions opts) {
   if (!opts.idx_to_extent) opts.idx_to_extent = default_idx_to_size();
   OptimizeResult res;
   res.expr = optimize_impl(expr, opts, opts.reorder == ReorderSum::Reorder,
@@ -365,8 +368,7 @@ OptimizeResult optimize(ExprPtr const& expr, OptimizeOptions opts,
   // The forest signal is derived from the ORIGINAL term's tensor network (the
   // batched DP is order-independent), so it does not depend on the chosen
   // parenthesization above.
-  res.external_batch_axis =
-      compute_external_batch_axis(expr, opts, occ_block_target);
+  res.external_batch_axis = compute_external_batch_axis(expr, opts);
   return res;
 }
 
diff --git a/SeQuant/core/optimize/optimize.hpp b/SeQuant/core/optimize/optimize.hpp
index cb50c1d0d0..dc8428217d 100644
--- a/SeQuant/core/optimize/optimize.hpp
+++ b/SeQuant/core/optimize/optimize.hpp
@@ -22,14 +22,14 @@ namespace sequant {
 struct ExternalBatchAxis {
   /// The spectator external axis to block over.
   Index axis;
-  /// The per-block extent (== the requested occ_block_target, snapped down to
-  /// the axis extent).
+  /// The per-block extent (== \c batch_target_size(axis), snapped down to the
+  /// axis extent).
   std::size_t block_size = 0;
 };
 
-/// Result of the forest-batching optimize overload: the optimized expression
-/// plus an optional \ref ExternalBatchAxis (empty when no external-occ batching
-/// was selected).
+/// Result of \ref optimize_result: the optimized expression plus an optional
+/// \ref ExternalBatchAxis (empty when no spectator-index batching was
+/// selected).
 struct OptimizeResult {
   ExprPtr expr;
   std::optional<ExternalBatchAxis> external_batch_axis;
@@ -45,19 +45,20 @@ struct OptimizeResult {
 /// \return Optimized expression.
 ExprPtr optimize(ExprPtr const& expr, OptimizeOptions opts = {});
 
-/// Forest-batching overload: optimize \p expr, and additionally report an
-/// optional \ref ExternalBatchAxis --- the spectator external OCCUPIED axis
-/// over which the whole term should be evaluated in blocks of \p
-/// occ_block_target (snapped down to the axis extent).
+/// Forest-batching entry point: optimize \p expr, and additionally report an
+/// optional \ref ExternalBatchAxis --- the spectator external axis over which
+/// the whole term should be evaluated in blocks of
+/// \c opts.batch_policy.batch_target_size(axis) (snapped down to the axis
+/// extent).
 ///
 /// The axis is emitted only when ALL of the following hold:
-///   (i)   \p occ_block_target > 0 (0 = disabled; then \c external_batch_axis
-///         is empty and the optimized expression is byte-identical to the
-///         2-argument overload);
+///   (i)   \p opts.batch_policy.batch_spectator_indices == true (false =
+///         disabled; then \c external_batch_axis is empty and the optimized
+///         expression is byte-identical to \ref optimize);
 ///   (ii)  \p opts.objective_function == \c DenseTimeSpaceBatched (the
 ///         perf-first batched objective);
 ///   (iii) \p expr is a single tensor Product with a genuine spectator external
-///         occupied axis (open on the root, contracted at no node); and
+///         axis (open on the root, contracted at no node); and
 ///   (iv)  the perf-first factorization's UNSEEDED peak exceeds
 ///         \p opts.batch_policy.peak_threshold --- i.e. the term actually needs
 ///         batching to fit the budget. (perf-first ignores \c peak_threshold
@@ -65,17 +66,16 @@ ExprPtr optimize(ExprPtr const& expr, OptimizeOptions opts = {});
 ///         WHEN to emit the axis.)
 /// Otherwise \c external_batch_axis is empty.
 ///
-/// The chosen factorization (\c OptimizeResult::expr) is identical to what the
-/// 2-argument overload produces under the same \p opts; only the extra signal
-/// is computed.
+/// The chosen factorization (\c OptimizeResult::expr) is byte-identical to what
+/// \ref optimize produces under the same \p opts; only the extra signal is
+/// computed.
 ///
-/// \param expr             Expression to be optimized.
-/// \param opts             Optimization parameters; see \ref OptimizeOptions.
-/// \param occ_block_target Requested per-block extent of the external occupied
-///                         axis (0 = disabled).
+/// \param expr Expression to be optimized.
+/// \param opts Optimization parameters; see \ref OptimizeOptions. The spectator
+///             per-block extent comes from
+///             \c opts.batch_policy.batch_target_size(axis).
 /// \return The optimized expression paired with the optional forest signal.
-OptimizeResult optimize(ExprPtr const& expr, OptimizeOptions opts,
-                        std::size_t occ_block_target);
+OptimizeResult optimize_result(ExprPtr const& expr, OptimizeOptions opts = {});
 
 /// \copydoc optimize(ExprPtr const&, OptimizeOptions)
 ResultExpr& optimize(ResultExpr& expr, OptimizeOptions opts = {});
diff --git a/tests/unit/test_optimize.cpp b/tests/unit/test_optimize.cpp
index dc4bee7e20..c3d910a96a 100644
--- a/tests/unit/test_optimize.cpp
+++ b/tests/unit/test_optimize.cpp
@@ -2017,24 +2017,30 @@ TEST_CASE("optimize emits an external batch axis for the PPL term",
   opts.batch_policy.is_batchable_index = [aux](Index const& ix) {
     return ix.space() == aux;
   };
-  opts.batch_policy.batch_target_size = [](Index const&) -> std::size_t {
-    return 236;
+  // All batch sizes live together on BatchPolicy: the DF aux Κ keeps its 236
+  // slice; the spectator occ axis "i" gets its own per-block extent of 10.
+  auto occ = reg->retrieve(L"i");
+  opts.batch_policy.batch_target_size = [occ](Index const& ix) -> std::size_t {
+    return ix.space() == occ ? 10 : 236;
   };
   opts.batch_policy.is_volatile_leaf = [](Tensor const& t) {
     return t.label() == L"t";
   };
   // A budget the unseeded 4-PNO W giant (~40 MB) exceeds: 1 MB.
   opts.batch_policy.peak_threshold = 1.0e6;
+  // Enable spectator-index batching (the domain-neutral trigger).
+  opts.batch_policy.batch_spectator_indices = true;
 
-  auto res = optimize(prod, opts, /*occ_block_target=*/10);
+  auto res = optimize_result(prod, opts);
   REQUIRE(res.external_batch_axis.has_value());
   CHECK(res.external_batch_axis->axis.space().base_key() == L"i");
   CHECK(res.external_batch_axis->block_size == 10);
   REQUIRE(static_cast<bool>(res.expr));
 
-  // occ_block_target == 0 disables the signal (the default 2-arg optimize path
-  // is byte-identical; the [optimize] suite is its regression witness).
-  auto res_off = optimize(prod, opts, /*occ_block_target=*/0);
+  // batch_spectator_indices == false disables the signal (the default
+  // optimize() path is byte-identical; the [optimize] suite is its witness).
+  opts.batch_policy.batch_spectator_indices = false;
+  auto res_off = optimize_result(prod, opts);
   CHECK_FALSE(res_off.external_batch_axis.has_value());
 }
 

From 1ded29353b039fcbecfc2d979c554f6859189307 Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Tue, 7 Jul 2026 23:07:18 -0400
Subject: [PATCH 61/78] optimize: scrub residual domain wording from
 ExternalBatchAxis public docs

---
 SeQuant/core/optimize/optimize.hpp | 18 +++++++++---------
 tests/unit/test_optimize.cpp       | 20 +++++++++++---------
 2 files changed, 20 insertions(+), 18 deletions(-)

diff --git a/SeQuant/core/optimize/optimize.hpp b/SeQuant/core/optimize/optimize.hpp
index dc8428217d..d4584980e2 100644
--- a/SeQuant/core/optimize/optimize.hpp
+++ b/SeQuant/core/optimize/optimize.hpp
@@ -10,15 +10,15 @@
 
 namespace sequant {
 
-/// A forest-level batching signal: the single spectator external index (e.g. a
-/// CC residual's own external OCCUPIED index, carried only as a composite
-/// protoindex on the output PNOs and therefore contracted at NO node) over
-/// which the whole optimized term should be evaluated in blocks of
-/// \c block_size, so every intermediate carrying that axis shrinks by
-/// ~block_size/extent while total work is unchanged (partitioning a spectator
-/// is work-neutral). Because a never-contracted axis has no eval node to hang
-/// on, this is reported per optimized term rather than as a per-node
-/// \c EvalExpr::batch_axes entry; the runtime (P3) and MPQC (P4) read it here.
+/// A forest-level batching signal: the single spectator external index (an
+/// index that is open on the whole network's result but contracted at NO node
+/// -- e.g. one carried only as a composite protoindex on the result) over which
+/// the whole optimized term should be evaluated in blocks of \c block_size, so
+/// every intermediate carrying that axis shrinks by ~block_size/extent while
+/// total work is unchanged (partitioning a spectator is work-neutral). Because
+/// a never-contracted axis has no eval node to hang on, this is reported per
+/// optimized term rather than as a per-node \c EvalExpr::batch_axes entry; the
+/// runtime and downstream consumers read it here.
 struct ExternalBatchAxis {
   /// The spectator external axis to block over.
   Index axis;
diff --git a/tests/unit/test_optimize.cpp b/tests/unit/test_optimize.cpp
index c3d910a96a..663a8d1643 100644
--- a/tests/unit/test_optimize.cpp
+++ b/tests/unit/test_optimize.cpp
@@ -1977,15 +1977,17 @@ TEST_CASE("PPL: form 4-PNO W vs fold-t (peak-neutral, flop tie-break)",
   CHECK(tbat_w_tight == flops_w);
 }
 
-// Task 4 (forest batching, G4): the public optimize() surfaces the chosen
-// spectator external-occupied axis + block size as a forest-level signal
-// (ExternalBatchAxis) that the runtime (P3) and MPQC (P4) read. The PPL
-// residual carries its external occ (i_1,i_2) ONLY as a composite protoindex on
-// the output PNOs a<i,i> (never a contracted top-level slot), so no eval node
-// hangs it -- it is emitted per optimized term instead. The perf-first
-// DenseTimeSpaceBatched factorization forms the 4-PNO W giant (~40 MB here);
-// with a budget it exceeds, optimize() reports the occ axis sliced to
-// occ_block_target=10.
+// Task 4 (forest batching, G4): the public optimize_result() surfaces the
+// chosen spectator external axis + block size as a forest-level signal
+// (ExternalBatchAxis) that the runtime and downstream consumers read. In this
+// (chemistry) test the PPL residual carries its external occ (i_1,i_2) ONLY as
+// a composite protoindex on the output PNOs a<i,i> (never a contracted
+// top-level slot), so no eval node hangs it -- it is emitted per optimized term
+// instead. The perf-first DenseTimeSpaceBatched factorization forms the 4-PNO W
+// giant
+// (~40 MB here); with a budget it exceeds, optimize_result() reports the
+// spectator axis sliced to batch_target_size=10, enabled by the domain-neutral
+// BatchPolicy::batch_spectator_indices flag.
 TEST_CASE("optimize emits an external batch axis for the PPL term",
           "[optimize][external-occ]") {
   using namespace sequant;

From 8d22d937002646d3329218d135e7319fd6b44c50 Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Tue, 7 Jul 2026 23:13:31 -0400
Subject: [PATCH 62/78] eval result: add write_into_slice block-scatter
 combinator (dryrun backend)

---
 SeQuant/core/eval/backends/dryrun/result.hpp | 85 ++++++++++++++++++++
 SeQuant/core/eval/result.hpp                 | 25 ++++++
 tests/unit/test_eval_dryrun.cpp              | 53 ++++++++++++
 3 files changed, 163 insertions(+)

diff --git a/SeQuant/core/eval/backends/dryrun/result.hpp b/SeQuant/core/eval/backends/dryrun/result.hpp
index 25b3aac8ff..f48a3f50cc 100644
--- a/SeQuant/core/eval/backends/dryrun/result.hpp
+++ b/SeQuant/core/eval/backends/dryrun/result.hpp
@@ -28,6 +28,14 @@ namespace sequant::eval::dryrun {
 ///
 using annot_t = container::svector<Index>;
 
+/// Per-mode assembled element coverage recorded by write_into_slice(): maps an
+/// outer mode position to the contiguous `[lo, hi)` element range filled so far
+/// by scattered blocks. Lets a zero-data DryRun destination report the REALIZED
+/// (assembled) size along a partitioned mode and detect gaps/overlaps between
+/// blocks -- the assemble-side analogue of ExtentOverrides for slice_mode().
+using AssembledCoverage =
+    container::map<std::size_t, std::pair<std::size_t, std::size_t>>;
+
 class ResultDryRun;
 class ResultDryRunNested;
 
@@ -134,6 +142,51 @@ struct DryRunOps {
     return make_dryrun_result(idx, cm, std::move(merged));
   }
 
+  /// Scatter \p block into the `[block_lo, block_hi)` element slice of the
+  /// destination's mode \p mode -- the inverse of slice_mode(). Zero-data:
+  /// updates only the destination's modelled size and assembled-coverage
+  /// bookkeeping. \p ov and \p cov are the destination's (mutated in place).
+  static void write_into_slice(container::svector<Index> const& idx,
+                               ExtentOverrides& ov, AssembledCoverage& cov,
+                               std::shared_ptr<CostModel const> const& cm,
+                               Result const& block, std::size_t mode,
+                               std::size_t block_lo, std::size_t block_hi) {
+    SEQUANT_ASSERT(mode < idx.size());
+    SEQUANT_ASSERT(block_lo < block_hi);
+    Index const& mix = idx[mode];
+    // Tile/width consistency: the block's own modelled extent on the shared
+    // mode index must equal the slice width it is being written into.
+    auto const bov = overrides_of(block);
+    std::size_t const block_extent = [&] {
+      if (auto it = bov.find(mix); it != bov.end()) return it->second;
+      return cm->regime().extent(mix);
+    }();
+    SEQUANT_ASSERT(block_extent == block_hi - block_lo);
+    // Merge the block's range into the assembled coverage, requiring
+    // contiguity: a block that neither appends after nor prepends before the
+    // filled range would leave a gap or overlap another block (a
+    // double-count). This is what makes disjoint gap-free tiling the only
+    // accepted assembly.
+    if (auto it = cov.find(mode); it == cov.end()) {
+      cov.emplace(mode,
+                  std::pair<std::size_t, std::size_t>{block_lo, block_hi});
+    } else {
+      auto& lohi = it->second;
+      bool const append = block_lo == lohi.second;
+      bool const prepend = block_hi == lohi.first;
+      SEQUANT_ASSERT(append || prepend);
+      if (append)
+        lohi.second = block_hi;
+      else
+        lohi.first = block_lo;
+    }
+    // Reflect the assembled element width (hi - lo, lobound preserved) as the
+    // realized extent of the batch mode so size_in_bytes() tracks the
+    // reconstructed footprint.
+    auto const& lohi = cov.at(mode);
+    ov[mix] = lohi.second - lohi.first;
+  }
+
   [[nodiscard]] static container::svector<std::pair<std::size_t, std::size_t>>
   mode_batches(container::svector<Index> const& idx, ExtentOverrides const& ov,
                std::shared_ptr<CostModel const> const& cm, std::size_t mode,
@@ -192,6 +245,15 @@ class ResultDryRun final : public Result {
     return overrides_;
   }
 
+  /// The contiguous `[lo, hi)` element range of outer mode \p mode assembled so
+  /// far by write_into_slice() (empty `{0, 0}` if nothing written).
+  [[nodiscard]] std::pair<std::size_t, std::size_t> assembled_range(
+      std::size_t mode) const {
+    if (auto it = assembled_.find(mode); it != assembled_.end())
+      return it->second;
+    return {0, 0};
+  }
+
  private:
   struct Payload {};
 
@@ -233,6 +295,12 @@ class ResultDryRun final : public Result {
                                            target_batch_size);
   }
 
+  void write_into_slice(Result const& block, std::size_t mode,
+                        std::size_t block_lo, std::size_t block_hi) override {
+    detail::DryRunOps::write_into_slice(indices_, overrides_, assembled_, cm_,
+                                        block, mode, block_lo, block_hi);
+  }
+
   void add_inplace(Result const& other) override {
     SEQUANT_ASSERT(other.is<ResultDryRun>() || other.is<ResultDryRunNested>());
     overrides_ =
@@ -258,6 +326,7 @@ class ResultDryRun final : public Result {
   container::svector<Index> indices_;
   std::shared_ptr<CostModel const> cm_;
   ExtentOverrides overrides_;
+  AssembledCoverage assembled_;
 };
 
 ///
@@ -319,6 +388,15 @@ class ResultDryRunNested final : public Result {
     return overrides_;
   }
 
+  /// The contiguous `[lo, hi)` element range of outer mode \p mode assembled so
+  /// far by write_into_slice() (empty `{0, 0}` if nothing written).
+  [[nodiscard]] std::pair<std::size_t, std::size_t> assembled_range(
+      std::size_t mode) const {
+    if (auto it = assembled_.find(mode); it != assembled_.end())
+      return it->second;
+    return {0, 0};
+  }
+
  private:
   struct Payload {};
 
@@ -360,6 +438,12 @@ class ResultDryRunNested final : public Result {
                                            target_batch_size);
   }
 
+  void write_into_slice(Result const& block, std::size_t mode,
+                        std::size_t block_lo, std::size_t block_hi) override {
+    detail::DryRunOps::write_into_slice(indices_, overrides_, assembled_, cm_,
+                                        block, mode, block_lo, block_hi);
+  }
+
   void add_inplace(Result const& other) override {
     SEQUANT_ASSERT(other.is<ResultDryRun>() || other.is<ResultDryRunNested>());
     overrides_ =
@@ -390,6 +474,7 @@ class ResultDryRunNested final : public Result {
   container::svector<Index> indices_;  // canon order; outer_++inner_ content
   std::shared_ptr<CostModel const> cm_;
   ExtentOverrides overrides_;
+  AssembledCoverage assembled_;
 };
 
 [[nodiscard]] inline ResultPtr make_dryrun_result(
diff --git a/SeQuant/core/eval/result.hpp b/SeQuant/core/eval/result.hpp
index 8ddc9f6709..4eaac2a321 100644
--- a/SeQuant/core/eval/result.hpp
+++ b/SeQuant/core/eval/result.hpp
@@ -332,6 +332,31 @@ class Result {
     throw detail::unimplemented_method("mode_batches");
   }
 
+  ///
+  /// \brief Scatter \p block into the `[block_lo, block_hi)` element slice of
+  ///        this result's mode \p mode.
+  ///
+  /// The inverse of slice_mode(): where slice_mode() GATHERS one contiguous
+  /// element block OUT of a mode, write_into_slice() SCATTERS a per-block
+  /// result INTO a pre-sized destination's `[block_lo, block_hi)` slice along
+  /// outer \p mode, leaving every other mode untouched. Used to assemble a
+  /// result that is evaluated one block at a time over a partitioned
+  /// (Hadamard/spectator) mode: partitioning the mode into disjoint blocks,
+  /// evaluating each, and write_into_slice()-ing each block into its slice
+  /// reconstructs the whole result. Unlike add_inplace() (which accumulates,
+  /// correct only for a contracted mode), the blocks are disjoint slices of
+  /// one pre-sized result. Element semantics keep this backend-neutral (no
+  /// notion of tiles); a tiled backend may require `[block_lo, block_hi)` to
+  /// fall on tile boundaries and preserves each mode's element lobound. Not a
+  /// pure virtual: only tensor-backed results need it; the default throws.
+  /// Mirrors the slice_mode() precedent.
+  ///
+  virtual void write_into_slice(Result const& /*block*/, std::size_t /*mode*/,
+                                std::size_t /*block_lo*/,
+                                std::size_t /*block_hi*/) {
+    throw detail::unimplemented_method("write_into_slice");
+  }
+
   ///
   /// \brief Add other Result object into this object.
   ///
diff --git a/tests/unit/test_eval_dryrun.cpp b/tests/unit/test_eval_dryrun.cpp
index f35f59a792..bdd4569c05 100644
--- a/tests/unit/test_eval_dryrun.cpp
+++ b/tests/unit/test_eval_dryrun.cpp
@@ -861,6 +861,59 @@ TEST_CASE("dryrun flat result mode_batches tiles the mode extent",
   CHECK(batches.back().second == 20);
 }
 
+TEST_CASE(
+    "dryrun result write_into_slice assembles disjoint blocks into a "
+    "pre-sized destination",
+    "[dryrun-result][write-into-slice]") {
+  auto r = backend_test_regime();
+  auto cm = std::make_shared<CostModel const>(r);
+
+  // A ToT template whose outer batch mode (position 0) is the occupied index
+  // i_1 (extent 10). Its full modelled size is the reference we must
+  // reconstruct by assembling disjoint outer-mode blocks.
+  Index i1{L"i_1"}, i2{L"i_2"}, a3{L"a_3"};
+  Index a_pno{L"a_1", {i1, i2}};  // proto-indexed composite (CSV/PNO) leg
+  container::svector<Index> outer{i1, a3};
+  container::svector<Index> inner{a_pno};
+  container::svector<Index> canon{i1, a3, a_pno};
+
+  ResultDryRunNested tmpl{outer, inner, cm, {}, canon};
+  Result const& tmpl_r = tmpl;
+  auto const whole = tmpl_r.size_in_bytes();
+
+  // Two disjoint element blocks [0,5) and [5,10) that tile the full extent 10
+  // of the batch mode with no overlap and no gap. Slice each out of the
+  // template (mirrors how the batched evaluator produces per-block results).
+  auto block0 = tmpl_r.slice_mode(0, 0, 5);
+  auto block1 = tmpl_r.slice_mode(0, 5, 10);
+  REQUIRE(block0);
+  REQUIRE(block1);
+
+  // A fresh pre-sized destination whose batch mode starts UNFILLED (extent 0):
+  // its shape/index-set is fixed, but its assembled size grows as blocks are
+  // written in. Assemble the two blocks into it.
+  ResultDryRunNested dest{outer, inner, cm, {{i1, 0}}, canon};
+  Result& dest_w = dest;  // the mutator is reached through the base interface
+  dest_w.write_into_slice(*block0, 0, 0, 5);
+  dest_w.write_into_slice(*block1, 0, 5, 10);
+
+  // No double-count, no gap: the assembled modelled size equals the whole
+  // array's size exactly, and the covered element range is the full extent.
+  CHECK(dest_w.size_in_bytes() == whole);
+  CHECK(dest.assembled_range(0) == std::pair<std::size_t, std::size_t>{0, 10});
+
+  // Lobounds are preserved: a block written at a nonzero element offset (a
+  // frozen-core-style occupied offset) assembles at that offset, not rebased
+  // to 0.
+  ResultDryRunNested dest_fc{outer, inner, cm, {{i1, 0}}, canon};
+  Result& dest_fc_w = dest_fc;
+  auto block_fc = tmpl_r.slice_mode(0, 2, 6);
+  REQUIRE(block_fc);
+  dest_fc_w.write_into_slice(*block_fc, 0, 2, 6);
+  CHECK(dest_fc.assembled_range(0) ==
+        std::pair<std::size_t, std::size_t>{2, 6});
+}
+
 TEST_CASE("dryrun nested result uses moment-aware inner extent, not extent^k",
           "[dryrun-nested]") {
   auto r = backend_test_regime();

From 02be8b096d2caa9a705c28f4a1465f349e5421fb Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Tue, 7 Jul 2026 23:37:06 -0400
Subject: [PATCH 63/78] eval result: TiledArray write_into_slice;
 numeric-invariance vs whole array

---
 .../core/eval/backends/tiledarray/result.hpp  | 144 ++++++++++++++----
 tests/unit/test_eval_ta.cpp                   | 126 +++++++++++++++
 2 files changed, 238 insertions(+), 32 deletions(-)

diff --git a/SeQuant/core/eval/backends/tiledarray/result.hpp b/SeQuant/core/eval/backends/tiledarray/result.hpp
index 6c640cf1cc..d1626cfbab 100644
--- a/SeQuant/core/eval/backends/tiledarray/result.hpp
+++ b/SeQuant/core/eval/backends/tiledarray/result.hpp
@@ -329,6 +329,27 @@ template <typename LArrayT, typename RArrayT>
   return TA::TiledRange(dims.begin(), dims.end());
 }
 
+/// Map a contiguous element range `[elem_lo, elem_hi)` on a mode's TiledRange1
+/// to the tile range `[tile_lo, tile_hi)` it must coincide with. A tiled
+/// backend can only cut or scatter whole tiles, so the element bounds must be
+/// in-range and fall on tile boundaries; this asserts both (mode_batches()
+/// yields exactly such tile-aligned ranges). Shared by slice_mode() (GATHER a
+/// block out) and write_into_slice() (SCATTER a block in) so both agree on the
+/// element-to-tile contract and its alignment preconditions.
+[[nodiscard]] inline std::pair<std::size_t, std::size_t> slice_bounds_to_tiles(
+    TA::TiledRange1 const& tr1, std::size_t elem_lo, std::size_t elem_hi) {
+  SEQUANT_ASSERT(elem_lo >= tr1.elements_range().first && elem_lo < elem_hi &&
+                 elem_hi <= tr1.elements_range().second);
+  std::size_t const tile_lo = tr1.element_to_tile(elem_lo);
+  SEQUANT_ASSERT(tr1.tile(tile_lo).first == elem_lo);  // lo on a tile boundary
+  std::size_t const tile_hi = (elem_hi >= tr1.elements_range().second)
+                                  ? tr1.tile_extent()
+                                  : tr1.element_to_tile(elem_hi);
+  SEQUANT_ASSERT(elem_hi >= tr1.elements_range().second ||
+                 tr1.tile(tile_hi).first == elem_hi);  // hi on a tile boundary
+  return {tile_lo, tile_hi};
+}
+
 }  // namespace detail
 
 /// TA::Tensor memory use logger
@@ -353,6 +374,14 @@ template <typename... Args>
     TA::DistArray<Args...> const& arr, std::size_t mode, std::size_t tile_lo,
     std::size_t tile_hi);
 
+// defined below; declared here so the result classes' write_into_slice()
+// overrides can call it. The scatter inverse of slice_array_over_mode().
+template <typename... Args>
+void write_array_into_mode(TA::DistArray<Args...>& dest,
+                           TA::DistArray<Args...> const& block,
+                           std::size_t mode, std::size_t tile_lo,
+                           std::size_t tile_hi);
+
 /// Partition a TiledRange1 into contiguous, tile-aligned element-range batches,
 /// each covering at most \p target_batch_size elements: whole tiles are
 /// appended to a batch until the next tile would push it over the target, so \p
@@ -434,22 +463,8 @@ class ResultTensorTA final : public Result {
 
   [[nodiscard]] ResultPtr slice_mode(std::size_t mode, std::size_t elem_lo,
                                      std::size_t elem_hi) const override {
-    auto const& tr1 = get<ArrayT>().trange().dim(mode);
-    // slice_mode takes element bounds, but a tiled backend can only cut on tile
-    // boundaries; mode_batches() returns exactly such (tile-aligned, in-range)
-    // bounds. Assert the precondition so misuse is caught rather than silently
-    // producing an over- or under-sized slice (which would break batched sums).
-    SEQUANT_ASSERT(elem_lo >= tr1.elements_range().first && elem_lo < elem_hi &&
-                   elem_hi <= tr1.elements_range().second);
-    std::size_t const tile_lo = tr1.element_to_tile(elem_lo);
-    SEQUANT_ASSERT(tr1.tile(tile_lo).first ==
-                   elem_lo);  // lo on a tile boundary
-    std::size_t const tile_hi = (elem_hi >= tr1.elements_range().second)
-                                    ? tr1.tile_extent()
-                                    : tr1.element_to_tile(elem_hi);
-    SEQUANT_ASSERT(elem_hi >= tr1.elements_range().second ||
-                   tr1.tile(tile_hi).first ==
-                       elem_hi);  // hi on a tile boundary
+    auto const [tile_lo, tile_hi] = detail::slice_bounds_to_tiles(
+        get<ArrayT>().trange().dim(mode), elem_lo, elem_hi);
     return eval_result<this_type>(
         slice_array_over_mode(get<ArrayT>(), mode, tile_lo, tile_hi));
   }
@@ -460,6 +475,15 @@ class ResultTensorTA final : public Result {
                                    target_batch_size);
   }
 
+  void write_into_slice(Result const& block, std::size_t mode,
+                        std::size_t block_lo, std::size_t block_hi) override {
+    SEQUANT_ASSERT(block.is<this_type>());
+    auto& dest = get<ArrayT>();
+    auto const [tile_lo, tile_hi] = detail::slice_bounds_to_tiles(
+        dest.trange().dim(mode), block_lo, block_hi);
+    write_array_into_mode(dest, block.get<ArrayT>(), mode, tile_lo, tile_hi);
+  }
+
   [[nodiscard]] ResultPtr prod(Result const& other,
                                std::array<std::any, 3> const& annot,
                                DeNest DeNestFlag) const override {
@@ -639,22 +663,8 @@ class ResultTensorOfTensorTA final : public Result {
 
   [[nodiscard]] ResultPtr slice_mode(std::size_t mode, std::size_t elem_lo,
                                      std::size_t elem_hi) const override {
-    auto const& tr1 = get<ArrayT>().trange().dim(mode);
-    // slice_mode takes element bounds, but a tiled backend can only cut on tile
-    // boundaries; mode_batches() returns exactly such (tile-aligned, in-range)
-    // bounds. Assert the precondition so misuse is caught rather than silently
-    // producing an over- or under-sized slice (which would break batched sums).
-    SEQUANT_ASSERT(elem_lo >= tr1.elements_range().first && elem_lo < elem_hi &&
-                   elem_hi <= tr1.elements_range().second);
-    std::size_t const tile_lo = tr1.element_to_tile(elem_lo);
-    SEQUANT_ASSERT(tr1.tile(tile_lo).first ==
-                   elem_lo);  // lo on a tile boundary
-    std::size_t const tile_hi = (elem_hi >= tr1.elements_range().second)
-                                    ? tr1.tile_extent()
-                                    : tr1.element_to_tile(elem_hi);
-    SEQUANT_ASSERT(elem_hi >= tr1.elements_range().second ||
-                   tr1.tile(tile_hi).first ==
-                       elem_hi);  // hi on a tile boundary
+    auto const [tile_lo, tile_hi] = detail::slice_bounds_to_tiles(
+        get<ArrayT>().trange().dim(mode), elem_lo, elem_hi);
     return eval_result<this_type>(
         slice_array_over_mode(get<ArrayT>(), mode, tile_lo, tile_hi));
   }
@@ -665,6 +675,15 @@ class ResultTensorOfTensorTA final : public Result {
                                    target_batch_size);
   }
 
+  void write_into_slice(Result const& block, std::size_t mode,
+                        std::size_t block_lo, std::size_t block_hi) override {
+    SEQUANT_ASSERT(block.is<this_type>());
+    auto& dest = get<ArrayT>();
+    auto const [tile_lo, tile_hi] = detail::slice_bounds_to_tiles(
+        dest.trange().dim(mode), block_lo, block_hi);
+    write_array_into_mode(dest, block.get<ArrayT>(), mode, tile_lo, tile_hi);
+  }
+
   [[nodiscard]] ResultPtr prod(Result const& other,
                                std::array<std::any, 3> const& annot,
                                DeNest DeNestFlag) const override {
@@ -889,6 +908,67 @@ template <typename... Args>
   return out;
 }
 
+/// \brief Scatter a per-block DistArray into a contiguous tile range of one
+///        mode of a pre-sized destination -- the inverse of
+///        slice_array_over_mode().
+///
+/// Writes \p block into tiles `[tile_lo, tile_hi)` of \p dest's mode \p mode,
+/// leaving every other tile of \p dest untouched. \p dest must already be
+/// allocated over its full TiledRange (the caller sizes the whole shape), and
+/// \p block's TiledRange must equal \p dest's sub-block over `[tile_lo,
+/// tile_hi)` (as produced by slice_array_over_mode() for the same mode/range).
+/// Implemented with TA's block() on the assignment LHS, so only the addressed
+/// sub-block is written and block-sparse shape is preserved. Every mode's
+/// element lobound is preserved (via TA's `preserve_lobound`), exactly as the
+/// lobound-preserving GATHER in slice_array_over_mode(): the destination
+/// sub-block and the source share element coordinates, so a spectator index
+/// carrying a nonzero lobound (e.g. a frozen-core offset) lands at its true
+/// offset rather than being rebased to 0. Reconstructs a whole result from a
+/// disjoint, gap-free tiling of one mode: scattering each block of a partition
+/// reproduces the array `slice_array_over_mode()` would gather back out.
+template <typename... Args>
+void write_array_into_mode(TA::DistArray<Args...>& dest,
+                           TA::DistArray<Args...> const& block,
+                           std::size_t mode, std::size_t tile_lo,
+                           std::size_t tile_hi) {
+  using ranges::views::iota;
+  auto const rank = dest.trange().rank();
+  SEQUANT_ASSERT(mode < rank);
+  SEQUANT_ASSERT(tile_lo < tile_hi &&
+                 tile_hi <= dest.trange().dim(mode).tile_extent());
+  container::svector<std::size_t> lo(rank, 0), hi(rank);
+  for (std::size_t d = 0; d < rank; ++d)
+    hi[d] = dest.trange().dim(d).tile_extent();
+  lo[mode] = tile_lo;
+  hi[mode] = tile_hi;
+  // For a tensor-of-tensor array the annotation must label an inner block
+  // ("outer;inner"); a flat annotation trips DistArray's is_tot_index() check.
+  // The block() is over outer modes only, so both sides share one annotation.
+  using value_type = typename TA::DistArray<Args...>::value_type;
+  std::string annot;
+  if constexpr (TA::detail::is_tensor_of_tensor_v<value_type>) {
+    auto const inner_rank = detail::tot_inner_rank(block);
+    if (inner_rank == 0) {
+      // block has all-empty inner tiles (tot_inner_rank() == 0): it represents
+      // zero and there is no inner rank to form the ToT annotation block()
+      // needs. A zero contribution leaves the pre-sized destination slice as
+      // it was, so skip the scatter entirely -- mirroring the zero-ToT early
+      // return in slice_array_over_mode().
+      return;
+    }
+    annot = TA::detail::dummy_annotation(static_cast<unsigned int>(rank),
+                                         static_cast<unsigned int>(inner_rank));
+  } else {
+    annot = detail::ords_to_annot(iota(std::size_t{0}, rank));
+  }
+  // preserve_lobound: address the destination sub-block in its original element
+  // coordinates (keeping every mode's lobound) so it matches the source block,
+  // which slice_array_over_mode() also gathered with preserve_lobound. Plain
+  // block() would rebase the sub-block to 0 and mismatch the source trange.
+  dest(annot).block(lo, hi, TA::preserve_lobound) = block(annot);
+  TA::DistArray<Args...>::wait_for_lazy_cleanup(dest.world());
+}
+
 /// \brief Compute the result's OUTER TiledRange for a binary product from the
 ///        type-erased operands and the [left, right, result] annotations.
 ///
diff --git a/tests/unit/test_eval_ta.cpp b/tests/unit/test_eval_ta.cpp
index f931d0bad5..f3161f9f9d 100644
--- a/tests/unit/test_eval_ta.cpp
+++ b/tests/unit/test_eval_ta.cpp
@@ -1680,6 +1680,132 @@ TEST_CASE("eval_slice_array_over_mode", "[eval]") {
   }
 }
 
+// Numeric-invariance for Result::write_into_slice on the TA backend: the union
+// of disjoint, tile-aligned blocks scattered into a pre-sized destination must
+// reconstruct the whole array EXACTLY. write_into_slice() is the inverse of
+// slice_array_over_mode() (which GATHERS a block out): here we gather disjoint
+// blocks of a whole array R and scatter each back into a fresh, pre-sized
+// destination, then require the reassembled destination == R elementwise.
+TEST_CASE("eval_write_into_slice", "[eval]") {
+  using sequant::eval_result;
+  using sequant::ResultPtr;
+  using sequant::ResultTensorOfTensorTA;
+  using sequant::ResultTensorTA;
+  using sequant::slice_array_over_mode;
+  auto& world = TA::get_default_world();
+
+  SECTION("flat: disjoint tile-aligned blocks reassemble exactly") {
+    // mode 0 has 3 multi-element tiles (size 3 each; occ_tile_size>1 analog),
+    // mode 1 a single tile. Split mode 0 into element ranges [0,3) and [3,9)
+    // (tiles [0,1) and [1,3)): disjoint, tile-aligned, and tile-SPANNING.
+    TA::TArrayD R(world, TA::TiledRange{{0, 3, 6, 9}, {0, 5}});
+    R.fill_random();
+    world.gop.fence();
+
+    auto const b0 = slice_array_over_mode(R, 0, 0, 1);  // elements [0,3)
+    auto const b1 = slice_array_over_mode(R, 0, 1, 3);  // elements [3,9)
+
+    // destination pre-sized to R's full shape, then filled block by block.
+    TA::TArrayD dest(world, R.trange());
+    dest.fill_local(0.0);
+    world.gop.fence();
+
+    auto rdest = eval_result<ResultTensorTA<TA::TArrayD>>(dest);
+    rdest->write_into_slice(*eval_result<ResultTensorTA<TA::TArrayD>>(b0), 0, 0,
+                            3);
+    rdest->write_into_slice(*eval_result<ResultTensorTA<TA::TArrayD>>(b1), 0, 3,
+                            9);
+
+    REQUIRE(equal_tarrays<Tight>(rdest->get<TA::TArrayD>(), R));
+  }
+
+  SECTION("flat: nonzero element lobound (frozen-core offset) is preserved") {
+    // mode 0 has element lobound 2 (a frozen-core-like offset) and two size-3
+    // tiles; split into [2,5) and [5,8). The block bounds honor the lobound.
+    TA::TArrayD R(world, TA::TiledRange{{2, 5, 8}, {0, 4}});
+    R.fill_random();
+    world.gop.fence();
+
+    auto const b0 = slice_array_over_mode(R, 0, 0, 1);  // elements [2,5)
+    auto const b1 = slice_array_over_mode(R, 0, 1, 2);  // elements [5,8)
+    // the gathered blocks keep the source element lobound
+    REQUIRE(b0.trange().dim(0).elements_range().first == 2);
+
+    TA::TArrayD dest(world, R.trange());
+    dest.fill_local(0.0);
+    world.gop.fence();
+
+    auto rdest = eval_result<ResultTensorTA<TA::TArrayD>>(dest);
+    rdest->write_into_slice(*eval_result<ResultTensorTA<TA::TArrayD>>(b0), 0, 2,
+                            5);
+    rdest->write_into_slice(*eval_result<ResultTensorTA<TA::TArrayD>>(b1), 0, 5,
+                            8);
+
+    auto const& out = rdest->get<TA::TArrayD>();
+    REQUIRE(out.trange().dim(0).elements_range().first == 2);  // lobound kept
+    REQUIRE(equal_tarrays<Tight>(out, R));
+  }
+
+  SECTION("tot: disjoint tile-aligned blocks reassemble exactly") {
+    using ToTArray = TA::DistArray<TA::Tensor<TA::Tensor<double>>>;
+    using ResultToT = ResultTensorOfTensorTA<ToTArray>;
+
+    // outer mode 0: two size-3 tiles (multi-element, tile-spanning split);
+    // outer mode 1: one size-2 tile. Inner tensors are 2x2. Inner values are
+    // position-dependent (derived from the outer coordinate) so a mis-scattered
+    // block -- wrong offset -- would change the reassembled norm.
+    TA::TiledRange const outer_tr{{0, 3, 6}, {0, 2}};
+    TA::Range const inner_r(std::array<std::size_t, 2>{2, 2});
+
+    auto build = [&world, inner_r](TA::TiledRange const& otr,
+                                   bool zero) -> ToTArray {
+      auto tile_fn = [inner_r, zero](TA::Range const& orng) {
+        TA::Tensor<TA::Tensor<double>> t{orng};
+        std::size_t o = 0;
+        for (auto const& coord : orng) {
+          auto& inner = t[o++];
+          inner = TA::Tensor<double>{inner_r};
+          double base = 0.0;
+          if (!zero)
+            for (auto c : coord)
+              base = base * 37.0 + static_cast<double>(c + 1);
+          std::size_t k = 0;
+          for (auto& x : inner) x = zero ? 0.0 : base * 100.0 + (++k);
+        }
+        return t;
+      };
+      ToTArray arr{world, otr};
+      for (auto it = arr.begin(); it != arr.end(); ++it)
+        if (arr.is_local(it.index()))
+          *it = world.taskq.add(tile_fn, it.make_range());
+      world.gop.fence();
+      return arr;
+    };
+
+    ToTArray R = build(outer_tr, /*zero=*/false);
+
+    auto const b0 = slice_array_over_mode(R, 0, 0, 1);  // outer elements [0,3)
+    auto const b1 = slice_array_over_mode(R, 0, 1, 2);  // outer elements [3,6)
+
+    // destination pre-sized to R's full shape with well-formed (zero) inners.
+    ToTArray dest = build(outer_tr, /*zero=*/true);
+
+    auto rdest = eval_result<ResultToT>(dest);
+    rdest->write_into_slice(*eval_result<ResultToT>(b0), 0, 0, 3);
+    rdest->write_into_slice(*eval_result<ResultToT>(b1), 0, 3, 6);
+
+    // ToT elementwise invariance: norm of the difference (dot of the diff with
+    // itself) must vanish. TA::norm2 does not support ToT tiles, so use dot.
+    auto const& out = rdest->get<ToTArray>();
+    ToTArray diff;
+    diff("i,j;a,b") = out("i,j;a,b") - R("i,j;a,b");
+    REQUIRE(Catch::Approx(diff("i,j;a,b").dot(diff("i,j;a,b"))) == 0.0);
+    // and the reassembled result is nonzero (guards against a trivial all-zero
+    // pass, e.g. if both blocks silently no-op'd).
+    REQUIRE(out("i,j;a,b").dot(out("i,j;a,b")) > 0.0);
+  }
+}
+
 TEST_CASE("eval_batched_custom_evaluator", "[eval]") {
   using sequant::evaluate;
   using sequant::make_batched_custom_evaluator;

From d18ccb7e0c5186fa1c29b7502624d42d997eb1cf Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Wed, 8 Jul 2026 06:20:58 -0400
Subject: [PATCH 64/78] eval_expr: outer_proto_position accessor for proto-only
 spectator slicing

---
 SeQuant/core/eval/eval_expr.cpp | 21 +++++++++++
 SeQuant/core/eval/eval_expr.hpp | 28 ++++++++++++++
 tests/unit/test_eval_expr.cpp   | 65 +++++++++++++++++++++++++++++++++
 3 files changed, 114 insertions(+)

diff --git a/SeQuant/core/eval/eval_expr.cpp b/SeQuant/core/eval/eval_expr.cpp
index 36edcda918..34940bcf88 100644
--- a/SeQuant/core/eval/eval_expr.cpp
+++ b/SeQuant/core/eval/eval_expr.cpp
@@ -133,6 +133,27 @@ EvalExpr::index_vector const& EvalExpr::canon_indices() const noexcept {
   return canon_indices_;
 }
 
+std::optional<std::size_t> outer_proto_position(EvalExpr const& node,
+                                                Index const& ix) {
+  // Enumerate the node's distinct outer protoindices in canonical order: walk
+  // canon_indices() (already canonical -- no re-canonicalization here) and, for
+  // each composite (proto-bearing) leg, append its proto_indices() that have
+  // not been seen yet, preserving the order of first appearance. That
+  // deduplicated sequence is the outer-mode order of the tensor-of-tensor
+  // array, so the match position is the `mode` argument slice_mode() addresses.
+  container::svector<Index> distinct;
+  for (auto const& leg : node.canon_indices()) {
+    if (!leg.has_proto_indices()) continue;
+    for (auto const& proto : leg.proto_indices())
+      if (std::ranges::find(distinct, proto) == distinct.end())
+        distinct.push_back(proto);
+  }
+
+  for (std::size_t p = 0; p < distinct.size(); ++p)
+    if (distinct[p] == ix) return p;
+  return std::nullopt;
+}
+
 EvalExpr::EvalExpr(Tensor const& tnsr)
     : op_type_{std::nullopt},
       result_type_{ResultType::Tensor},
diff --git a/SeQuant/core/eval/eval_expr.hpp b/SeQuant/core/eval/eval_expr.hpp
index 628458a41d..8932a2db99 100644
--- a/SeQuant/core/eval/eval_expr.hpp
+++ b/SeQuant/core/eval/eval_expr.hpp
@@ -312,6 +312,34 @@ struct EvalOpSetter {
   void reset(EvalExpr& expr) { expr.op_type_ = std::nullopt; }
 };
 
+///
+/// \brief Position of \p ix among \p node's distinct outer protoindices, in
+///        canonical order, or nullopt if \p ix is not one of them.
+///
+/// \details Proto-aware sibling of \c index_position (which scans top-level
+///          canonical slots only). A spectator index can appear on a node
+///          exclusively as a protoindex of composite (CSV/PNO/OSV) legs like
+///          `a<i,j>`, with no top-level slot in \c canon_indices() -- so
+///          \c index_position misses it. For such a tensor-of-tensor node the
+///          array's OUTER modes are precisely the distinct protoindices of its
+///          composite legs, in canonical order; that is the position
+///          \c Result::slice_mode()/\c write_into_slice() address as their
+///          `mode` argument.
+///
+///          The distinct outer protoindices are enumerated by walking
+///          \c canon_indices() (whose order is already canonical -- this does
+///          NOT rerun slot canonicalization), collecting the \c proto_indices()
+///          of each composite leg, and deduplicating while preserving the
+///          canonical order of first appearance. The returned position indexes
+///          that deduplicated sequence.
+///
+/// \param node A (typically tensor-of-tensor) EvalExpr node.
+/// \param ix   The index to locate among \p node's distinct outer protos.
+/// \return The 0-based outer-mode position of \p ix, or nullopt if absent.
+///
+[[nodiscard]] std::optional<std::size_t> outer_proto_position(
+    EvalExpr const& node, Index const& ix);
+
 struct BinarizationOptions {
   /// Whether to merge indices of intermediate tensors into a single list
   /// (stored as aux indices) instead of retaining the bra, ket and aux
diff --git a/tests/unit/test_eval_expr.cpp b/tests/unit/test_eval_expr.cpp
index 4d8339404f..52e6ce6214 100644
--- a/tests/unit/test_eval_expr.cpp
+++ b/tests/unit/test_eval_expr.cpp
@@ -12,8 +12,10 @@
 #include <SeQuant/core/tensor_canonicalizer.hpp>
 #include <SeQuant/core/utility/macros.hpp>
 
+#include <algorithm>
 #include <initializer_list>
 #include <memory>
+#include <optional>
 #include <set>
 #include <string>
 #include <string_view>
@@ -533,3 +535,66 @@ TEST_CASE("eval_expr", "[EvalExpr]") {
     REQUIRE_NOTHROW(result_expr(t1, t2, EvalOp::Product));
   }
 }
+
+TEST_CASE("eval_expr_outer_proto_position",
+          "[EvalExpr][outer-proto-position]") {
+  using namespace sequant;
+
+  // A proto-only spectator node: both legs are PNO-like composites
+  // a_1<i_1,i_2> and a_2<i_1,i_2> that share the occ protos i_1, i_2. The occ
+  // indices appear ONLY as protoindices; there is no top-level occ slot. Yet
+  // the tensor-of-tensor array's outer modes are exactly these distinct protos,
+  // in canonical order, which is what slice_mode()/write_into_slice() address.
+  //
+  // Build the node directly via the low-level EvalExpr ctor with canon_indices
+  // = the two composite legs, mirroring a real contraction intermediate (e.g.
+  // the PPL residual W) whose proto-only externals are dropped from the result
+  // slots by binarize (target_indices, eval_expr.cpp). The leaf ctor is NOT
+  // used here: its per-tensor slot canonicalization promotes the shared protos
+  // to top-level named slots, which is not the proto-only shape under test.
+  auto const tnsr = parse_tensor(L"W{a_1<i_1,i_2>;a_2<i_1,i_2>}",
+                                 {.def_perm_symm = Symmetry::Nonsymm});
+  EvalExpr::index_vector composite_legs;
+  for (auto const& ix : tnsr.const_indices())
+    if (ix.has_proto_indices()) composite_legs.push_back(ix);
+  EvalExpr const node{EvalOp::Product,
+                      ResultType::Tensor,
+                      tnsr.clone(),
+                      composite_legs,  //
+                      /*phase=*/1,     //
+                      /*hash=*/0,      //
+                      /*connectivity=*/nullptr};
+
+  // The node is a tensor-of-tensor whose canonical legs are all composite (they
+  // each carry proto indices) -- so there is no top-level plain occ slot.
+  REQUIRE(node.tot());
+  auto const& legs = node.canon_indices();
+  REQUIRE(legs.size() == 2);
+  REQUIRE(std::all_of(legs.begin(), legs.end(),
+                      [](Index const& ix) { return ix.has_proto_indices(); }));
+
+  // The occ protos, in the order they appear on a leg == their canonical outer
+  // order (both legs share the same, canonicalized, proto list).
+  Index const i1 = legs.front().proto_indices().front();
+  Index const i2 = legs.front().proto_indices().back();
+  REQUIRE(i1 != i2);
+
+  // Distinct outer protos in canonical order: {i1, i2} -> positions 0, 1.
+  auto const p1 = outer_proto_position(node, i1);
+  REQUIRE(p1.has_value());
+  REQUIRE(*p1 == 0);
+
+  auto const p2 = outer_proto_position(node, i2);
+  REQUIRE(p2.has_value());
+  REQUIRE(*p2 == 1);
+
+  // An index that is not one of the node's outer protos -> nullopt.
+  Index const absent{L"i_5"};
+  REQUIRE_FALSE(outer_proto_position(node, absent).has_value());
+
+  // The occ proto has no top-level slot: it does not appear as a top-level
+  // entry of canon_indices() (the proto-only property that makes index_position
+  // -- which scans top-level slots only -- miss it).
+  REQUIRE(std::none_of(legs.begin(), legs.end(),
+                       [&](Index const& ix) { return ix == i1; }));
+}

From 8f3eee3097e38a5a2e70ffbd3c621f28c00dded1 Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Wed, 8 Jul 2026 06:37:55 -0400
Subject: [PATCH 65/78] eval_expr: guard outer_proto_position against mixed
 (plain+proto) outer nodes

---
 SeQuant/core/eval/eval_expr.cpp | 11 ++++++++
 SeQuant/core/eval/eval_expr.hpp | 30 ++++++++++++++++----
 tests/unit/test_eval_expr.cpp   | 49 +++++++++++++++++++++++++++++++++
 3 files changed, 84 insertions(+), 6 deletions(-)

diff --git a/SeQuant/core/eval/eval_expr.cpp b/SeQuant/core/eval/eval_expr.cpp
index 34940bcf88..a4faf42292 100644
--- a/SeQuant/core/eval/eval_expr.cpp
+++ b/SeQuant/core/eval/eval_expr.cpp
@@ -135,6 +135,17 @@ EvalExpr::index_vector const& EvalExpr::canon_indices() const noexcept {
 
 std::optional<std::size_t> outer_proto_position(EvalExpr const& node,
                                                 Index const& ix) {
+  // Precondition: node has no plain (non-proto) outer mode -- every leg of
+  // canon_indices() must carry proto indices. On a MIXED node (plain outer
+  // index alongside proto outer modes) the "position among distinct protos"
+  // computed below does not correspond to the physical ToT outer-trange
+  // position that slice_mode()/write_into_slice() address, so fail loudly
+  // here instead of silently returning a wrong mode. See the \warning on the
+  // declaration in eval_expr.hpp.
+  SEQUANT_ASSERT(std::ranges::all_of(
+      node.canon_indices(),
+      [](Index const& leg) { return leg.has_proto_indices(); }));
+
   // Enumerate the node's distinct outer protoindices in canonical order: walk
   // canon_indices() (already canonical -- no re-canonicalization here) and, for
   // each composite (proto-bearing) leg, append its proto_indices() that have
diff --git a/SeQuant/core/eval/eval_expr.hpp b/SeQuant/core/eval/eval_expr.hpp
index 8932a2db99..8d9c7c55ff 100644
--- a/SeQuant/core/eval/eval_expr.hpp
+++ b/SeQuant/core/eval/eval_expr.hpp
@@ -320,11 +320,12 @@ struct EvalOpSetter {
 ///          canonical slots only). A spectator index can appear on a node
 ///          exclusively as a protoindex of composite (CSV/PNO/OSV) legs like
 ///          `a<i,j>`, with no top-level slot in \c canon_indices() -- so
-///          \c index_position misses it. For such a tensor-of-tensor node the
-///          array's OUTER modes are precisely the distinct protoindices of its
-///          composite legs, in canonical order; that is the position
-///          \c Result::slice_mode()/\c write_into_slice() address as their
-///          `mode` argument.
+///          \c index_position misses it. For a PROTO-ONLY node (every leg of
+///          \c canon_indices() is composite, e.g. the PPL residual W) the
+///          tensor-of-tensor array's OUTER modes are precisely the distinct
+///          protoindices of its composite legs, in canonical order; that is
+///          the position \c Result::slice_mode()/\c write_into_slice() address
+///          as their `mode` argument.
 ///
 ///          The distinct outer protoindices are enumerated by walking
 ///          \c canon_indices() (whose order is already canonical -- this does
@@ -333,7 +334,24 @@ struct EvalOpSetter {
 ///          canonical order of first appearance. The returned position indexes
 ///          that deduplicated sequence.
 ///
-/// \param node A (typically tensor-of-tensor) EvalExpr node.
+/// \pre Every index in \p node.canon_indices() carries proto indices (i.e.
+///      \p node has no plain, non-proto outer mode). Violating this aborts
+///      (via \c SEQUANT_ASSERT) rather than returning a silently wrong
+///      position.
+///
+/// \warning On a MIXED node -- one that carries both a plain non-proto
+///          top-level outer index and proto outer modes -- the "position
+///          among distinct protos" computed here does NOT correspond to the
+///          physical ToT outer-trange position that \c slice_mode() addresses
+///          (the plain outer index also occupies an outer trange mode, but is
+///          not counted by this function). Computing the correct physical
+///          position for a mixed node requires interleaving the plain and
+///          proto outer modes in their true trange order, which this
+///          function does not attempt; such callers must not use this
+///          accessor as-is.
+///
+/// \param node A (typically tensor-of-tensor) EvalExpr node with no plain
+///             (non-proto) outer modes; see \pre.
 /// \param ix   The index to locate among \p node's distinct outer protos.
 /// \return The 0-based outer-mode position of \p ix, or nullopt if absent.
 ///
diff --git a/tests/unit/test_eval_expr.cpp b/tests/unit/test_eval_expr.cpp
index 52e6ce6214..bfa79a0a44 100644
--- a/tests/unit/test_eval_expr.cpp
+++ b/tests/unit/test_eval_expr.cpp
@@ -598,3 +598,52 @@ TEST_CASE("eval_expr_outer_proto_position",
   REQUIRE(std::none_of(legs.begin(), legs.end(),
                        [&](Index const& ix) { return ix == i1; }));
 }
+
+TEST_CASE("eval_expr_outer_proto_position_mixed_node_guard",
+          "[EvalExpr][outer-proto-position]") {
+  using namespace sequant;
+
+  // A MIXED node: one plain (non-proto) top-level outer index p_1 alongside a
+  // composite proto-bearing leg a_1<i_1,i_2>. Unlike the proto-only node
+  // above, here "position among distinct protos" does not correspond to the
+  // node's physical ToT outer-trange position (the plain leg p_1 also
+  // occupies an outer trange mode, uncounted by outer_proto_position), so the
+  // accessor must refuse to answer instead of silently mis-slicing. Built via
+  // the same low-level EvalExpr ctor technique as the proto-only case, but
+  // keeping BOTH legs (not filtering to composites only) so canon_indices()
+  // actually mixes a plain index with a proto-bearing one.
+  auto const tnsr = parse_tensor(L"W{p_1;a_1<i_1,i_2>}",
+                                 {.def_perm_symm = Symmetry::Nonsymm});
+  EvalExpr::index_vector mixed_legs;
+  for (auto const& ix : tnsr.const_indices()) mixed_legs.push_back(ix);
+  EvalExpr const node{EvalOp::Product,
+                      ResultType::Tensor,
+                      tnsr.clone(),
+                      mixed_legs,   //
+                      /*phase=*/1,  //
+                      /*hash=*/0,   //
+                      /*connectivity=*/nullptr};
+
+  auto const& legs = node.canon_indices();
+  REQUIRE(legs.size() == 2);
+
+  // Confirm this is genuinely mixed: NOT all legs carry proto indices (that
+  // is precisely the precondition outer_proto_position's guard checks).
+  bool const all_have_protos =
+      std::all_of(legs.begin(), legs.end(),
+                  [](Index const& ix) { return ix.has_proto_indices(); });
+  REQUIRE_FALSE(all_have_protos);
+
+  Index const i1 = [&] {
+    for (auto const& ix : legs)
+      if (ix.has_proto_indices()) return ix.proto_indices().front();
+    throw std::logic_error("no proto-bearing leg found");
+  }();
+
+  // Misuse on a mixed node must fail loudly (SEQUANT_ASSERT throws in this
+  // build, SEQUANT_ASSERT_BEHAVIOR=THROW) rather than silently returning a
+  // wrong outer-trange position.
+  if (sequant::assert_behavior() == sequant::AssertBehavior::Throw) {
+    REQUIRE_THROWS_AS(outer_proto_position(node, i1), sequant::Exception);
+  }
+}

From b50a4d21720afbb704b030dc75d40eb12e04cb05 Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Wed, 8 Jul 2026 08:19:02 -0400
Subject: [PATCH 66/78] eval: forest evaluation over a free/spectator external
 axis (core spine)

---
 SeQuant/core/eval/eval.hpp  | 151 ++++++++++++++++++++++++++++++++++++
 tests/unit/test_eval_ta.cpp | 125 +++++++++++++++++++++++++++++
 2 files changed, 276 insertions(+)

diff --git a/SeQuant/core/eval/eval.hpp b/SeQuant/core/eval/eval.hpp
index 1c5d1ea649..d29cda8bde 100644
--- a/SeQuant/core/eval/eval.hpp
+++ b/SeQuant/core/eval/eval.hpp
@@ -12,6 +12,7 @@
 #include <SeQuant/core/io/serialization/serialization.hpp>
 #include <SeQuant/core/logger.hpp>
 #include <SeQuant/core/meta.hpp>
+#include <SeQuant/core/optimize/optimize.hpp>
 #include <SeQuant/core/utility/macros.hpp>
 #include <SeQuant/core/utility/string.hpp>
 
@@ -1615,6 +1616,156 @@ template <class F, class ScopeGuardFactory = make_no_scope_guard>
       policy.persistent_only, /*depth=*/0, peak);
 }
 
+/// \brief Position of the spectator external axis \p axis among a node's OUTER
+/// modes, or nullopt if the node does not carry it.
+///
+/// A spectator external index can occupy a node's outer modes in two ways: as a
+/// plain top-level slot of \c canon_indices() (\c index_position), or -- on a
+/// proto-only tensor-of-tensor node whose legs are all composite (CSV/PNO/OSV),
+/// where the axis appears exclusively as a protoindex -- as one of the distinct
+/// outer protos (\c outer_proto_position). Either way the returned position is
+/// the physical outer-mode index that \c Result::slice_mode() and
+/// \c Result::write_into_slice() address as their \c mode argument.
+///
+/// \note On a MIXED node (a plain non-proto outer index NOT equal to \p axis,
+///       alongside composite proto legs) \c index_position(axis) misses, so
+///       this falls through to \c outer_proto_position, whose precondition
+///       assert fires -- a deliberate signal that the proto-only outer-mode
+///       computation does not model the true interleaved outer-trange position
+///       of a mixed node. The core external-occ spine slices only proto-only or
+///       plain-outer spectator nodes; a mixed spectator carrier requires
+///       upgrading the accessor to compute the interleaved physical position.
+template <typename Node>
+[[nodiscard]] std::optional<std::size_t> spectator_outer_mode(
+    Node const& node, Index const& axis) {
+  if (auto const p = index_position(node, axis)) return p;
+  return outer_proto_position(*node, axis);
+}
+
+/// \brief Co-evaluate a forest of residual summand trees one block of a
+/// free/spectator external axis at a time, on a single shared scratch cache,
+/// assembling each block into a pre-sized destination.
+///
+/// This is the free-axis / explicit-forest generalization of the batched-eval
+/// group/replay loop (\c make_batched_custom_evaluator). The differences:
+///
+///   - The batch axis is a Hadamard/spectator external index -- present on
+///     every operand and the result of every contraction on its path,
+///     contracted nowhere -- rather than a contracted axis. Because it is never
+///     contracted, it is not sliced node-locally by an in-tree custom evaluator
+///     (no node's DP `aprime` can carry it); it is sliced by seeding the outer
+///     block loop here and re-slicing every leaf that carries it per block.
+///   - The co-batched group is the EXPLICIT \p forest (the summands of the
+///     residual Sum), not a \c persistent()-gated cache scan, so volatile term
+///     roots are included.
+///   - The cross-batch combinator is \c Result::write_into_slice (PARTITION:
+///     the blocks are disjoint slices of \p dest), not \c add_inplace
+///     (ACCUMULATE, correct only for a contracted axis). Within a block the
+///     summands are still summed by \c add_inplace (they share the block's
+///     result layout); across blocks they are scattered into disjoint slices.
+///
+/// Per block: reset the shared scratch, evaluate every summand tree with every
+/// leaf carrying \p axis sliced to the block's element range
+/// (\c spectator_outer_mode -> \c slice_mode), sum the summands, and
+/// \c write_into_slice the summed block into \p dest's \p axis slice. Because
+/// the whole forest streams over the same block on ONE registered scratch,
+/// cross-term sub-intermediates (e.g. gC shared between summands) are built
+/// once per block and reused; the per-block reset drops the previous block's
+/// sliced partials while the registration (repeat structure) survives. Exact by
+/// `R = union_blocks R[block]` on the disjoint spectator partition, with each
+/// block itself an exact sum of its summands -- a memory schedule, never an
+/// approximation. Stays on the lazy path: each per-block \c evaluate is an
+/// ordinary decision-at-the-node traversal; \p t amplitudes stay resident in
+/// \p le.
+///
+/// \param forest        the residual summand trees (each already binarized).
+/// \param external_axis the spectator axis + per-block element extent (P1).
+/// \param shared_cache  a registered scratch cache over \p forest (typically
+///                      \c cache_manager(forest, ...)); reset() per block.
+/// \param le            the leaf evaluator (\p t stays resident here).
+/// \param dest          the pre-sized destination result (full spectator
+///                      extent); each block is scattered into its slice.
+/// \return the number of (non-empty) blocks processed (>= 1).
+template <Trace EvalTrace = Trace::Default, meta::can_evaluate_range Nodes,
+          typename F, typename N, bool FHC>
+  requires meta::leaf_node_evaluator<std::ranges::range_value_t<Nodes>, F>
+std::size_t evaluate_forest_over_external_axis(
+    Nodes const& forest, ExternalBatchAxis const& external_axis,
+    CacheManager<N, FHC>& shared_cache, F const& le, ResultPtr const& dest) {
+  using node_t = std::ranges::range_value_t<Nodes>;
+  SEQUANT_ASSERT(dest);
+  SEQUANT_ASSERT(std::ranges::begin(forest) != std::ranges::end(forest));
+  Index const& axis = external_axis.axis;
+
+  // The common block-result layout: the first summand's head annotation. Every
+  // summand of a residual shares the result's index layout, so all block
+  // partials permute to this and add_inplace into one accumulator.
+  auto const& head = *std::ranges::begin(forest);
+  auto const layout = head->annot();
+  // The destination outer mode of the spectator axis (the write_into_slice
+  // `mode` argument): the same for dest and every block partial.
+  auto const dest_mode = spectator_outer_mode(head, axis);
+  SEQUANT_ASSERT(dest_mode &&
+                 "forest head does not carry the external spectator axis");
+
+  // Learn the spectator axis's tiling from the first leaf (in any tree) that
+  // carries it, then partition it into tile-aligned element blocks. A leaf's
+  // result knows the axis's true trange (tiles, lobound), so the partition
+  // snaps to whole tiles and preserves a frozen-core element lobound.
+  auto find_carrier = [&axis](auto&& self, node_t const& n)
+      -> std::optional<std::pair<node_t, std::size_t>> {
+    if (n.leaf()) {
+      if (auto const p = spectator_outer_mode(n, axis)) return std::pair{n, *p};
+      return std::nullopt;
+    }
+    if (auto l = self(self, n.left())) return l;
+    return self(self, n.right());
+  };
+  std::optional<std::pair<node_t, std::size_t>> carrier;
+  for (auto const& tree : forest)
+    if ((carrier = find_carrier(find_carrier, tree))) break;
+  SEQUANT_ASSERT(carrier && "no leaf carries the external spectator axis");
+  auto const batches =
+      le(carrier->first)
+          ->mode_batches(carrier->second, external_axis.block_size);
+
+  std::size_t n_blocks = 0;
+  for (auto const& [e_lo, e_hi] : batches) {
+    if (e_lo == e_hi) continue;
+    ++n_blocks;
+    // Fresh block: the previous block's sliced partials are dropped, the
+    // registration (shared-subtree structure) survives, so a cross-term
+    // sub-intermediate is rebuilt once for this block and reused across the
+    // summands that share it.
+    shared_cache.reset();
+
+    // Leaf evaluator that slices every leaf carrying the spectator axis to this
+    // element block; other leaves pass through. `le` (with `t` resident) is the
+    // captured underlying evaluator.
+    auto le_block = [&le, &axis, e_lo = e_lo,
+                     e_hi = e_hi](node_t const& leaf) -> ResultPtr {
+      ResultPtr r = le(leaf);
+      if (auto const p = spectator_outer_mode(leaf, axis))
+        return r->slice_mode(*p, e_lo, e_hi);
+      return r;
+    };
+
+    ResultPtr block_acc;
+    for (auto const& tree : forest) {
+      ResultPtr part =
+          evaluate<EvalTrace>(tree, layout, le_block, shared_cache);
+      if (!block_acc)
+        block_acc = std::move(part);
+      else
+        block_acc->add_inplace(*part);
+    }
+    SEQUANT_ASSERT(block_acc);
+    dest->write_into_slice(*block_acc, *dest_mode, e_lo, e_hi);
+  }
+  SEQUANT_ASSERT(n_blocks >= 1);
+  return n_blocks;
+}
+
 }  // namespace sequant
 
 #endif  // SEQUANT_EVAL_EVAL_HPP
diff --git a/tests/unit/test_eval_ta.cpp b/tests/unit/test_eval_ta.cpp
index f3161f9f9d..fb54bcd380 100644
--- a/tests/unit/test_eval_ta.cpp
+++ b/tests/unit/test_eval_ta.cpp
@@ -3248,3 +3248,128 @@ TEST_CASE("shape_provider_denest_to_flat", "[shape-provider]") {
     REQUIRE(equal_tarrays(res, ref, "i,j"));
   }
 }
+
+// Task 8 (P3) crux-3 gate: numeric invariance of the free/spectator external
+// axis forest evaluator. A small forest of two summand trees shares an EXTERNAL
+// spectator occupied index i_1 (present -- as a composite protoindex -- on
+// every operand and result, contracted NOWHERE) and a cross-term
+// sub-intermediate S = g*h. Evaluated UNBATCHED (multi-root sum) it is the
+// reference R = F1 + F2. evaluate_forest_over_external_axis partitions i_1 into
+// blocks, co-evaluates the forest one block at a time on a shared scratch (S
+// built once per block, reused by both summands), sums the summands per block,
+// and write_into_slice's each block into the pre-sized destination. The
+// assembled destination must equal R ELEMENTWISE for every block size -- a
+// memory schedule, not an approximation. The occupied outer mode i_1 is
+// multi-tiled (occ_tile_size > 1) so blocks are tile-aligned multi-element
+// (and, for one size, tile-spanning).
+TEST_CASE("eval_forest_over_external_occ", "[eval][forest-external-occ]") {
+  using sequant::eval_result;
+  using sequant::evaluate;
+  using sequant::evaluate_forest_over_external_axis;
+  using sequant::ExternalBatchAxis;
+  using sequant::ResultPtr;
+  using node_t = sequant::FullBinaryNode<sequant::EvalExprTA>;
+
+  auto& world = TA::get_default_world();
+  // occ i_1 extent 6 in tiles of <= 2 -> 3 tiles (occ_tile_size == 2 > 1); the
+  // virtual (OSV) space extent 3 (single-occ protos a<i_1>).
+  rand_tensor_yield<double, TA::DensePolicy> yield{world, /*nocc=*/6,
+                                                   /*nvirt=*/3};
+  yield.set_max_tile(2);
+
+  using ArrayToT = typename decltype(yield)::array_tot_type;
+  using ResultToT = sequant::ResultTensorOfTensorTA<ArrayToT>;
+
+  // Two summand trees sharing S = g*h (a proto-only ToT carrying i_1 as its
+  // sole outer/spectator mode). Every leg is a single-occ OSV composite a<i_1>,
+  // so i_1 is a pure spectator: an outer Hadamard mode, contracted at no node.
+  // The contracted indices are the inner virtuals (a_2, a_4).
+  //   F1 = (g{a1<i1>;a2<i1>} * h{a2<i1>;a4<i1>}) * p{a4<i1>;a5<i1>}
+  //   F2 = (g{a1<i1>;a2<i1>} * h{a2<i1>;a4<i1>}) * r{a4<i1>;a5<i1>}
+  // Both produce {a1<i1>;a5<i1>}; R = F1 + F2.
+  auto const e1 = sequant::deserialize<sequant::ExprPtr>(
+      L"(g{a1<i1>;a2<i1>} * h{a2<i1>;a4<i1>}) * p{a4<i1>;a5<i1>}");
+  auto const e2 = sequant::deserialize<sequant::ExprPtr>(
+      L"(g{a1<i1>;a2<i1>} * h{a2<i1>;a4<i1>}) * r{a4<i1>;a5<i1>}");
+  auto const n1 = eval_node(e1);
+  auto const n2 = eval_node(e2);
+  std::vector<node_t> const forest{n1, n2};
+
+  // The spectator axis: i_1, extracted from a composite leg's protos (so the
+  // Index object exactly matches the parsed one). Also confirm proto-only
+  // shape.
+  sequant::Index axis;
+  for (auto const& leg : n1->canon_indices())
+    if (leg.has_proto_indices()) {
+      axis = leg.proto_indices()[0];
+      break;
+    }
+  REQUIRE(axis.nonnull());
+  REQUIRE(
+      axis.space() ==
+      sequant::get_default_context().index_space_registry()->retrieve(L"i"));
+  // Structural precondition: the shared sub-intermediate S = g*h repeats across
+  // the forest (cache_manager registers it with max_life 2), so a per-block
+  // shared scratch builds it once per block and reuses it across F1 and F2.
+  {
+    sequant::TreeNodeEqualityComparator<node_t> const eq;
+    REQUIRE(eq(n1.left(), n2.left()));  // both left children are S
+    auto cm = sequant::cache_manager(forest, 2);
+    REQUIRE(cm.max_life(n1.left()) == 2);
+  }
+  // The ToT annotation convention (NestedTensorIndices -> indices_annot) hoists
+  // the spectator's protoindex into a plain top-level outer slot of the TA
+  // node's canon_indices (so the "outer;inner" annotation can name it as an
+  // outer mode). So i_1 is addressed as outer mode 0 directly by
+  // index_position; the proto-only outer_proto_position fallback (Task 7) is
+  // not needed for these hoisted nodes and its mixed-node guard is never
+  // tripped (the spine consults index_position first). Calling
+  // outer_proto_position directly on this hoisted (mixed: plain i_1 + composite
+  // legs) node WOULD trip its proto-only precondition guard, which is exactly
+  // why the spine's spectator_outer_mode tries index_position first.
+  REQUIRE(sequant::index_position(n1, axis) == std::size_t{0});
+
+  // Unbatched reference R = F1 + F2 (each in the head's natural layout).
+  std::string const target = n1->annot();
+  ResultPtr ref = evaluate(n1, target, yield);
+  ref->add_inplace(*evaluate(n2, target, yield));
+  auto const& R = ref->get<ArrayToT>();
+  double const ref_dot = R(target).dot(R(target));
+  REQUIRE(ref_dot > 0.0);  // guard: reference is nontrivially nonzero
+
+  // block sizes (in elements of i_1, extent 6, tiles of 2):
+  //   1000 -> 1 block (no partition; the trivial schedule)
+  //   4    -> 2 blocks [0,4),[4,6) (first block SPANS two tiles)
+  //   2    -> 3 blocks [0,2),[2,4),[4,6) (one tile each)
+  for (std::size_t const block_size :
+       {std::size_t{1000}, std::size_t{4}, std::size_t{2}}) {
+    // Pre-sized, ZERO destination with R's exact ToT structure (R - R). A block
+    // that silently no-op'd would leave a zero region and fail the equality.
+    ArrayToT dest_arr;
+    dest_arr(target) = R(target) - R(target);
+    world.gop.fence();
+    auto dest = eval_result<ResultToT>(dest_arr);
+
+    // Fresh registered scratch per run (registration = the shared-subtree map;
+    // the evaluator reset()s alive values between blocks).
+    auto scratch = sequant::cache_manager(forest, 2);
+    ExternalBatchAxis const ext{axis, block_size};
+    auto const n_blocks =
+        evaluate_forest_over_external_axis(forest, ext, scratch, yield, dest);
+
+    // partition sanity: expected block counts for the tiling above.
+    std::size_t const expected_blocks =
+        (block_size >= 6) ? 1 : (block_size == 4 ? 2 : 3);
+    REQUIRE(n_blocks == expected_blocks);
+
+    // ELEMENTWISE numeric invariance: ||dest - R||^2 == 0 exactly (ToT norm via
+    // self-dot of the difference; TA::norm2 is unsupported for ToT tiles).
+    auto const& out = dest->get<ArrayToT>();
+    ArrayToT diff;
+    diff(target) = out(target) - R(target);
+    world.gop.fence();
+    REQUIRE(Catch::Approx(diff(target).dot(diff(target))).margin(1e-12) == 0.0);
+    // and the assembled result is nonzero (guards a trivial all-zero pass).
+    REQUIRE(out(target).dot(out(target)) == Catch::Approx(ref_dot));
+  }
+}

From 8940deef22303d78aa53d1d1200a64a1d0b76380 Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Wed, 8 Jul 2026 10:40:46 -0400
Subject: [PATCH 67/78] eval: nest intra-term batching inside the external-occ
 forest loop

---
 SeQuant/core/eval/eval.hpp  |  40 ++++++++-
 tests/unit/test_eval_ta.cpp | 168 ++++++++++++++++++++++++++++++++++++
 2 files changed, 207 insertions(+), 1 deletion(-)

diff --git a/SeQuant/core/eval/eval.hpp b/SeQuant/core/eval/eval.hpp
index d29cda8bde..83dc811ac2 100644
--- a/SeQuant/core/eval/eval.hpp
+++ b/SeQuant/core/eval/eval.hpp
@@ -1685,13 +1685,35 @@ template <typename Node>
 /// \param le            the leaf evaluator (\p t stays resident here).
 /// \param dest          the pre-sized destination result (full spectator
 ///                      extent); each block is scattered into its slice.
+/// \param intra_term_batching  OPTIONAL nested intra-term batching (P3). When
+///        engaged, a giant WITHIN a summand tree is additionally batched over
+///        its CONTRACTED aux/PAO/internal-occ axis INSIDE the current external
+///        block, composing the two mechanisms: the external-occ partition is
+///        the OUTER loop (this function), the intra-term batched custom
+///        evaluator is the INNER mechanism (\c make_batched_custom_evaluator),
+///        installed on the shared scratch. The parameter is a FACTORY: it is
+///        handed THIS block's leaf evaluator (already sliced to the external
+///        block), and returns the \c custom_evaluator_type to install on the
+///        shared scratch for the block; because the intra-term evaluator closes
+///        over that external-sliced leaf evaluator, its contracted-axis slices
+///        compose ON TOP of the external slice. The intra-term evaluator starts
+///        at its OWN depth 0 (the external partition is a SEPARATE outer loop,
+///        NOT part of the intra-term depth counter) and nests/caps internally
+///        (cap 8); it builds its own per-interception scratch, so nothing leaks
+///        across external blocks. It is reinstalled per block (the factory
+///        closes over the block's element range). DEFAULT (empty): the shared
+///        scratch carries no custom evaluator and this path is byte-identical
+///        to the un-nested spine (P2).
 /// \return the number of (non-empty) blocks processed (>= 1).
 template <Trace EvalTrace = Trace::Default, meta::can_evaluate_range Nodes,
           typename F, typename N, bool FHC>
   requires meta::leaf_node_evaluator<std::ranges::range_value_t<Nodes>, F>
 std::size_t evaluate_forest_over_external_axis(
     Nodes const& forest, ExternalBatchAxis const& external_axis,
-    CacheManager<N, FHC>& shared_cache, F const& le, ResultPtr const& dest) {
+    CacheManager<N, FHC>& shared_cache, F const& le, ResultPtr const& dest,
+    std::function<typename CacheManager<N, FHC>::custom_evaluator_type(
+        std::function<ResultPtr(N const&)> const&)> const& intra_term_batching =
+        {}) {
   using node_t = std::ranges::range_value_t<Nodes>;
   SEQUANT_ASSERT(dest);
   SEQUANT_ASSERT(std::ranges::begin(forest) != std::ranges::end(forest));
@@ -1750,6 +1772,22 @@ std::size_t evaluate_forest_over_external_axis(
       return r;
     };
 
+    // Optional NESTED intra-term batching (P3): install a per-block custom
+    // evaluator on the shared scratch so a giant WITHIN a summand is batched
+    // over its CONTRACTED aux/PAO/internal-occ axis INSIDE this external block.
+    // The factory is handed this block's (external-sliced) leaf evaluator, so
+    // the intra-term contracted-axis slices compose ON TOP of the external
+    // slice. Reinstalled here (after reset, with THIS block's le_block) because
+    // le_block closes over the block's element range; the intra-term evaluator
+    // starts at its own depth 0 and manages its own per-interception scratch
+    // and depth cap, independent of this outer loop. When the factory is empty
+    // the shared scratch keeps its (empty) custom evaluator and the loop stays
+    // byte-identical to the un-nested spine.
+    if (intra_term_batching) {
+      std::function<ResultPtr(N const&)> le_block_erased = le_block;
+      shared_cache.set_custom_evaluator(intra_term_batching(le_block_erased));
+    }
+
     ResultPtr block_acc;
     for (auto const& tree : forest) {
       ResultPtr part =
diff --git a/tests/unit/test_eval_ta.cpp b/tests/unit/test_eval_ta.cpp
index fb54bcd380..b2f2bd780f 100644
--- a/tests/unit/test_eval_ta.cpp
+++ b/tests/unit/test_eval_ta.cpp
@@ -3373,3 +3373,171 @@ TEST_CASE("eval_forest_over_external_occ", "[eval][forest-external-occ]") {
     REQUIRE(out(target).dot(out(target)) == Catch::Approx(ref_dot));
   }
 }
+
+// P3 nesting gate: intra-term (contracted-aux) batching NESTED inside the
+// external-occ forest loop. Each summand carries BOTH (i) the shared external
+// spectator occ i_9 -- a Hadamard outer mode present on every operand and the
+// result, contracted at no node -- AND (ii) a contracted aux axis x_1 whose
+// intermediate S = g*h carries x_1 free (a batching target). The external-occ
+// partition is the OUTER loop; WITHIN each external block the intra-term
+// batched custom evaluator slices x_1 on the shared scratch. The assembled
+// destination must equal the unbatched reference R = F1 + F2 ELEMENTWISE for
+// every external block size (a memory schedule, never an approximation), and
+// the intra-term evaluator must ACTUALLY FIRE inside each block (proven by a
+// spy scope guard that records every firing). occ_tile_size > 1 (i_9 tiled).
+TEST_CASE("eval_forest_over_external_occ nests intra-term aux batching",
+          "[eval][forest-external-occ][forest-external-occ-nested]") {
+  using sequant::eval_result;
+  using sequant::evaluate;
+  using sequant::evaluate_forest_over_external_axis;
+  using sequant::ExternalBatchAxis;
+  using sequant::make_batched_custom_evaluator;
+  using sequant::ResultPtr;
+  using node_t = sequant::FullBinaryNode<sequant::EvalExprTA>;
+  using cache_t = sequant::CacheManager<node_t>;
+
+  auto& world = TA::get_default_world();
+  // occ i_9 extent 6 in tiles of 2 -> 3 tiles (occ_tile_size == 2 > 1); aux x
+  // extent 6 in tiles of 2 -> 3 tiles (so x_1 partitions into 3 aux batches at
+  // target size 2 -> intra-term batching genuinely engages); virt extent 4.
+  rand_tensor_yield<double, TA::DensePolicy> yield{world, /*nocc=*/6,
+                                                   /*nvirt=*/4, /*naux=*/6};
+  yield.set_max_tile(2);
+  using ArrayT = typename decltype(yield)::array_type;
+  using ResultT = sequant::ResultTensorTA<ArrayT>;
+
+  // Two flat summand trees sharing S = g*h. i_9 is a Hadamard spectator: it
+  // rides every tensor and is declared external (in the result's aux slot via
+  // the ResultExpr LHS) so binarize keeps it uncontracted on every node. x_1
+  // rides g and the final factor and is CONTRACTED at each root; S = g*h
+  // carries x_1 free, so the root's x_1 contraction is a batching target whose
+  // intermediate is S. (The deprecated binarize(ExprPtr) would infer i_9 as
+  // contracted; the ResultExpr API pins it external -- same mechanism as the
+  // GAM{...;i1,i2} = t T2 Hadamard test above.)
+  //   F1 = (g{a_1,i_9;a_2;x_1} * h{a_2,i_9;a_5}) * p{a_5,i_9;a_6;x_1}
+  //   F2 = (g{a_1,i_9;a_2;x_1} * h{a_2,i_9;a_5}) * q{a_5,i_9;a_6;x_1}
+  // Both produce R{a_1;a_6;i_9}; R = F1 + F2.
+  auto const e1 = sequant::deserialize<sequant::ResultExpr>(
+      L"R{a_1;a_6;i_9} = "
+      L"(g{a_1,i_9;a_2;x_1} * h{a_2,i_9;a_5}) * p{a_5,i_9;a_6;x_1}");
+  auto const e2 = sequant::deserialize<sequant::ResultExpr>(
+      L"R{a_1;a_6;i_9} = "
+      L"(g{a_1,i_9;a_2;x_1} * h{a_2,i_9;a_5}) * q{a_5,i_9;a_6;x_1}");
+  auto const n1 = eval_node(e1);
+  auto const n2 = eval_node(e2);
+  std::vector<node_t> const forest{n1, n2};
+
+  auto const isr = sequant::get_default_context().index_space_registry();
+  auto const occ_space = isr->retrieve(L"i");
+  auto const aux_space = isr->retrieve(L"x");
+
+  // The spectator axis: the unique occ index i_9 among the head's outer modes.
+  sequant::Index axis;
+  for (auto const& ix : n1->canon_indices())
+    if (ix.space() == occ_space && !ix.has_proto_indices()) {
+      axis = ix;
+      break;
+    }
+  REQUIRE(axis.nonnull());
+  REQUIRE(axis.space() == occ_space);
+  // Structural preconditions: S = g*h repeats across the forest (shared scratch
+  // builds it once per external block), and i_9 is a plain outer mode.
+  {
+    sequant::TreeNodeEqualityComparator<node_t> const eq;
+    REQUIRE(eq(n1.left(), n2.left()));  // both left children are S
+    auto cm = sequant::cache_manager(forest, 2);
+    REQUIRE(cm.max_life(n1.left()) == 2);
+  }
+  REQUIRE(sequant::index_position(n1, axis).has_value());
+  // The intra-term batch axis x_1 is a CONTRACTED aux index at the root, and S
+  // carries it free (so it is a real batching target, not the external axis).
+  auto accept_aux = [aux_space](sequant::Index const& ix) {
+    return ix.space() == aux_space;
+  };
+  auto const root_axis = sequant::batch_axis(n1, accept_aux);
+  REQUIRE(root_axis.has_value());
+  REQUIRE(root_axis->space() == aux_space);
+  REQUIRE(root_axis->space() != occ_space);
+
+  // Unbatched reference R = F1 + F2 (each in the head's natural layout).
+  std::string const target = n1->annot();
+  ResultPtr ref = evaluate(n1, target, yield);
+  ref->add_inplace(*evaluate(n2, target, yield));
+  auto const& R = ref->get<ArrayT>();
+  double const ref_nrm = TA::norm2(R);
+  REQUIRE(ref_nrm > 0.0);  // guard: reference is nontrivially nonzero
+
+  // The intra-term batching FACTORY: given THIS block's (external-sliced) leaf
+  // evaluator, build a make_batched_custom_evaluator that batches the aux axis
+  // x_1. A spy scope guard records every firing so the test can prove the
+  // intra-term evaluator engaged INSIDE the external blocks (not just once).
+  std::vector<std::size_t> guard_calls;
+  auto spy = [&guard_calls](std::size_t n) {
+    guard_calls.push_back(n);
+    return sequant::no_scope_guard{};
+  };
+  std::function<std::size_t(sequant::Index const&)> const aux_target =
+      [](sequant::Index const&) -> std::size_t { return 2; };
+  std::function<cache_t::custom_evaluator_type(
+      std::function<ResultPtr(node_t const&)> const&)>
+      intra_factory = [&](std::function<ResultPtr(node_t const&)> const& le_blk)
+      -> cache_t::custom_evaluator_type {
+    return make_batched_custom_evaluator(le_blk, aux_target, accept_aux, spy,
+                                         sequant::never_volatile{});
+  };
+
+  // block sizes (in elements of i_9, extent 6, tiles of 2):
+  //   1000 -> 1 block; 4 -> 2 blocks (first spans two tiles); 2 -> 3 blocks.
+  for (std::size_t const block_size :
+       {std::size_t{1000}, std::size_t{4}, std::size_t{2}}) {
+    std::size_t const expected_blocks =
+        (block_size >= 6) ? 1 : (block_size == 4 ? 2 : 3);
+
+    // (A) NESTED run: external-occ partition (outer) WITH intra-term aux
+    // batching (inner). Assert exactness AND that intra-term batching fired
+    // once per (external block, summand) -- i.e. INSIDE every block.
+    guard_calls.clear();
+    ArrayT dest_arr;
+    dest_arr(target) = R(target) - R(target);  // pre-sized zero
+    world.gop.fence();
+    auto dest = eval_result<ResultT>(dest_arr);
+    auto scratch = sequant::cache_manager(forest, 2);
+    ExternalBatchAxis const ext{axis, block_size};
+    auto const n_blocks = evaluate_forest_over_external_axis(
+        forest, ext, scratch, yield, dest, intra_factory);
+    REQUIRE(n_blocks == expected_blocks);
+
+    auto const& out = dest->get<ArrayT>();
+    ArrayT diff;
+    diff(target) = out(target) - R(target);
+    world.gop.fence();
+    REQUIRE(TA::norm2(diff) < 1e-12);
+    REQUIRE(TA::norm2(out) == Catch::Approx(ref_nrm));
+
+    // Nesting fired inside blocks: the root of each of the 2 summands is
+    // intercepted and batched over x_1 in EACH external block -> n_blocks * 2
+    // firings, each partitioning x_1 into 3 aux batches. size > n_summands is
+    // the RED/GREEN gate that intra-term batching ran INSIDE the blocks (not
+    // once globally).
+    REQUIRE(guard_calls.size() == expected_blocks * forest.size());
+    for (auto const n : guard_calls) CHECK(n == 3);
+
+    // (B) DEFAULT (no intra-term batching): byte-identical spine, same result,
+    // and the spy is never touched.
+    guard_calls.clear();
+    ArrayT dest_arr2;
+    dest_arr2(target) = R(target) - R(target);
+    world.gop.fence();
+    auto dest2 = eval_result<ResultT>(dest_arr2);
+    auto scratch2 = sequant::cache_manager(forest, 2);
+    auto const n_blocks2 =
+        evaluate_forest_over_external_axis(forest, ext, scratch2, yield, dest2);
+    REQUIRE(n_blocks2 == expected_blocks);
+    auto const& out2 = dest2->get<ArrayT>();
+    ArrayT diff2;
+    diff2(target) = out2(target) - R(target);
+    world.gop.fence();
+    REQUIRE(TA::norm2(diff2) < 1e-12);
+    REQUIRE(guard_calls.empty());  // default path never installs the evaluator
+  }
+}

From 02f8948499076918facbb57e945fcfca79811851 Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Thu, 9 Jul 2026 20:38:25 -0400
Subject: [PATCH 68/78] eval tests: express external spectator as an aux (not
 occ) hyperindex

The forest-over-external-axis nesting test built its external Hadamard
spectator as a bare occupied index shared among three tensor slots (g, h,
p) plus the result. Master's TensorNetworkV3::canonicalize_slots
deliberately rejects a non-auxiliary index shared among >2 tensor slots
(it has no well-defined bra/ket slot type), so eval_node threw once this
branch merged master's newer TNv3.

Switch the spectator to an auxiliary index (x_9): a high-order aux
hyperindex carried into the result IS supported (the same case the
eval_with_tiledarray test exercises), the arrays stay flat so the
intra-term batched evaluator runs on its supported path, and the forest +
nested-batching mechanism under test is axis-agnostic. A second inner-aux
predicate keeps the contracted batch axis (x_1) distinct from the
spectator. Occupied-external recognition and sizing are covered
separately at the DP/cost level.
---
 tests/unit/test_eval_ta.cpp | 80 ++++++++++++++++++++++---------------
 1 file changed, 48 insertions(+), 32 deletions(-)

diff --git a/tests/unit/test_eval_ta.cpp b/tests/unit/test_eval_ta.cpp
index d3d1dc25aa..f18f172852 100644
--- a/tests/unit/test_eval_ta.cpp
+++ b/tests/unit/test_eval_ta.cpp
@@ -3396,16 +3396,26 @@ TEST_CASE("eval_forest_over_external_occ", "[eval][forest-external-occ]") {
 }
 
 // P3 nesting gate: intra-term (contracted-aux) batching NESTED inside the
-// external-occ forest loop. Each summand carries BOTH (i) the shared external
-// spectator occ i_9 -- a Hadamard outer mode present on every operand and the
+// external forest loop. Each summand carries BOTH (i) a shared external
+// spectator x_9 -- a Hadamard outer mode present on every operand and the
 // result, contracted at no node -- AND (ii) a contracted aux axis x_1 whose
-// intermediate S = g*h carries x_1 free (a batching target). The external-occ
+// intermediate S = g*h carries x_1 free (a batching target). The external
 // partition is the OUTER loop; WITHIN each external block the intra-term
 // batched custom evaluator slices x_1 on the shared scratch. The assembled
 // destination must equal the unbatched reference R = F1 + F2 ELEMENTWISE for
 // every external block size (a memory schedule, never an approximation), and
 // the intra-term evaluator must ACTUALLY FIRE inside each block (proven by a
-// spy scope guard that records every firing). occ_tile_size > 1 (i_9 tiled).
+// spy scope guard that records every firing). external axis tiled (> 1 tile).
+//
+// NOTE on the external axis space: the spectator here is an AUXILIARY index
+// (x_9), NOT an occupied one. TNv3::canonicalize_slots deliberately forbids a
+// *non-auxiliary* index shared among >2 tensor slots (it has no well-defined
+// bra/ket slot type); a high-order AUX hyperindex carried into the result IS
+// supported (same case exercised in "eval_with_tiledarray"). The forest +
+// nested-batching MECHANISM under test is axis-agnostic, so an aux spectator
+// exercises it identically. Occupied-external RECOGNITION and SIZING (where
+// the occ-vs-aux distinction actually matters) are covered at the DP/cost
+// level by the [dryrun-occ-recognize] / [dryrun-occ-sizing] gates.
 TEST_CASE("eval_forest_over_external_occ nests intra-term aux batching",
           "[eval][forest-external-occ][forest-external-occ-nested]") {
   using sequant::eval_result;
@@ -3418,51 +3428,55 @@ TEST_CASE("eval_forest_over_external_occ nests intra-term aux batching",
   using cache_t = sequant::CacheManager<node_t>;
 
   auto& world = TA::get_default_world();
-  // occ i_9 extent 6 in tiles of 2 -> 3 tiles (occ_tile_size == 2 > 1); aux x
-  // extent 6 in tiles of 2 -> 3 tiles (so x_1 partitions into 3 aux batches at
-  // target size 2 -> intra-term batching genuinely engages); virt extent 4.
+  // aux x (both x_9 and x_1 live in this space) extent 6 in tiles of 2 -> 3
+  // tiles: the external axis x_9 partitions into 1/2/3 blocks, and the inner
+  // axis x_1 partitions into 3 aux batches at target size 2 (so intra-term
+  // batching genuinely engages); virt extent 4. (nocc unused here.)
   rand_tensor_yield<double, TA::DensePolicy> yield{world, /*nocc=*/6,
                                                    /*nvirt=*/4, /*naux=*/6};
   yield.set_max_tile(2);
   using ArrayT = typename decltype(yield)::array_type;
   using ResultT = sequant::ResultTensorTA<ArrayT>;
 
-  // Two flat summand trees sharing S = g*h. i_9 is a Hadamard spectator: it
-  // rides every tensor and is declared external (in the result's aux slot via
-  // the ResultExpr LHS) so binarize keeps it uncontracted on every node. x_1
+  // Two flat summand trees sharing S = g*h. x_9 is a Hadamard spectator: it
+  // rides every tensor (in the aux slot) and is declared external (in the
+  // result's aux slot via the ResultExpr LHS) so binarize keeps it uncontracted
+  // on every node -- a high-order AUX hyperindex carried into the result. x_1
   // rides g and the final factor and is CONTRACTED at each root; S = g*h
   // carries x_1 free, so the root's x_1 contraction is a batching target whose
-  // intermediate is S. (The deprecated binarize(ExprPtr) would infer i_9 as
+  // intermediate is S. (The deprecated binarize(ExprPtr) would infer x_9 as
   // contracted; the ResultExpr API pins it external -- same mechanism as the
   // GAM{...;i1,i2} = t T2 Hadamard test above.)
-  //   F1 = (g{a_1,i_9;a_2;x_1} * h{a_2,i_9;a_5}) * p{a_5,i_9;a_6;x_1}
-  //   F2 = (g{a_1,i_9;a_2;x_1} * h{a_2,i_9;a_5}) * q{a_5,i_9;a_6;x_1}
-  // Both produce R{a_1;a_6;i_9}; R = F1 + F2.
+  //   F1 = (g{a_1;a_2;x_1,x_9} * h{a_2;a_5;x_9}) * p{a_5;a_6;x_1,x_9}
+  //   F2 = (g{a_1;a_2;x_1,x_9} * h{a_2;a_5;x_9}) * q{a_5;a_6;x_1,x_9}
+  // Both produce R{a_1;a_6;x_9}; R = F1 + F2.
   auto const e1 = sequant::deserialize<sequant::ResultExpr>(
-      L"R{a_1;a_6;i_9} = "
-      L"(g{a_1,i_9;a_2;x_1} * h{a_2,i_9;a_5}) * p{a_5,i_9;a_6;x_1}");
+      L"R{a_1;a_6;x_9} = "
+      L"(g{a_1;a_2;x_1,x_9} * h{a_2;a_5;x_9}) * p{a_5;a_6;x_1,x_9}");
   auto const e2 = sequant::deserialize<sequant::ResultExpr>(
-      L"R{a_1;a_6;i_9} = "
-      L"(g{a_1,i_9;a_2;x_1} * h{a_2,i_9;a_5}) * q{a_5,i_9;a_6;x_1}");
+      L"R{a_1;a_6;x_9} = "
+      L"(g{a_1;a_2;x_1,x_9} * h{a_2;a_5;x_9}) * q{a_5;a_6;x_1,x_9}");
   auto const n1 = eval_node(e1);
   auto const n2 = eval_node(e2);
   std::vector<node_t> const forest{n1, n2};
 
   auto const isr = sequant::get_default_context().index_space_registry();
-  auto const occ_space = isr->retrieve(L"i");
   auto const aux_space = isr->retrieve(L"x");
 
-  // The spectator axis: the unique occ index i_9 among the head's outer modes.
+  // The external spectator axis: the aux index carried in the head's result
+  // (uncontracted) -- i.e. among the root node's free/canon indices. The
+  // contracted inner batch axis x_1 is summed at the root, so it is absent
+  // there; the sole aux among the root's free modes is the spectator x_9.
   sequant::Index axis;
   for (auto const& ix : n1->canon_indices())
-    if (ix.space() == occ_space && !ix.has_proto_indices()) {
+    if (ix.space() == aux_space && !ix.has_proto_indices()) {
       axis = ix;
       break;
     }
   REQUIRE(axis.nonnull());
-  REQUIRE(axis.space() == occ_space);
+  REQUIRE(axis.space() == aux_space);
   // Structural preconditions: S = g*h repeats across the forest (shared scratch
-  // builds it once per external block), and i_9 is a plain outer mode.
+  // builds it once per external block), and x_9 is a plain outer mode.
   {
     sequant::TreeNodeEqualityComparator<node_t> const eq;
     REQUIRE(eq(n1.left(), n2.left()));  // both left children are S
@@ -3470,15 +3484,17 @@ TEST_CASE("eval_forest_over_external_occ nests intra-term aux batching",
     REQUIRE(cm.max_life(n1.left()) == 2);
   }
   REQUIRE(sequant::index_position(n1, axis).has_value());
-  // The intra-term batch axis x_1 is a CONTRACTED aux index at the root, and S
-  // carries it free (so it is a real batching target, not the external axis).
-  auto accept_aux = [aux_space](sequant::Index const& ix) {
-    return ix.space() == aux_space;
+  // The intra-term batch axis is the CONTRACTED aux index at the root (x_1),
+  // and S carries it free (so it is a real batching target, not the external
+  // spectator x_9). accept_inner_aux matches aux indices OTHER than the
+  // external spectator so the inner evaluator never tries to batch x_9.
+  auto accept_inner_aux = [aux_space, axis](sequant::Index const& ix) {
+    return ix.space() == aux_space && ix != axis;
   };
-  auto const root_axis = sequant::batch_axis(n1, accept_aux);
+  auto const root_axis = sequant::batch_axis(n1, accept_inner_aux);
   REQUIRE(root_axis.has_value());
   REQUIRE(root_axis->space() == aux_space);
-  REQUIRE(root_axis->space() != occ_space);
+  REQUIRE(*root_axis != axis);
 
   // Unbatched reference R = F1 + F2 (each in the head's natural layout).
   std::string const target = n1->annot();
@@ -3503,11 +3519,11 @@ TEST_CASE("eval_forest_over_external_occ nests intra-term aux batching",
       std::function<ResultPtr(node_t const&)> const&)>
       intra_factory = [&](std::function<ResultPtr(node_t const&)> const& le_blk)
       -> cache_t::custom_evaluator_type {
-    return make_batched_custom_evaluator(le_blk, aux_target, accept_aux, spy,
-                                         sequant::never_volatile{});
+    return make_batched_custom_evaluator(le_blk, aux_target, accept_inner_aux,
+                                         spy, sequant::never_volatile{});
   };
 
-  // block sizes (in elements of i_9, extent 6, tiles of 2):
+  // block sizes (in elements of x_9, extent 6, tiles of 2):
   //   1000 -> 1 block; 4 -> 2 blocks (first spans two tiles); 2 -> 3 blocks.
   for (std::size_t const block_size :
        {std::size_t{1000}, std::size_t{4}, std::size_t{2}}) {

From 39c7eb78e6bdfc10fc7526bcf0059ef44e3871ef Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Thu, 9 Jul 2026 21:49:03 -0400
Subject: [PATCH 69/78] is_valid: accept Power expressions

is_valid recognized Constant, Variable, Tensor, Product and Sum but fell
through to a hard assertion for any other expression type. Power (base^
exponent) is a legitimate expression -- it appears, for example, in CC/EOM
residual expressions as an inverse-denominator factor -- so a consumer that
validates such an expression (e.g. MPQC's process_for_evaluation) aborts in
assertion-enabled builds and, with the assertion elided in release, silently
treats a Power-bearing expression as valid only by luck.

Add a Power case: a Power is valid iff its base is valid (the exponent is a
rational and is always well-formed). Power is atomic, so the base is not
reached by the children loop and is validated explicitly here.
---
 SeQuant/core/utility/expr.cpp | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/SeQuant/core/utility/expr.cpp b/SeQuant/core/utility/expr.cpp
index 00566a9632..3129c066e8 100644
--- a/SeQuant/core/utility/expr.cpp
+++ b/SeQuant/core/utility/expr.cpp
@@ -373,6 +373,11 @@ bool is_valid(const Expr &expr, std::string *msg) {
     if (!consistent) {
       SEQUANT_EXPR_INVALID("Inconsistent external indices in sum");
     }
+  } else if (expr.is<Power>()) {
+    // A Power (base^exponent) is valid iff its base is valid; the exponent is a
+    // rational and is always well-formed. Power is atomic (it exposes no
+    // subexpressions to the children loop above), so validate the base here.
+    if (!is_valid(expr.as<Power>().base(), msg)) return false;
   } else {
     SEQUANT_ASSERT(false, "Unsupported expression type in is_valid");
   }

From 0f69597718cf69fc86f5b3713302972cabb88c5c Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Fri, 10 Jul 2026 07:50:05 -0400
Subject: [PATCH 70/78] index space registry: make occupancy predicates robust
 to non-physical spaces

is_pure_occupied/is_pure_unoccupied/contains_occupied/contains_unoccupied
reduced an index's quantum numbers to physical-particle (spin) attributes and
then looked up the vacuum-(un)occupied space at those qns via a throwing
retrieve. For an index whose reduced qns has no registered occupied space this
threw instead of answering the occupancy question. Two cases motivated this:

- Physical spaces (AO, PAO) span real particle states and are spin-independent,
  not spin-less; they must carry the convention's spin_any in the physical
  sector. add_ao_spaces/add_pao_spaces registered them with only their LCAO
  trait bit (spin bits empty), so physical_particle_attributes() reported no
  spin and the occupancy lookup queried a spin flavor with no occupied space.
  Fix: add_ao_spaces/add_pao_spaces now take an explicit spin_any parameter
  (Spin::null for SpinConvention::Legacy, else Spin::any, matching make_*_spaces)
  and register the AO/PAO spaces with spin_any | trait.

- Non-physical auxiliary spaces (density-fitting, batching) legitimately carry
  no spin; asking whether they are occupied must answer false, not throw. The
  four occupancy predicates now route through non-throwing helpers
  (vacuum_occupied_type_or_null / complete_type_or_null /
  vacuum_unoccupied_type_or_null) that return a null type when no space is
  registered at the reduced qns. Byte-identical for physical inputs.

Update unit-test callers of add_ao_spaces/add_pao_spaces to pass the spin_any
matching each test's registry convention.
---
 SeQuant/core/index_space_registry.hpp | 72 +++++++++++++++++++++++++--
 SeQuant/domain/mbpt/convention.cpp    | 32 ++++++++----
 SeQuant/domain/mbpt/convention.hpp    | 14 +++++-
 tests/unit/test_canonicalize.cpp      |  6 +--
 tests/unit/test_eval_btas.cpp         |  4 +-
 tests/unit/test_optimize.cpp          | 44 ++++++++--------
 tests/unit/test_space.cpp             |  4 +-
 tests/unit/test_tensor_network.cpp    |  2 +-
 8 files changed, 132 insertions(+), 46 deletions(-)

diff --git a/SeQuant/core/index_space_registry.hpp b/SeQuant/core/index_space_registry.hpp
index a55593e0d9..3d892e237d 100644
--- a/SeQuant/core/index_space_registry.hpp
+++ b/SeQuant/core/index_space_registry.hpp
@@ -905,8 +905,16 @@ class IndexSpaceRegistry {
       return false;
     }
     // this introduces icky dependence on bit footprint of vacuum_occupied_space
-    if (IS.type().to_int32() <=
-        vacuum_occupied_space(IS.qns()).type().to_int32()) {
+    // Reduce qns to physical-particle (e.g. spin) attributes before the
+    // occupancy lookup: non-particle traits (LCAO/factorization bits) do not
+    // participate in occupancy. The non-throwing lookup returns a null
+    // vacuum-occupied type for a non-physical auxiliary space (e.g. a
+    // density-fitting or batching index that carries no particle/spin
+    // character), so such a space is reported not pure-occupied rather than
+    // triggering a throw.
+    auto const vacocc_type =
+        vacuum_occupied_type_or_null(physical_particle_attributes(IS.qns()));
+    if (IS.type().to_int32() <= vacocc_type.to_int32()) {
       return true;
     } else {
       return false;
@@ -938,8 +946,10 @@ class IndexSpaceRegistry {
       // Q: would be better to express as IS is a subspace of
       // vacuum_unoccupied_space? Then subspaces that are part of neither (this
       // is not supposed to happen) will not cause an issue here
+      // non-throwing lookup: a non-physical auxiliary space yields null
+      // vacuum-occupied type, so this reports it as (trivially) unoccupied
       return !IS.type().intersection(
-          vacuum_occupied_space(physical_particle_attributes(IS.qns())).type());
+          vacuum_occupied_type_or_null(physical_particle_attributes(IS.qns())));
     }
   }
 
@@ -960,7 +970,10 @@ class IndexSpaceRegistry {
 
   /// @brief some states are fermi vacuum occupied
   bool contains_occupied(const IndexSpace& IS) const {
-    return IS.type().intersection(vacuum_occupied_space(IS.qns()).type()) !=
+    // non-throwing lookup on physical-particle attributes: a non-physical
+    // auxiliary space (no particle/spin character) contains no occupied states
+    return IS.type().intersection(vacuum_occupied_type_or_null(
+               physical_particle_attributes(IS.qns()))) !=
            IndexSpace::Type::null;
   }
 
@@ -981,7 +994,11 @@ class IndexSpaceRegistry {
 
   /// @brief some states are fermi vacuum unoccupied
   bool contains_unoccupied(const IndexSpace& IS) const {
-    return IS.type().intersection(vacuum_unoccupied_space(IS.qns()).type()) !=
+    // non-throwing lookup on physical-particle attributes: a non-physical
+    // auxiliary space (no particle/spin character) contains no unoccupied
+    // states
+    return IS.type().intersection(vacuum_unoccupied_type_or_null(
+               physical_particle_attributes(IS.qns()))) !=
            IndexSpace::Type::null;
   }
 
@@ -1385,6 +1402,51 @@ class IndexSpaceRegistry {
     return bits && !(bits & (bits - 1));
   }
 
+  /// @brief non-throwing counterpart of `vacuum_occupied_space(qn).type()`
+  /// @param qn quantum numbers (typically already reduced to
+  ///        physical-particle attributes)
+  /// @return the vacuum-occupied TYPE registered for @p qn (per-qns override if
+  ///         present, else the default), or IndexSpace::Type::null when no
+  ///         occupied space is registered at @p qn -- e.g. a non-physical
+  ///         auxiliary space (density-fitting, batching) that carries no
+  ///         particle/spin character, hence no occupancy.
+  IndexSpace::Type vacuum_occupied_type_or_null(
+      IndexSpace::QuantumNumbers qn) const {
+    auto const& qn2type = std::get<1>(vacocc_);
+    auto const it = qn2type.find(qn);
+    IndexSpace::Type const t =
+        (it != qn2type.end()) ? it->second : std::get<0>(vacocc_);
+    if (!t) return IndexSpace::Type::null;
+    return retrieve_ptr(t, qn) ? t : IndexSpace::Type::null;
+  }
+
+  /// @brief non-throwing counterpart of `complete_space(qn).type()`
+  /// @param qn quantum numbers
+  /// @return the complete-space TYPE registered for @p qn, or
+  ///         IndexSpace::Type::null when none is registered at @p qn
+  IndexSpace::Type complete_type_or_null(IndexSpace::QuantumNumbers qn) const {
+    auto const& qn2type = std::get<1>(complete_);
+    auto const it = qn2type.find(qn);
+    IndexSpace::Type const t =
+        (it != qn2type.end()) ? it->second : std::get<0>(complete_);
+    if (!t) return IndexSpace::Type::null;
+    return retrieve_ptr(t, qn) ? t : IndexSpace::Type::null;
+  }
+
+  /// @brief non-throwing counterpart of `vacuum_unoccupied_space(qn).type()`
+  /// @param qn quantum numbers (typically already reduced to
+  ///        physical-particle attributes)
+  /// @return the vacuum-unoccupied TYPE (complete minus vacuum-occupied) for
+  ///         @p qn, or IndexSpace::Type::null when no complete space is
+  ///         registered at @p qn (non-physical auxiliary space)
+  IndexSpace::Type vacuum_unoccupied_type_or_null(
+      IndexSpace::QuantumNumbers qn) const {
+    auto const complete_t = complete_type_or_null(qn);
+    if (!complete_t) return IndexSpace::Type::null;
+    auto const vacocc_t = vacuum_occupied_type_or_null(qn);
+    return complete_t.xOr(vacocc_t).intersection(complete_t);
+  }
+
   /// @brief find an IndexSpace from its attr. return nullspace if not present.
   /// @param attr the attribute of the IndexSpace
   const IndexSpace& find_by_attr(const IndexSpace::Attr& attr) const {
diff --git a/SeQuant/domain/mbpt/convention.cpp b/SeQuant/domain/mbpt/convention.cpp
index fef76a3b20..07366d65fe 100644
--- a/SeQuant/domain/mbpt/convention.cpp
+++ b/SeQuant/domain/mbpt/convention.cpp
@@ -71,30 +71,44 @@ void add_fermi_spin(IndexSpaceRegistry& isr) {
   isr = std::move(result);
 }
 
-void add_ao_spaces(std::shared_ptr<IndexSpaceRegistry>& isr, bool vbs,
-                   bool abs) {
+void add_ao_spaces(std::shared_ptr<IndexSpaceRegistry>& isr,
+                   IndexSpace::QuantumNumbers spin_any, bool vbs, bool abs) {
   // matches the MPQC layout, see spindex.h
   // this will not work for MR
+  // AO spaces are physical (spin-specific AOs can support particle states of a
+  // given spin), so they carry the convention's spin-agnostic quantum numbers
+  // (spin_any) in the physical (spin) sector alongside the LCAOQNS::ao trait
+  // bit; leaving the spin bits empty would make physical_particle_attributes()
+  // report no spin and break occupancy lookups (e.g. is_pure_occupied) that key
+  // on spin. spin_any matches how make_*_spaces sets the base spaces' spin.
+  auto const ao_qns = spin_any | LCAOQNS::ao;
   auto obs_lcao = isr->retrieve(vbs ? L"m" : L"p");
-  isr->add(IndexSpace{L"μ", obs_lcao.type(), LCAOQNS::ao});  // OBS AO
+  isr->add(IndexSpace{L"μ", obs_lcao.type(), ao_qns});  // OBS AO
   if (vbs) {
     auto vbs_lcao = isr->retrieve(L"e");
-    isr->add(IndexSpace{L"Α", vbs_lcao.type(), LCAOQNS::ao})  // VBS AO
-        .add_union(L"Γ", {L"μ", L"Α"});  // VBS+ = OBS + VBS
+    isr->add(IndexSpace{L"Α", vbs_lcao.type(), ao_qns})  // VBS AO
+        .add_union(L"Γ", {L"μ", L"Α"});                  // VBS+ = OBS + VBS
   }
   if (abs) {
     auto abs_lcao = isr->retrieve(L"α'");
-    isr->add(IndexSpace{L"σ", abs_lcao.type(),
-                        LCAOQNS::ao})  // ABS AO in F12 methods
+    isr->add(
+           IndexSpace{L"σ", abs_lcao.type(), ao_qns})  // ABS AO in F12 methods
         .add_union(L"ρ", {L"μ", L"σ"});
     if (vbs)                               // ABS+ = OBS + ABS
       isr->add_union(L"Ρ", {L"Γ", L"σ"});  // VABS+ = VBS+ + ABS
   }
 }
 
-void add_pao_spaces(std::shared_ptr<IndexSpaceRegistry>& isr) {
+void add_pao_spaces(std::shared_ptr<IndexSpaceRegistry>& isr,
+                    IndexSpace::QuantumNumbers spin_any) {
   auto uocc_space = isr->particle_space(/* nulltype_ok = */ false);
-  isr->add(IndexSpace{L"μ̃", uocc_space, LCAOQNS::pao})  // OBS PAO
+  // PAO states are physical (spin-independent, but still particle states), so
+  // they carry the convention's spin-agnostic quantum numbers (spin_any) in the
+  // physical (spin) sector alongside the LCAOQNS::pao trait bit; leaving the
+  // spin bits empty would make physical_particle_attributes() report no spin
+  // and break occupancy lookups (e.g. is_pure_occupied) that key on spin.
+  // spin_any matches how make_*_spaces sets the base spaces' spin.
+  isr->add(IndexSpace{L"μ̃", uocc_space, spin_any | LCAOQNS::pao})  // OBS PAO
       ;
 }
 
diff --git a/SeQuant/domain/mbpt/convention.hpp b/SeQuant/domain/mbpt/convention.hpp
index dfe9241e71..d544a2bfd7 100644
--- a/SeQuant/domain/mbpt/convention.hpp
+++ b/SeQuant/domain/mbpt/convention.hpp
@@ -45,8 +45,13 @@ void add_fermi_spin(IndexSpaceRegistry& isr);
 /// @brief add AO spaces to registry
 
 /// @param isr the IndexSpaceRegistry to which add the AO spaces
+/// @param spin_any the quantum numbers carried by spin-agnostic physical
+///        spaces in the target convention (Spin::null for
+///        SpinConvention::Legacy, else Spin::any); AO spaces are physical, so
+///        they carry it in the spin sector alongside the LCAOQNS::ao trait bit
 /// @param vbs if true, have separate virtual basis
-void add_ao_spaces(std::shared_ptr<IndexSpaceRegistry>& isr, bool vbs = false,
+void add_ao_spaces(std::shared_ptr<IndexSpaceRegistry>& isr,
+                   IndexSpace::QuantumNumbers spin_any, bool vbs = false,
                    bool abs = false);
 
 /// @brief add DF spaces to registry
@@ -58,7 +63,12 @@ void add_thc_spaces(std::shared_ptr<IndexSpaceRegistry>& isr);
 /// @brief add PAO spaces to registry
 
 /// expects \p isr to have a defined particle space
-void add_pao_spaces(std::shared_ptr<IndexSpaceRegistry>& isr);
+/// @param spin_any the quantum numbers carried by spin-agnostic physical
+///        spaces in the target convention (Spin::null for
+///        SpinConvention::Legacy, else Spin::any); PAO spaces are physical, so
+///        they carry it in the spin sector alongside the LCAOQNS::pao trait bit
+void add_pao_spaces(std::shared_ptr<IndexSpaceRegistry>& isr,
+                    IndexSpace::QuantumNumbers spin_any);
 
 /// @brief add batching spaces to registry
 void add_batching_spaces(std::shared_ptr<IndexSpaceRegistry>& isr);
diff --git a/tests/unit/test_canonicalize.cpp b/tests/unit/test_canonicalize.cpp
index 5b32c3e2ba..e9326d6072 100644
--- a/tests/unit/test_canonicalize.cpp
+++ b/tests/unit/test_canonicalize.cpp
@@ -34,7 +34,7 @@ TEST_CASE("canonicalization", "[algorithms]") {
   TensorCanonicalizer::register_instance(
       std::make_shared<DefaultTensorCanonicalizer>());
   auto isr = sequant::mbpt::make_legacy_spaces();
-  mbpt::add_pao_spaces(isr);
+  mbpt::add_pao_spaces(isr, mbpt::Spin::null);
   auto ctx = get_default_context();
   ctx.set(isr);
   auto ctx_resetter = set_scoped_default_context(ctx);
@@ -319,8 +319,8 @@ TEST_CASE("canonicalization", "[algorithms]") {
     // intermediate.
     {
       auto sr_reg = mbpt::make_min_sr_spaces(mbpt::SpinConvention::None);
-      mbpt::add_pao_spaces(sr_reg);  // μ̃ (PAO)
-      mbpt::add_df_spaces(sr_reg);   // Κ  (DF aux)
+      mbpt::add_pao_spaces(sr_reg, mbpt::Spin::any);  // μ̃ (PAO)
+      mbpt::add_df_spaces(sr_reg);                    // Κ  (DF aux)
       std::vector<std::wstring> keys;
       for (auto const& s : *sr_reg) keys.push_back(s.base_key());
       for (auto const& k : keys)
diff --git a/tests/unit/test_eval_btas.cpp b/tests/unit/test_eval_btas.cpp
index e57ff3169e..463001375a 100644
--- a/tests/unit/test_eval_btas.cpp
+++ b/tests/unit/test_eval_btas.cpp
@@ -590,8 +590,8 @@ TEST_CASE("binarize_highorder_aux_hyperindex", "[eval_btas][hyperindex]") {
   // register the OBS AO space (μ) and the batching space (z) on top of the
   // standard single-reference spaces
   auto isr = mbpt::make_sr_spaces();
-  mbpt::add_ao_spaces(isr);        // μ (OBS AO)
-  mbpt::add_batching_spaces(isr);  // z (batching)
+  mbpt::add_ao_spaces(isr, mbpt::Spin::any);  // μ (OBS AO)
+  mbpt::add_batching_spaces(isr);             // z (batching)
   auto ctx_resetter =
       set_scoped_default_context(Context{get_default_context()}.set(isr));
 
diff --git a/tests/unit/test_optimize.cpp b/tests/unit/test_optimize.cpp
index 8f88671ea7..aa8d180c14 100644
--- a/tests/unit/test_optimize.cpp
+++ b/tests/unit/test_optimize.cpp
@@ -1166,8 +1166,8 @@ TEST_CASE("optimize", "[optimize]") {
         set_scoped_default_context(get_default_context().clone());
     auto reg = get_default_context().mutable_index_space_registry();
     mbpt::add_df_spaces(reg);
-    mbpt::add_pao_spaces(reg);
-    mbpt::add_ao_spaces(reg);
+    mbpt::add_pao_spaces(reg, mbpt::Spin::any);
+    mbpt::add_ao_spaces(reg, mbpt::Spin::any);
     // i 10
     // a 40
     // μ̃ 50
@@ -1364,8 +1364,8 @@ TEST_CASE("OSV early-contraction reproducer", "[optimize][osv]") {
   auto ctx_resetter = set_scoped_default_context(get_default_context().clone());
   auto reg = get_default_context().mutable_index_space_registry();
   mbpt::add_df_spaces(reg);
-  mbpt::add_pao_spaces(reg);
-  mbpt::add_ao_spaces(reg);
+  mbpt::add_pao_spaces(reg, mbpt::Spin::any);
+  mbpt::add_ao_spaces(reg, mbpt::Spin::any);
   for (auto&& [k, v] :
        std::initializer_list<std::pair<std::wstring_view, size_t>>{
            {L"i", 10}, {L"a", 40}, {L"μ̃", 50}, {L"Κ", 90}}) {
@@ -1421,8 +1421,8 @@ TEST_CASE("OSV early-contraction reproducer (full term #1)",
   auto ctx_resetter = set_scoped_default_context(get_default_context().clone());
   auto reg = get_default_context().mutable_index_space_registry();
   mbpt::add_df_spaces(reg);
-  mbpt::add_pao_spaces(reg);
-  mbpt::add_ao_spaces(reg);
+  mbpt::add_pao_spaces(reg, mbpt::Spin::any);
+  mbpt::add_ao_spaces(reg, mbpt::Spin::any);
   for (auto&& [k, v] :
        std::initializer_list<std::pair<std::wstring_view, size_t>>{
            {L"i", 56}, {L"a", 12}, {L"μ̃", 602}, {L"Κ", 1652}}) {
@@ -1475,8 +1475,8 @@ TEST_CASE("OSV deferral reproducer (tetramer term 3)", "[optimize][osv]") {
   auto ctx_resetter = set_scoped_default_context(get_default_context().clone());
   auto reg = get_default_context().mutable_index_space_registry();
   mbpt::add_df_spaces(reg);
-  mbpt::add_pao_spaces(reg);
-  mbpt::add_ao_spaces(reg);
+  mbpt::add_pao_spaces(reg, mbpt::Spin::any);
+  mbpt::add_ao_spaces(reg, mbpt::Spin::any);
   for (auto&& [k, v] :
        std::initializer_list<std::pair<std::wstring_view, size_t>>{
            {L"i", 16}, {L"a", 12}, {L"μ̃", 170}, {L"Κ", 472}}) {
@@ -1711,8 +1711,8 @@ TEST_CASE("C60 member-2 double-proto probe", "[optimize][osv][c60]") {
   auto ctx_resetter = set_scoped_default_context(get_default_context().clone());
   auto reg = get_default_context().mutable_index_space_registry();
   mbpt::add_df_spaces(reg);
-  mbpt::add_pao_spaces(reg);
-  mbpt::add_ao_spaces(reg);
+  mbpt::add_pao_spaces(reg, mbpt::Spin::any);
+  mbpt::add_ao_spaces(reg, mbpt::Spin::any);
   // C60 cc-pVDZ-F12-ish extents: active occ 120, PNO domain 42, PAO 1800,
   // DF aux 6000 (sliced to batch 30 by the batched objective).
   for (auto&& [k, v] :
@@ -1835,8 +1835,8 @@ TEST_CASE("PPL: form 4-PNO W vs fold-t (peak-neutral, flop tie-break)",
   auto ctx_resetter = set_scoped_default_context(get_default_context().clone());
   auto reg = get_default_context().mutable_index_space_registry();
   mbpt::add_df_spaces(reg);
-  mbpt::add_pao_spaces(reg);
-  mbpt::add_ao_spaces(reg);
+  mbpt::add_pao_spaces(reg, mbpt::Spin::any);
+  mbpt::add_ao_spaces(reg, mbpt::Spin::any);
   for (auto&& [k, v] :
        std::initializer_list<std::pair<std::wstring_view, size_t>>{
            {L"i", 16}, {L"a", 12}, {L"μ̃", 170}, {L"Κ", 472}})
@@ -1995,8 +1995,8 @@ TEST_CASE("optimize emits an external batch axis for the PPL term",
   auto ctx_resetter = set_scoped_default_context(get_default_context().clone());
   auto reg = get_default_context().mutable_index_space_registry();
   mbpt::add_df_spaces(reg);
-  mbpt::add_pao_spaces(reg);
-  mbpt::add_ao_spaces(reg);
+  mbpt::add_pao_spaces(reg, mbpt::Spin::any);
+  mbpt::add_ao_spaces(reg, mbpt::Spin::any);
   for (auto&& [k, v] :
        std::initializer_list<std::pair<std::wstring_view, size_t>>{
            {L"i", 16}, {L"a", 12}, {L"μ̃", 170}, {L"Κ", 472}})
@@ -2077,8 +2077,8 @@ TEST_CASE("quadratic bubble: early-K integral vs late-K t·(gC)",
   auto ctx_resetter = set_scoped_default_context(get_default_context().clone());
   auto reg = get_default_context().mutable_index_space_registry();
   mbpt::add_df_spaces(reg);
-  mbpt::add_pao_spaces(reg);
-  mbpt::add_ao_spaces(reg);
+  mbpt::add_pao_spaces(reg, mbpt::Spin::any);
+  mbpt::add_ao_spaces(reg, mbpt::Spin::any);
   // water-20-scale extents (≈ water-14 OSV extents scaled by 20/14).
   for (auto&& [k, v] :
        std::initializer_list<std::pair<std::wstring_view, size_t>>{
@@ -2287,8 +2287,8 @@ TEST_CASE(
   auto ctx_resetter = set_scoped_default_context(get_default_context().clone());
   auto reg = get_default_context().mutable_index_space_registry();
   mbpt::add_df_spaces(reg);
-  mbpt::add_pao_spaces(reg);
-  mbpt::add_ao_spaces(reg);
+  mbpt::add_pao_spaces(reg, mbpt::Spin::any);
+  mbpt::add_ao_spaces(reg, mbpt::Spin::any);
   // water-20-scale extents (matches the "quadratic bubble" test above).
   for (auto&& [k, v] :
        std::initializer_list<std::pair<std::wstring_view, size_t>>{
@@ -2404,8 +2404,8 @@ TEST_CASE("batched DP peak matches oracle with two axes and accumulation",
   auto ctx_resetter = set_scoped_default_context(get_default_context().clone());
   auto reg = get_default_context().mutable_index_space_registry();
   mbpt::add_df_spaces(reg);
-  mbpt::add_pao_spaces(reg);
-  mbpt::add_ao_spaces(reg);
+  mbpt::add_pao_spaces(reg, mbpt::Spin::any);
+  mbpt::add_ao_spaces(reg, mbpt::Spin::any);
   for (auto&& [k, v] :
        std::initializer_list<std::pair<std::wstring_view, size_t>>{
            {L"i", 20}, {L"a", 20}, {L"μ̃", 200}, {L"Κ", 300}}) {
@@ -2780,8 +2780,8 @@ TEST_CASE("fast_flops equals flops_of over all bipartitions (parity)",
   auto ctx_resetter = set_scoped_default_context(get_default_context().clone());
   auto reg = get_default_context().mutable_index_space_registry();
   mbpt::add_df_spaces(reg);
-  mbpt::add_pao_spaces(reg);
-  mbpt::add_ao_spaces(reg);
+  mbpt::add_pao_spaces(reg, mbpt::Spin::any);
+  mbpt::add_ao_spaces(reg, mbpt::Spin::any);
   for (auto&& [k, v] :
        std::initializer_list<std::pair<std::wstring_view, size_t>>{
            {L"i", 10}, {L"a", 40}, {L"μ̃", 50}, {L"Κ", 90}})
diff --git a/tests/unit/test_space.cpp b/tests/unit/test_space.cpp
index b59e30a275..fdf90e15f3 100644
--- a/tests/unit/test_space.cpp
+++ b/tests/unit/test_space.cpp
@@ -209,7 +209,7 @@ TEST_CASE("index_space", "[elements]") {
 
   SECTION("AO spaces") {
     auto isr = sequant::mbpt::make_min_sr_spaces();
-    REQUIRE_NOTHROW(mbpt::add_ao_spaces(isr));
+    REQUIRE_NOTHROW(mbpt::add_ao_spaces(isr, mbpt::Spin::any));
 
     // OBS AO space ...
     REQUIRE_NOTHROW(isr->retrieve(L"μ"));
@@ -229,7 +229,7 @@ TEST_CASE("index_space", "[elements]") {
 
   SECTION("PAO spaces") {
     auto isr = sequant::mbpt::make_min_sr_spaces();
-    REQUIRE_NOTHROW(mbpt::add_pao_spaces(isr));
+    REQUIRE_NOTHROW(mbpt::add_pao_spaces(isr, mbpt::Spin::any));
 
     // OBS PAO space ...
     REQUIRE_NOTHROW(isr->retrieve(L"μ̃"));
diff --git a/tests/unit/test_tensor_network.cpp b/tests/unit/test_tensor_network.cpp
index 21aaa3c157..35b5dbe1c8 100644
--- a/tests/unit/test_tensor_network.cpp
+++ b/tests/unit/test_tensor_network.cpp
@@ -62,7 +62,7 @@ TEMPLATE_TEST_CASE("tensor_network_shared", "[elements]", TensorNetworkV1,
   TensorCanonicalizer::register_instance(
       std::make_shared<DefaultTensorCanonicalizer>());
   auto isr = sequant::mbpt::make_legacy_spaces();
-  mbpt::add_pao_spaces(isr);
+  mbpt::add_pao_spaces(isr, mbpt::Spin::null);
   auto ctx = get_default_context();
   ctx.set(isr);
   ctx.set(Vacuum::SingleProduct);

From d896b984183b5fd4fabb435a3dc1913101500126 Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Sun, 12 Jul 2026 04:17:31 +0300
Subject: [PATCH 71/78] eval: type batch_axes_ entries with AxisKind
 (Contracted/External)

Retype EvalExpr::batch_axes_ and every producer/consumer of it (optimize's
term_batch_axes/node_batch_axes, PeakBatchedModel::reconstruct_axes, the
batched evaluator's candidate_axes lookup) from a bare Index to
std::pair<Index, AxisKind>. AxisKind lives in core/eval/fwd.hpp next to
DeNest so core/optimize (which has no other dependency on eval_expr.hpp) can
see it without pulling in the whole header.

Pure refactor: every producer tags entries AxisKind::Contracted, so behavior
is unchanged. A later change will start emitting AxisKind::External for
never-contracted spectator indices, which the batched evaluator can then
handle without a separate forest-level mechanism.
---
 SeQuant/core/eval/eval.hpp            |  4 ++--
 SeQuant/core/eval/eval_expr.hpp       | 23 ++++++++++++++---------
 SeQuant/core/eval/fwd.hpp             |  6 ++++++
 SeQuant/core/optimize/cost_model.hpp  | 17 ++++++++++-------
 SeQuant/core/optimize/optimize.cpp    |  2 +-
 SeQuant/core/optimize/options.hpp     |  5 ++++-
 SeQuant/core/optimize/single_term.hpp |  6 ++++--
 tests/unit/test_eval_expr.cpp         | 14 ++++++++++++++
 tests/unit/test_eval_ta.cpp           | 14 +++++++++-----
 tests/unit/test_optimize.cpp          |  7 ++++---
 10 files changed, 68 insertions(+), 30 deletions(-)

diff --git a/SeQuant/core/eval/eval.hpp b/SeQuant/core/eval/eval.hpp
index 83dc811ac2..08b2b57591 100644
--- a/SeQuant/core/eval/eval.hpp
+++ b/SeQuant/core/eval/eval.hpp
@@ -1338,8 +1338,8 @@ template <typename F, typename IndexPredicate = accept_any_index,
     auto candidate_axes = [&accept,
                            depth](auto const& n) -> container::svector<Index> {
       container::svector<Index> out;
-      for (Index const& ix : n->batch_axes())
-        if (accept(ix)) out.push_back(ix);
+      for (auto const& entry : n->batch_axes())
+        if (accept(entry.first)) out.push_back(entry.first);
       if (out.empty() && depth == 0)
         if (auto const h = batch_axis(n, accept)) out.push_back(*h);
       return out;
diff --git a/SeQuant/core/eval/eval_expr.hpp b/SeQuant/core/eval/eval_expr.hpp
index 8d9c7c55ff..db71c082e8 100644
--- a/SeQuant/core/eval/eval_expr.hpp
+++ b/SeQuant/core/eval/eval_expr.hpp
@@ -14,6 +14,7 @@
 #include <cstddef>
 #include <memory>
 #include <string>
+#include <utility>
 
 namespace sequant {
 
@@ -272,19 +273,22 @@ class EvalExpr {
 
   ///
   /// \brief Batchable indices the single-term optimizer chose to slice AT
-  /// this node (its DP `aprime`). Empty unless set by \c binarize from
-  /// \c BinarizationOptions::node_batch_axes (itself populated from
-  /// \c OptimizeOptions::term_batch_axes by the optimizer). The runtime
-  /// batched evaluator slices exactly these indices at this node.
-  ///
-  [[nodiscard]] container::svector<Index> const& batch_axes() const noexcept {
+  /// this node (its DP `aprime`), each tagged with its \c AxisKind. Empty
+  /// unless set by \c binarize from \c BinarizationOptions::node_batch_axes
+  /// (itself populated from \c OptimizeOptions::term_batch_axes by the
+  /// optimizer). The runtime batched evaluator slices exactly these indices
+  /// at this node.
+  ///
+  [[nodiscard]] container::svector<std::pair<Index, AxisKind>> const&
+  batch_axes() const noexcept {
     return batch_axes_;
   }
 
   ///
   /// \brief Sets the batch axes for this node; see \c batch_axes.
   ///
-  void set_batch_axes(container::svector<Index> axes) noexcept {
+  void set_batch_axes(
+      container::svector<std::pair<Index, AxisKind>> axes) noexcept {
     batch_axes_ = std::move(axes);
   }
 
@@ -304,7 +308,7 @@ class EvalExpr {
   std::shared_ptr<bliss::Graph> connectivity_;
 
   /// See \c batch_axes.
-  container::svector<Index> batch_axes_{};
+  container::svector<std::pair<Index, AxisKind>> batch_axes_{};
 };
 
 struct EvalOpSetter {
@@ -369,7 +373,8 @@ struct BinarizationOptions {
   /// the corresponding entry of \c OptimizeOptions::term_batch_axes for the
   /// summand being binarized. Empty (default) => no stamping, no behavior
   /// change. See \c EvalExpr::batch_axes.
-  container::vector<container::svector<Index>> node_batch_axes = {};
+  container::vector<container::svector<std::pair<Index, AxisKind>>>
+      node_batch_axes = {};
 };
 
 namespace meta {
diff --git a/SeQuant/core/eval/fwd.hpp b/SeQuant/core/eval/fwd.hpp
index 18de70d70b..55e9ab6444 100644
--- a/SeQuant/core/eval/fwd.hpp
+++ b/SeQuant/core/eval/fwd.hpp
@@ -14,6 +14,12 @@ namespace sequant {
 /// should be "de-nested" (flattened) to a regular tensor or kept as nested.
 enum class DeNest { True, False };
 
+/// \brief Flavor of an \c EvalExpr::batch_axes entry: whether the index is
+///        contracted away somewhere in the term (\c Contracted), or is an
+///        external/spectator index that survives to the term's result
+///        (\c External). See \c EvalExpr::batch_axes.
+enum class AxisKind { Contracted, External };
+
 template <typename TreeNode, bool force_hash_collisions = false>
 class CacheManager;
 
diff --git a/SeQuant/core/optimize/cost_model.hpp b/SeQuant/core/optimize/cost_model.hpp
index 00f8216750..03ad740761 100644
--- a/SeQuant/core/optimize/cost_model.hpp
+++ b/SeQuant/core/optimize/cost_model.hpp
@@ -84,15 +84,16 @@ EvalSequence run_single_term_opt(Model const& m, TensorNetwork const& network,
 ///         nt==2 shortcut (single contraction, no DP context is built) the
 ///         axes vector holds one empty entry (no batching info available).
 template <class Model, typename TIdxs>
-std::pair<EvalSequence, container::vector<container::svector<Index>>>
+std::pair<EvalSequence,
+          container::vector<container::svector<std::pair<Index, AxisKind>>>>
 run_single_term_opt_axes(Model const& m, TensorNetwork const& network,
                          TIdxs const& tidxs) {
   auto const nt = network.tensors().size();
   if (nt == 1) return {EvalSequence{0}, {}};
   if (nt == 2)
     return {EvalSequence{0, 1, -1},
-            container::vector<container::svector<Index>>{
-                container::svector<Index>{}}};
+            container::vector<container::svector<std::pair<Index, AxisKind>>>{
+                container::svector<std::pair<Index, AxisKind>>{}}};
   typename Model::Context ctx = m.build_context(network, tidxs);
   auto st = solve_single_term(m, network, tidxs, ctx);
   return m.reconstruct_axes(ctx, st);
@@ -1075,12 +1076,13 @@ struct PeakBatchedModel {
   /// each set bit of that node's \c aprime). Leaf entries contribute nothing.
   /// Does not change \ref reconstruct's own output; the two walks are kept in
   /// lock-step so the RPN order and the per-node axes line up.
-  std::pair<EvalSequence, container::vector<container::svector<Index>>>
+  std::pair<EvalSequence,
+            container::vector<container::svector<std::pair<Index, AxisKind>>>>
   reconstruct_axes(Context const& ctx,
                    container::vector<State> const& st) const {
     std::size_t const root = (std::size_t{1} << ctx.nt) - 1;
     int const best = select_root(ctx, st);  // shared helper (see below)
-    container::vector<container::svector<Index>> node_axes;
+    container::vector<container::svector<std::pair<Index, AxisKind>>> node_axes;
     std::function<EvalSequence(std::size_t, std::size_t, int)> build =
         [&](std::size_t n, std::size_t B, int idx) -> EvalSequence {
       if (std::popcount(n) == 1)
@@ -1094,9 +1096,10 @@ struct PeakBatchedModel {
       EvalSequence s = build(fs, C, fi);
       EvalSequence b = build(ss, C, si);
       s.insert(s.end(), b.begin(), b.end());
-      container::svector<Index> axes;
+      container::svector<std::pair<Index, AxisKind>> axes;
       for (std::size_t k = 0; k < ctx.m; ++k)
-        if (r.aprime & (std::size_t{1} << k)) axes.push_back(ctx.aux[k]);
+        if (r.aprime & (std::size_t{1} << k))
+          axes.push_back({ctx.aux[k], AxisKind::Contracted});
       node_axes.push_back(std::move(axes));  // one entry per -1, in RPN order
       s.push_back(-1);
       return s;
diff --git a/SeQuant/core/optimize/optimize.cpp b/SeQuant/core/optimize/optimize.cpp
index e6ea1a64e2..01710fb264 100644
--- a/SeQuant/core/optimize/optimize.cpp
+++ b/SeQuant/core/optimize/optimize.cpp
@@ -105,7 +105,7 @@ ExprPtr opt_pure_product(Product const& prod, OptimizeOptions const& opts) {
   // other objective leaves it empty, so the term_batch_axes insertion at the
   // end is then a no-op-shaped empty-vector entry (harmless: Task 3.3 only
   // consumes entries for summands the batched objective actually annotated).
-  container::vector<container::svector<Index>> node_axes;
+  container::vector<container::svector<std::pair<Index, AxisKind>>> node_axes;
   auto run = [&]() -> ExprPtr {
     if (opts.objective_function == ObjectiveFunction::DenseFLOPs)
       return opt::single_term_opt<ObjectiveFunction::DenseFLOPs>(
diff --git a/SeQuant/core/optimize/options.hpp b/SeQuant/core/optimize/options.hpp
index bf85cef484..d3b2da0ff3 100644
--- a/SeQuant/core/optimize/options.hpp
+++ b/SeQuant/core/optimize/options.hpp
@@ -3,12 +3,14 @@
 
 #include <SeQuant/core/batch_policy.hpp>
 #include <SeQuant/core/container.hpp>
+#include <SeQuant/core/eval/fwd.hpp>
 
 #include <cstddef>
 #include <functional>
 #include <limits>
 #include <memory>
 #include <unordered_map>
+#include <utility>
 
 namespace sequant {
 
@@ -251,7 +253,8 @@ struct OptimizeOptions {
   /// every other objective leaves any pre-existing map entry for that
   /// summand untouched (it is simply never written).
   std::shared_ptr<std::unordered_map<
-      sequant::Expr const*, container::vector<container::svector<Index>>>>
+      sequant::Expr const*,
+      container::vector<container::svector<std::pair<Index, AxisKind>>>>>
       term_batch_axes = {};
 
   /// Prune disconnected (outer-product) subsets from the single-term
diff --git a/SeQuant/core/optimize/single_term.hpp b/SeQuant/core/optimize/single_term.hpp
index 0151e11d90..d48d7eb894 100644
--- a/SeQuant/core/optimize/single_term.hpp
+++ b/SeQuant/core/optimize/single_term.hpp
@@ -70,7 +70,8 @@ EvalSequence single_term_opt(
     std::function<std::size_t(Index const&)> batch_target_size = {},
     std::function<double(Index const&, std::size_t)> const& inner_pow = {},
     bool batch_persistent_only = false,
-    container::vector<container::svector<Index>>* out_axes = nullptr) {
+    container::vector<container::svector<std::pair<Index, AxisKind>>>*
+        out_axes = nullptr) {
   if (out_axes) out_axes->clear();
   decltype(OptRes::indices) tidxs{};
   // Unpack the cost knobs into the names the recurrence arms below use, so the
@@ -232,7 +233,8 @@ ExprPtr single_term_opt(
     std::function<std::size_t(Index const&)> batch_target_size = {},
     std::function<double(Index const&, std::size_t)> const& inner_pow = {},
     bool batch_persistent_only = false,
-    container::vector<container::svector<Index>>* out_axes = nullptr) {
+    container::vector<container::svector<std::pair<Index, AxisKind>>>*
+        out_axes = nullptr) {
   using ranges::views::filter;
   using ranges::views::reverse;
 
diff --git a/tests/unit/test_eval_expr.cpp b/tests/unit/test_eval_expr.cpp
index 352198e7be..621b0adece 100644
--- a/tests/unit/test_eval_expr.cpp
+++ b/tests/unit/test_eval_expr.cpp
@@ -671,3 +671,17 @@ TEST_CASE("eval_expr_outer_proto_position_mixed_node_guard",
     REQUIRE_THROWS_AS(outer_proto_position(node, i1), sequant::Exception);
   }
 }
+
+TEST_CASE("eval_expr_batch_axes_typed", "[EvalExpr][batch-axes]") {
+  using namespace sequant;
+  auto const tnsr =
+      parse_tensor(L"g{i_1,a_1;i_2,a_2}", {.def_perm_symm = Symmetry::Nonsymm});
+  EvalExpr node{tnsr};
+  container::svector<std::pair<Index, AxisKind>> axes{
+      {Index{L"a_1"}, AxisKind::Contracted},
+      {Index{L"i_1"}, AxisKind::External}};
+  node.set_batch_axes(axes);
+  REQUIRE(node.batch_axes().size() == 2);
+  REQUIRE(node.batch_axes()[0].second == AxisKind::Contracted);
+  REQUIRE(node.batch_axes()[1].second == AxisKind::External);
+}
diff --git a/tests/unit/test_eval_ta.cpp b/tests/unit/test_eval_ta.cpp
index f18f172852..3d26db8b19 100644
--- a/tests/unit/test_eval_ta.cpp
+++ b/tests/unit/test_eval_ta.cpp
@@ -2363,7 +2363,7 @@ TEST_CASE("eval_batched_custom_evaluator nests inner axis", "[eval]") {
   // contracted aux axis keeps this robust to binarize's operand ordering.
   auto const root_axis = sequant::batch_axis(node, accept_aux);
   REQUIRE(root_axis.has_value());
-  node->set_batch_axes({*root_axis});
+  node->set_batch_axes({{*root_axis, sequant::AxisKind::Contracted}});
 
   node_t* inner = nullptr;
   std::optional<sequant::Index> inner_axis;
@@ -2382,7 +2382,7 @@ TEST_CASE("eval_batched_custom_evaluator nests inner axis", "[eval]") {
   REQUIRE(inner != nullptr);
   REQUIRE(inner_axis.has_value());
   REQUIRE(*inner_axis != *root_axis);  // the two nested axes differ
-  (*inner)->set_batch_axes({*inner_axis});
+  (*inner)->set_batch_axes({{*inner_axis, sequant::AxisKind::Contracted}});
 
   // Reference: plain (unbatched) evaluation. Computed first so yield_'s random
   // leaf arrays are generated and cached; the batched evaluator reuses them.
@@ -2465,7 +2465,11 @@ TEST_CASE("eval_batched_custom_evaluator nests two axes on one node",
     if (accept_aux(ix)) two_axes.push_back(ix);
   REQUIRE(two_axes.size() == 2);
   REQUIRE(two_axes[0] != two_axes[1]);
-  node->set_batch_axes(two_axes);
+  sequant::container::svector<std::pair<sequant::Index, sequant::AxisKind>>
+      two_axes_typed;
+  for (sequant::Index const& ix : two_axes)
+    two_axes_typed.push_back({ix, sequant::AxisKind::Contracted});
+  node->set_batch_axes(two_axes_typed);
 
   // Reference: plain (unbatched) evaluation; also generates yield_'s random
   // leaf arrays that the batched evaluator reuses.
@@ -2591,7 +2595,7 @@ TEST_CASE(
 
   auto const root_axis = sequant::batch_axis(node, accept_aux);
   REQUIRE(root_axis.has_value());
-  node->set_batch_axes({*root_axis});
+  node->set_batch_axes({{*root_axis, sequant::AxisKind::Contracted}});
 
   node_t* inner = nullptr;
   std::optional<sequant::Index> inner_axis;
@@ -2610,7 +2614,7 @@ TEST_CASE(
   REQUIRE(inner != nullptr);
   REQUIRE(inner_axis.has_value());
   REQUIRE(*inner_axis != *root_axis);
-  (*inner)->set_batch_axes({*inner_axis});
+  (*inner)->set_batch_axes({{*inner_axis, sequant::AxisKind::Contracted}});
 
   auto const ref = evaluate(node, target, yield_)->get<TArrayD>();
 
diff --git a/tests/unit/test_optimize.cpp b/tests/unit/test_optimize.cpp
index aa8d180c14..4fa6670c44 100644
--- a/tests/unit/test_optimize.cpp
+++ b/tests/unit/test_optimize.cpp
@@ -2488,7 +2488,8 @@ TEST_CASE("binarize stamps per-node batch axes from optimize()",
       deserialize(L"g{a_1;i_1;Κ_1} g{a_2;i_2;Κ_1} f{i_1;i_3} f{i_2;i_4}");
 
   auto axes_map = std::make_shared<std::unordered_map<
-      Expr const*, container::vector<container::svector<Index>>>>();
+      Expr const*,
+      container::vector<container::svector<std::pair<Index, AxisKind>>>>>();
 
   OptimizeOptions opts;
   opts.objective_function = ObjectiveFunction::DensePeakSizeBatched;
@@ -2524,8 +2525,8 @@ TEST_CASE("binarize stamps per-node batch axes from optimize()",
   node.visit([&](auto const& n) {
     if (n->batch_axes().empty()) return;
     any_annotated = true;
-    for (auto const& ix : n->batch_axes())
-      if (ix.space() == aux) aux_found = true;
+    for (auto const& entry : n->batch_axes())
+      if (entry.first.space() == aux) aux_found = true;
   });
   // The essential assertion: the round-trip actually annotated a node. If the
   // optimizer's and binarize's post-orders had diverged, either this would be

From ebd95b0909fb670ac018c43a8452769f49bafb1c Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Sun, 12 Jul 2026 04:34:45 +0300
Subject: [PATCH 72/78] optimize: admit explicit external occ modes as
 batchable candidates

---
 SeQuant/core/optimize/single_term_detail.hpp | 58 +++++++++++++-------
 tests/unit/test_optimize.cpp                 | 44 +++++++++++++++
 2 files changed, 82 insertions(+), 20 deletions(-)

diff --git a/SeQuant/core/optimize/single_term_detail.hpp b/SeQuant/core/optimize/single_term_detail.hpp
index 1bcd703294..8f7131e27e 100644
--- a/SeQuant/core/optimize/single_term_detail.hpp
+++ b/SeQuant/core/optimize/single_term_detail.hpp
@@ -251,14 +251,25 @@ container::vector<double> subset_footprints(
 /// it.  The returned list assigns each index a stable bit position: index at
 /// position \c k is bit \c k of a sliced-set bitmask \c B.
 ///
-/// In addition to the top-level slots, a second pass admits the pure-occupied
-/// protoindices of composite (CSV/PNO/OSV tensor-of-tensor) legs. A composite
-/// leg carries its external occupied indices ONLY as protoindices -- they never
-/// appear as a top-level bra/ket/aux slot -- so the slot scan alone drops them.
-/// Admitting them lets the batched DP slice that external-occ spectator axis
-/// (mirrored in \ref subset_open_aux). The proto pass is guarded by index space
-/// (only pure-occupied protos are admitted) and short-circuits on non-composite
-/// indices, so PAO/aux/internal-occ recognition is unchanged.
+/// In addition to the top-level slots, two more passes admit pure-occupied
+/// indices that \p is_batchable never sees:
+///
+///  - the pure-occupied protoindices of composite (CSV/PNO/OSV
+///    tensor-of-tensor) legs. A composite leg carries its external occupied
+///    indices ONLY as protoindices -- they never appear as a top-level
+///    bra/ket/aux slot -- so the slot scan alone drops them.
+///  - an explicit pure-occupied index that is open (external) on the network
+///    root, i.e. a member of \c network.ext_indices(). Such an index is a
+///    genuine top-level slot, but \p is_batchable is typically scoped to a
+///    non-occupied space (e.g. DF/RI aux), so it would otherwise never be
+///    admitted as a batching candidate. Contracted (internal) occupied
+///    indices -- those that connect two or more tensors -- are NOT open on
+///    the root and so are never admitted by this pass.
+///
+/// Admitting either lets the batched DP slice that external-occ spectator
+/// axis (mirrored in \ref subset_open_aux). Both passes are guarded by index
+/// space (only pure-occupied indices are admitted) so PAO/aux/internal-occ
+/// recognition is unchanged.
 ///
 /// \param network  The TensorNetwork to scan.
 /// \param is_batchable  Predicate returning true for indices in a batchable
@@ -269,30 +280,37 @@ inline container::vector<Index> batchable_index_list(
     std::function<bool(Index const&)> const& is_batchable) {
   container::vector<Index> aux;
   if (!is_batchable) return aux;
-  // Registry used to recognize the pure-occupied protoindices of composite
-  // legs. Guarded by has_vacocc: occupancy is defined relative to the
-  // vacuum-occupied space, so a registry without one (or no registry) admits no
-  // protos and leaves behavior byte-identical. is_pure_occupied is NOT used
-  // directly: its space reconstruction throws for proto quantum numbers absent
-  // from the registry; instead we replicate its core type-bitset test (a space
-  // is pure-occupied iff its type is at or below the vacuum-occupied type),
-  // which needs no space retrieval.
+  // Registry used to recognize pure-occupied indices/protoindices. Guarded by
+  // has_vacocc: occupancy is defined relative to the vacuum-occupied space, so
+  // a registry without one (or no registry) admits nothing new and leaves
+  // behavior byte-identical. is_pure_occupied is NOT used directly: its space
+  // reconstruction throws for proto quantum numbers absent from the registry;
+  // instead we replicate its core type-bitset test (a space is pure-occupied
+  // iff its type is at or below the vacuum-occupied type), which needs no
+  // space retrieval.
   auto const isr = get_default_context().index_space_registry();
   auto const vacocc = isr ? isr->vacuum_occupied_space(/*nulltype_ok=*/true)
                           : IndexSpace::Type::null;
   bool const has_vacocc = vacocc != IndexSpace::Type::null;
-  auto is_occ_proto = [&](Index const& p) {
-    return has_vacocc && p.space() &&
-           p.space().type().to_int32() <= vacocc.to_int32();
+  auto is_occ_index = [&](Index const& ix) {
+    return has_vacocc && ix.space() &&
+           ix.space().type().to_int32() <= vacocc.to_int32();
   };
+  // The network's own open (root-external) indices, computed once; membership
+  // in this set is what distinguishes an explicit external occ index from a
+  // contracted (internal) one.
+  auto const& open = network.ext_indices();
   for (auto&& t : network.tensors()) {
     auto tp = std::dynamic_pointer_cast<Tensor>(t);
     for (auto&& ix : ranges::views::concat(tp->bra(), tp->ket(), tp->aux())) {
       if (is_batchable(ix) && ranges::find(aux, ix) == ranges::end(aux))
         aux.push_back(ix);
       for (auto&& p : ix.proto_indices())
-        if (is_occ_proto(p) && ranges::find(aux, p) == ranges::end(aux))
+        if (is_occ_index(p) && ranges::find(aux, p) == ranges::end(aux))
           aux.push_back(p);
+      if (is_occ_index(ix) && ranges::contains(open, ix) &&
+          ranges::find(aux, ix) == ranges::end(aux))
+        aux.push_back(ix);
     }
   }
   return aux;
diff --git a/tests/unit/test_optimize.cpp b/tests/unit/test_optimize.cpp
index 4fa6670c44..cc7aa0b1c9 100644
--- a/tests/unit/test_optimize.cpp
+++ b/tests/unit/test_optimize.cpp
@@ -1359,6 +1359,50 @@ std::wstring render_tree(sequant::ExprPtr const& e) {
 }
 }  // namespace
 
+// batchable_index_list today admits a pure-occupied index only when it
+// arrives as a composite protoindex (e.g. a<i1,i2>): the occ index itself
+// never sits in a top-level bra/ket/aux slot in that case. When the external
+// occ instead appears as an EXPLICIT top-level index (no PAO/CSV composite in
+// sight), the slot scan sees it but rejects it because is_batchable is scoped
+// to the virtual/aux space -- so it is dropped entirely. This reproducer:
+//   R{i_1;a_1} = f{i_1;i_2} t{i_2;a_1}
+// has i_1 external (open on the network root) and i_2 internal (contracted
+// between f and t). is_batchable admits only the virtual space "a", so today
+// batchable_index_list(net, is_batchable) == {} -- i_1 never shows up as a
+// batching candidate even though it is a legitimate spectator axis.
+TEST_CASE("batchable_index_list_admits_explicit_external_occ",
+          "[optimize][batch]") {
+  using namespace sequant;
+  auto ctx_resetter = set_scoped_default_context(get_default_context().clone());
+  auto reg = get_default_context().mutable_index_space_registry();
+  {
+    auto occ = reg->retrieve_ptr(L"i");
+    auto uocc = reg->retrieve_ptr(L"a");
+    REQUIRE(occ);
+    REQUIRE(uocc);
+    occ->approximate_size(10);
+    uocc->approximate_size(100);
+  }
+
+  auto is_batchable = [](Index const& ix) {
+    return ix.space().base_key() == L"a";
+  };
+
+  auto f = deserialize(L"f{i_1;i_2}", {.def_perm_symm = Symmetry::Nonsymm});
+  auto t = deserialize(L"t{i_2;a_1}", {.def_perm_symm = Symmetry::Nonsymm});
+  TensorNetwork net{std::vector<ExprPtr>{f, t}};
+
+  auto i1 = Index{L"i_1"};
+  auto i2 = Index{L"i_2"};
+
+  auto aux = opt::detail::batchable_index_list(net, is_batchable);
+  // i_1 is external (open on the network root) and pure-occupied: admitted.
+  REQUIRE(ranges::find(aux, i1) != ranges::end(aux));
+  // i_2 is contracted (internal) between f and t: never admitted, even
+  // though it is pure-occupied.
+  REQUIRE(ranges::find(aux, i2) == ranges::end(aux));
+}
+
 TEST_CASE("OSV early-contraction reproducer", "[optimize][osv]") {
   using namespace sequant;
   auto ctx_resetter = set_scoped_default_context(get_default_context().clone());

From 5cc8ecd4c257790e52541cd782b0a96ebbafd44a Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Sun, 12 Jul 2026 04:53:11 +0300
Subject: [PATCH 73/78] optimize: reconstruct_axes emits external (spectator)
 modes per node

PeakBatchedModel::reconstruct_axes now appends AxisKind::External entries
for genuine spectator (never-contracted) axes carried on a node's result,
alongside the existing AxisKind::Contracted entries for sliced axes.
Gated by a new PeakBatchedModel::batch_spectator_indices member (default
false), threaded from CostParams::batch_spectator_indices <-
BatchPolicy::batch_spectator_indices. Every other PeakBatchedModel
construction is unaffected and stays byte-identical.
---
 SeQuant/core/optimize/cost_model.hpp  | 19 ++++++
 SeQuant/core/optimize/optimize.cpp    |  3 +-
 SeQuant/core/optimize/options.hpp     |  6 ++
 SeQuant/core/optimize/single_term.hpp |  1 +
 tests/unit/test_optimize.cpp          | 90 +++++++++++++++++++++++++++
 5 files changed, 118 insertions(+), 1 deletion(-)

diff --git a/SeQuant/core/optimize/cost_model.hpp b/SeQuant/core/optimize/cost_model.hpp
index 03ad740761..3293f1b8d4 100644
--- a/SeQuant/core/optimize/cost_model.hpp
+++ b/SeQuant/core/optimize/cost_model.hpp
@@ -606,6 +606,14 @@ struct PeakBatchedModel {
   /// Prune disconnected (outer-product) subsets from the DP (see
   /// OptimizeOptions::prune_outer_products). Default true.
   bool prune_outer_products = true;
+  /// Term-level gate for \ref reconstruct_axes emitting \c AxisKind::External
+  /// entries (genuine spectator axes; see \ref is_spectator_axis), threaded
+  /// from \ref CostParams::batch_spectator_indices /
+  /// BatchPolicy::batch_spectator_indices. Default false so every OTHER
+  /// PeakBatchedModel construction (peak_cost_batched, compute_external_batch_
+  /// axis's own model, existing tests) is unaffected and emits no External
+  /// entries -- byte-identical to before this member existed.
+  bool batch_spectator_indices = false;
 
   /// One non-dominated (peak, flops) trade-off for a (subset, sliced-set \c B)
   /// cell. \c aprime is the sliced-set chosen at this node; the children are
@@ -1100,6 +1108,17 @@ struct PeakBatchedModel {
       for (std::size_t k = 0; k < ctx.m; ++k)
         if (r.aprime & (std::size_t{1} << k))
           axes.push_back({ctx.aux[k], AxisKind::Contracted});
+      // External (spectator) axes: unlike Contracted entries, these do not
+      // depend on the chosen frontier point's aprime -- a spectator axis is
+      // never contracted anywhere, so annotating it is purely informational
+      // (this node's result happens to carry it), independent of which
+      // sliced-set the DP chose to slice at this node. Gated on the
+      // term-level flag so every caller that leaves it false (the default)
+      // stays byte-identical.
+      if (batch_spectator_indices)
+        for (std::size_t k = 0; k < ctx.m; ++k)
+          if (((ctx.open_aux[n] >> k) & 1u) && is_spectator_axis(ctx, k))
+            axes.push_back({ctx.aux[k], AxisKind::External});
       node_axes.push_back(std::move(axes));  // one entry per -1, in RPN order
       s.push_back(-1);
       return s;
diff --git a/SeQuant/core/optimize/optimize.cpp b/SeQuant/core/optimize/optimize.cpp
index 01710fb264..3a9870b4aa 100644
--- a/SeQuant/core/optimize/optimize.cpp
+++ b/SeQuant/core/optimize/optimize.cpp
@@ -100,7 +100,8 @@ ExprPtr opt_pure_product(Product const& prod, OptimizeOptions const& opts) {
                         opts.roofline,
                         opts.batch_policy.accumulation_factor,
                         opts.batch_policy.peak_threshold,
-                        opts.prune_outer_products};
+                        opts.prune_outer_products,
+                        opts.batch_policy.batch_spectator_indices};
   // Filled only by the DensePeakSizeBatched arm below (via out_axes); every
   // other objective leaves it empty, so the term_batch_axes insertion at the
   // end is then a no-op-shaped empty-vector entry (harmless: Task 3.3 only
diff --git a/SeQuant/core/optimize/options.hpp b/SeQuant/core/optimize/options.hpp
index d3b2da0ff3..6e1488252c 100644
--- a/SeQuant/core/optimize/options.hpp
+++ b/SeQuant/core/optimize/options.hpp
@@ -141,6 +141,12 @@ struct CostParams {
   /// Prune disconnected (outer-product) subsets from the single-term DP; see
   /// OptimizeOptions::prune_outer_products. true (default) = prune.
   bool prune_outer_products = true;
+  /// Gate for external-(spectator-)index batching; see
+  /// BatchPolicy::batch_spectator_indices. false (default) => \ref
+  /// opt::detail::PeakBatchedModel::reconstruct_axes emits no
+  /// \c AxisKind::External entries, so every existing (non-spectator-aware)
+  /// caller stays byte-identical.
+  bool batch_spectator_indices = false;
 };
 
 /// A type-erased provider mapping an Index to its extent. Used by the public
diff --git a/SeQuant/core/optimize/single_term.hpp b/SeQuant/core/optimize/single_term.hpp
index d48d7eb894..2bde72cc16 100644
--- a/SeQuant/core/optimize/single_term.hpp
+++ b/SeQuant/core/optimize/single_term.hpp
@@ -145,6 +145,7 @@ EvalSequence single_term_opt(
                            cost.peak_threshold};
     model.perf_first = (Metric == ObjectiveFunction::DenseTimeSpaceBatched);
     model.prune_outer_products = prune_outer_products;
+    model.batch_spectator_indices = cost.batch_spectator_indices;
     // charge_batch_recompute defaults to true (see PeakBatchedModel): the batch
     // recomputation cost is always reflected on the flops/exec axis.
     if (out_axes) {
diff --git a/tests/unit/test_optimize.cpp b/tests/unit/test_optimize.cpp
index cc7aa0b1c9..d8be70bea4 100644
--- a/tests/unit/test_optimize.cpp
+++ b/tests/unit/test_optimize.cpp
@@ -2580,6 +2580,96 @@ TEST_CASE("binarize stamps per-node batch axes from optimize()",
   CHECK(aux_found);
 }
 
+// Task 3: reconstruct_axes must emit AxisKind::External entries for a genuine
+// spectator (external, never-contracted) axis at every node whose subset
+// carries it, gated by BatchPolicy::batch_spectator_indices. i_1 lives only on
+// the first tensor of a 4-tensor chain -- a genuine external spectator that is
+// never contracted anywhere, so is_spectator_axis(i_1) holds regardless of the
+// chosen factorization -- while Kappa_1 (the DF aux shared by the first two
+// tensors) is a genuine CONTRACTED axis, never a spectator. Distinguishes the
+// two kinds even though both get admitted into ctx.aux.
+TEST_CASE("reconstruct_axes_emits_external_per_node", "[optimize][batch]") {
+  using namespace sequant;
+  auto ctx_resetter = set_scoped_default_context(get_default_context().clone());
+  auto reg = get_default_context().mutable_index_space_registry();
+  mbpt::add_df_spaces(reg);
+  for (auto&& [k, v] :
+       std::initializer_list<std::pair<std::wstring_view, size_t>>{
+           {L"i", 8}, {L"a", 8}, {L"Κ", 400}})
+    reg->retrieve_ptr(k)->approximate_size(v);
+  auto aux_space = reg->retrieve(L"Κ");
+  auto occ_space = reg->retrieve(L"i");
+
+  auto idxsz = [](Index const& ix) -> std::size_t {
+    return ix.nonnull() ? ix.space().approximate_size() : std::size_t{1};
+  };
+
+  // Chain network T1-T2-T3-T4: T1--(a_1,Kappa_1)--T2--(a_2)--T3--(a_4)--T4.
+  // i_1 (on T1 only) and a_5 (on T4 only) are the root-external indices.
+  auto expr =
+      deserialize(L"g{i_1;a_1;Κ_1} g{a_1;a_2;Κ_1} f{a_2;a_4} h{a_4;a_5}");
+
+  auto axes_map = std::make_shared<std::unordered_map<
+      Expr const*,
+      container::vector<container::svector<std::pair<Index, AxisKind>>>>>();
+
+  OptimizeOptions opts;
+  opts.objective_function = ObjectiveFunction::DenseTimeSpaceBatched;
+  opts.reorder = ReorderSum::NoReorder;
+  opts.idx_to_extent = idxsz;
+  opts.batch_policy.is_batchable_index = [aux_space](Index const& ix) {
+    return ix.space() == aux_space;
+  };
+  opts.batch_policy.batch_target_size = [](Index const&) -> std::size_t {
+    return 20;
+  };
+  // Finite but irrelevant to selection here (perf-first does not consult it as
+  // a feasibility gate); set to mirror how a real caller would configure it.
+  opts.batch_policy.peak_threshold = 1.0e6;
+  opts.batch_policy.batch_spectator_indices = true;
+  opts.term_batch_axes = axes_map;
+
+  auto optimized = optimize(expr, opts);
+  REQUIRE(optimized);
+
+  auto it = axes_map->find(optimized.get());
+  REQUIRE(it != axes_map->end());
+  auto const& node_axes = it->second;
+  REQUIRE(!node_axes.empty());
+
+  bool node_with_external = false;
+  bool node_without_external = false;
+  for (auto const& axes : node_axes) {
+    bool has_i1_external = false;
+    for (auto const& entry : axes) {
+      // Kappa (a genuine contracted DF aux, never a spectator) must never be
+      // tagged External.
+      if (entry.first.space() == aux_space)
+        CHECK(entry.second == AxisKind::Contracted);
+      if (entry.first.space() == occ_space &&
+          entry.second == AxisKind::External)
+        has_i1_external = true;
+    }
+    if (has_i1_external)
+      node_with_external = true;
+    else
+      node_without_external = true;
+  }
+  CHECK(node_with_external);
+  CHECK(node_without_external);
+
+  // With the gate off, the default optimize() path stays byte-identical: no
+  // External entries anywhere (existing [optimize] tests are its witness).
+  axes_map->clear();
+  opts.batch_policy.batch_spectator_indices = false;
+  auto optimized_off = optimize(expr, opts);
+  REQUIRE(optimized_off);
+  auto it_off = axes_map->find(optimized_off.get());
+  REQUIRE(it_off != axes_map->end());
+  for (auto const& axes : it_off->second)
+    for (auto const& entry : axes) CHECK(entry.second != AxisKind::External);
+}
+
 TEST_CASE("contractible_adjacency", "[optimize][pruning]") {
   using namespace sequant;
   namespace o = sequant::opt::detail;

From 0f2490eac9b5703d8ee7852b6f6a76b8b5160563 Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Sun, 12 Jul 2026 05:12:38 +0300
Subject: [PATCH 74/78] optimize: gate reconstruct_axes External emission on
 the perf-first peak-threshold trigger

Fold compute_external_batch_axis's conditions (ii) perf-first objective and
(iv) unseeded root peak (bytes) over peak_threshold into
PeakBatchedModel::reconstruct_axes's own emit_external gate, alongside the
existing batch_spectator_indices flag. The gate reuses the SAME selected
root (select_root(ctx, st), root_B=0) that seeded_root_peak_batched already
reads for condition (iv), so no extra model pass is needed.

compute_external_batch_axis / ExternalBatchAxis / OptimizeResult's
external_batch_axis field are untouched; they still feed the MPQC forest
path (cck.ipp) until that is retired.
---
 SeQuant/core/optimize/cost_model.hpp | 21 +++++++--
 tests/unit/test_optimize.cpp         | 69 ++++++++++++++++++++++++----
 2 files changed, 77 insertions(+), 13 deletions(-)

diff --git a/SeQuant/core/optimize/cost_model.hpp b/SeQuant/core/optimize/cost_model.hpp
index 3293f1b8d4..9a406a6bf0 100644
--- a/SeQuant/core/optimize/cost_model.hpp
+++ b/SeQuant/core/optimize/cost_model.hpp
@@ -1090,6 +1090,19 @@ struct PeakBatchedModel {
                    container::vector<State> const& st) const {
     std::size_t const root = (std::size_t{1} << ctx.nt) - 1;
     int const best = select_root(ctx, st);  // shared helper (see below)
+    // Term-level "should batch spectator axes" gate, reproducing the OLD
+    // compute_external_batch_axis conditions (ii) perf-first objective and
+    // (iv) unseeded root peak (bytes) exceeds peak_threshold, on top of (i)
+    // batch_spectator_indices already required below. select_root(ctx, st)
+    // above defaults to root_B=0 (unseeded) and this is the SAME model
+    // (same perf_first / peak_threshold / numeric_size) that
+    // seeded_root_peak_batched reads via select_root(ctx, st, /*root_B=*/0),
+    // so st[root][0][best].peak * numeric_size is exactly the byte-peak the
+    // old path compared to peak_threshold -- no extra seeded-model pass
+    // needed to reproduce (iv).
+    double const root_peak_bytes = st[root][0][best].peak * numeric_size;
+    bool const emit_external = batch_spectator_indices && perf_first &&
+                               (root_peak_bytes > peak_threshold);
     container::vector<container::svector<std::pair<Index, AxisKind>>> node_axes;
     std::function<EvalSequence(std::size_t, std::size_t, int)> build =
         [&](std::size_t n, std::size_t B, int idx) -> EvalSequence {
@@ -1113,9 +1126,11 @@ struct PeakBatchedModel {
       // never contracted anywhere, so annotating it is purely informational
       // (this node's result happens to carry it), independent of which
       // sliced-set the DP chose to slice at this node. Gated on the
-      // term-level flag so every caller that leaves it false (the default)
-      // stays byte-identical.
-      if (batch_spectator_indices)
+      // term-level emit_external flag (batch_spectator_indices AND
+      // perf_first AND unseeded peak over threshold) so every caller that
+      // leaves batch_spectator_indices false (the default) -- or whose term
+      // does not need batching -- stays byte-identical.
+      if (emit_external)
         for (std::size_t k = 0; k < ctx.m; ++k)
           if (((ctx.open_aux[n] >> k) & 1u) && is_spectator_axis(ctx, k))
             axes.push_back({ctx.aux[k], AxisKind::External});
diff --git a/tests/unit/test_optimize.cpp b/tests/unit/test_optimize.cpp
index d8be70bea4..04d7124698 100644
--- a/tests/unit/test_optimize.cpp
+++ b/tests/unit/test_optimize.cpp
@@ -2580,11 +2580,14 @@ TEST_CASE("binarize stamps per-node batch axes from optimize()",
   CHECK(aux_found);
 }
 
-// Task 3: reconstruct_axes must emit AxisKind::External entries for a genuine
-// spectator (external, never-contracted) axis at every node whose subset
-// carries it, gated by BatchPolicy::batch_spectator_indices. i_1 lives only on
-// the first tensor of a 4-tensor chain -- a genuine external spectator that is
-// never contracted anywhere, so is_spectator_axis(i_1) holds regardless of the
+// Task 3/4: reconstruct_axes must emit AxisKind::External entries for a
+// genuine spectator (external, never-contracted) axis at every node whose
+// subset carries it, gated by BOTH BatchPolicy::batch_spectator_indices (i)
+// AND the Task 4 term-level emit_external gate (perf-first objective (ii) +
+// unseeded root peak over peak_threshold (iv)), reproducing the OLD
+// compute_external_batch_axis trigger exactly. i_1 lives only on the first
+// tensor of a 4-tensor chain -- a genuine external spectator that is never
+// contracted anywhere, so is_spectator_axis(i_1) holds regardless of the
 // chosen factorization -- while Kappa_1 (the DF aux shared by the first two
 // tensors) is a genuine CONTRACTED axis, never a spectator. Distinguishes the
 // two kinds even though both get admitted into ctx.aux.
@@ -2623,12 +2626,40 @@ TEST_CASE("reconstruct_axes_emits_external_per_node", "[optimize][batch]") {
   opts.batch_policy.batch_target_size = [](Index const&) -> std::size_t {
     return 20;
   };
-  // Finite but irrelevant to selection here (perf-first does not consult it as
-  // a feasibility gate); set to mirror how a real caller would configure it.
-  opts.batch_policy.peak_threshold = 1.0e6;
   opts.batch_policy.batch_spectator_indices = true;
   opts.term_batch_axes = axes_map;
 
+  // Determine this term's actual perf-first root peak (bytes) directly, via
+  // the same PeakBatchedModel construction single_term.hpp's
+  // DenseTimeSpaceBatched arm uses (idxsz, is_batchable_index,
+  // batch_target_size, perf_first=true), so peak_threshold values below and
+  // above it can be chosen without hardcoding a magic number tied to the
+  // extents above. peak_threshold is NOT a factorization gate under
+  // perf_first (see PeakBatchedModel::select_root), so this value does not
+  // depend on which threshold the model below is eventually given.
+  namespace o = sequant::opt::detail;
+  container::svector<ExprPtr> tensors;
+  for (auto const& f : expr->as<Product>().factors())
+    if (f->is<Tensor>()) tensors.push_back(f);
+  TensorNetwork const net{tensors};
+  o::PeakBatchedModel<decltype(idxsz)> peek_model{
+      idxsz, opts.batch_policy.is_batchable_index,
+      opts.batch_policy.batch_target_size, /*is_volatile_leaf=*/{}};
+  peek_model.perf_first = true;
+  container::svector<Index> const tidxs{};
+  auto pctx = peek_model.build_context(net, tidxs);
+  auto pst = o::solve_single_term(peek_model, net, tidxs, pctx);
+  std::size_t const proot = (std::size_t{1} << pctx.nt) - 1;
+  int const pbest = peek_model.select_root(pctx, pst);
+  REQUIRE(pbest >= 0);
+  double const root_peak_bytes =
+      pst[proot][0][pbest].peak * peek_model.numeric_size;
+  REQUIRE(root_peak_bytes > 0.0);
+
+  // Assertion 1: peak_threshold strictly BELOW the term's actual peak =>
+  // gate (iv) holds => External entries ARE emitted.
+  opts.batch_policy.peak_threshold = root_peak_bytes / 2.0;
+
   auto optimized = optimize(expr, opts);
   REQUIRE(optimized);
 
@@ -2658,9 +2689,27 @@ TEST_CASE("reconstruct_axes_emits_external_per_node", "[optimize][batch]") {
   CHECK(node_with_external);
   CHECK(node_without_external);
 
-  // With the gate off, the default optimize() path stays byte-identical: no
-  // External entries anywhere (existing [optimize] tests are its witness).
+  // Assertion 2: peak_threshold = +infinity (the term never "needs" batching
+  // under any budget) with batch_spectator_indices still true => gate (iv)
+  // fails => ZERO External entries anywhere. This is exactly the OLD
+  // compute_external_batch_axis condition (iv); before the Task 4 gate,
+  // reconstruct_axes emitted External regardless of peak_threshold, so this
+  // assertion fails without the fix and passes with it.
+  axes_map->clear();
+  opts.batch_policy.peak_threshold = std::numeric_limits<double>::infinity();
+  auto optimized_inf = optimize(expr, opts);
+  REQUIRE(optimized_inf);
+  auto it_inf = axes_map->find(optimized_inf.get());
+  REQUIRE(it_inf != axes_map->end());
+  for (auto const& axes : it_inf->second)
+    for (auto const& entry : axes) CHECK(entry.second != AxisKind::External);
+
+  // Assertion 3: with the spectator gate off (batch_spectator_indices=false)
+  // -- threshold restored below the actual peak so only the flag is under
+  // test -- the default optimize() path stays byte-identical: no External
+  // entries anywhere (existing [optimize] tests are its witness).
   axes_map->clear();
+  opts.batch_policy.peak_threshold = root_peak_bytes / 2.0;
   opts.batch_policy.batch_spectator_indices = false;
   auto optimized_off = optimize(expr, opts);
   REQUIRE(optimized_off);

From 6abb853b901253633546ff616ccf3da92fe5f41f Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Sun, 12 Jul 2026 05:51:10 +0300
Subject: [PATCH 75/78] eval: scatter (not accumulate) external batch axes into
 a pre-sized result

A batch axis stamped External (AxisKind::External) on a node is a spectator
index that survives free onto the node's result -- a Hadamard/batched-matmul
mode present on every operand and the result, contracted at no node. Such an
axis must be SCATTERED: the per-block partials are disjoint slices of one
result, assembled via write_into_slice into a pre-sized destination, not
accumulated via add_inplace (correct only for a contracted axis).

make_batched_custom_evaluator now classifies the picked axis by AxisKind. A
Contracted axis (or the depth-0 heuristic fallback, which only ever yields a
contracted index) takes the existing accumulate path byte-for-byte. An External
axis takes a new scatter branch: pre-size the node's result to the axis's full
extent (from the carrying leaf's tiling), then for each block slice every
carrying leaf, evaluate the node subtree on a per-block scratch, and
write_into_slice the block partial into its slice. Inner axes still nest through
the same per-block reinstall, so External composes with Contracted.

Adds Result::pre_sized_zeros_over_mode (base throws; flat ResultTensorTA builds
a zero array with the axis widened to full) and a [batched-external] TA test
that evaluates a spectator-carrying tree with external batching on (block <
extent) and off and requires the two elementwise-equal, with a scope-guard
witness proving the on path actually blocks.
---
 .../core/eval/backends/tiledarray/result.hpp  |  23 ++++
 SeQuant/core/eval/eval.hpp                    |  92 ++++++++++++++
 SeQuant/core/eval/result.hpp                  |  23 ++++
 tests/unit/test_eval_ta.cpp                   | 118 ++++++++++++++++++
 4 files changed, 256 insertions(+)

diff --git a/SeQuant/core/eval/backends/tiledarray/result.hpp b/SeQuant/core/eval/backends/tiledarray/result.hpp
index d1626cfbab..56debce4f5 100644
--- a/SeQuant/core/eval/backends/tiledarray/result.hpp
+++ b/SeQuant/core/eval/backends/tiledarray/result.hpp
@@ -484,6 +484,29 @@ class ResultTensorTA final : public Result {
     write_array_into_mode(dest, block.get<ArrayT>(), mode, tile_lo, tile_hi);
   }
 
+  [[nodiscard]] ResultPtr pre_sized_zeros_over_mode(
+      std::size_t mode, Result const& axis_src,
+      std::size_t axis_src_mode) const override {
+    SEQUANT_ASSERT(axis_src.is<this_type>());
+    auto const& self = get<ArrayT>();
+    auto const& src = axis_src.get<ArrayT>();
+    auto const rank = self.trange().rank();
+    SEQUANT_ASSERT(mode < rank);
+    SEQUANT_ASSERT(axis_src_mode < src.trange().rank());
+    // Take *this's outer trange but swap in the external axis's FULL tiling
+    // (from axis_src's mode axis_src_mode). Every other mode of a block partial
+    // is already full extent, so only the sliced axis needs widening.
+    std::vector<TA::TiledRange1> dims;
+    dims.reserve(rank);
+    for (std::size_t d = 0; d < rank; ++d) dims.push_back(self.trange().dim(d));
+    dims[mode] = src.trange().dim(axis_src_mode);
+    ArrayT dest(self.world(), TA::TiledRange(dims.begin(), dims.end()));
+    dest.fill_local(numeric_type(0));
+    dest.world().gop.fence();
+    log_ta_tensor_host_memory_use();
+    return eval_result<this_type>(std::move(dest));
+  }
+
   [[nodiscard]] ResultPtr prod(Result const& other,
                                std::array<std::any, 3> const& annot,
                                DeNest DeNestFlag) const override {
diff --git a/SeQuant/core/eval/eval.hpp b/SeQuant/core/eval/eval.hpp
index 08b2b57591..1132dd7aad 100644
--- a/SeQuant/core/eval/eval.hpp
+++ b/SeQuant/core/eval/eval.hpp
@@ -1387,6 +1387,98 @@ template <typename F, typename IndexPredicate = accept_any_index,
     using member_t = std::pair<node_t const*, Index>;
     TreeNodeEqualityComparator<node_t> const eq;
 
+    // Classify the picked axis by AxisKind. K is a batch axis of `node`; the
+    // optimizer stamps it CONTRACTED (summed away -> block partials ACCUMULATE)
+    // or EXTERNAL (a spectator index free on the node's result -> block
+    // partials are DISJOINT slices, SCATTERED into a pre-sized result). The
+    // depth-0 heuristic fallback only ever yields a contracted index, so an
+    // axis absent from batch_axes() is Contracted -- keeping the
+    // Contracted-only path (no External entry) byte-identical to before this
+    // branch existed.
+    AxisKind picked_kind = AxisKind::Contracted;
+    for (auto const& [ix, knd] : node->batch_axes())
+      if (ix == K) {
+        picked_kind = knd;
+        break;
+      }
+
+    if (picked_kind == AxisKind::External) {
+      // SCATTER branch. K survives to node's result as a free spectator mode,
+      // so the per-block partials are disjoint slices of one result (not
+      // summands of a contraction): they are write_into_slice()d into a
+      // pre-sized result, never add_inplace()d. Inner batch axes -- of either
+      // kind, at this node or a descendant -- still nest through the same
+      // per-block reinstall the contracted path uses, so External composes with
+      // Contracted: within each external block the reinstalled evaluator slices
+      // any remaining axis (a contracted axis accumulates within the block, an
+      // inner external axis scatters into its own block-local result). K itself
+      // is not re-picked on the re-entry: le_g has sliced its carrier to this
+      // block, so the block yields a single batch on the sliced leaf and is
+      // skipped (same invariant as the contracted nesting).
+      auto const dest_mode = index_position(node, K);
+      SEQUANT_ASSERT(dest_mode &&
+                     "external batch axis is not free on the node's result");
+      auto const carrier = find_leaf_carrying(node, K);
+      SEQUANT_ASSERT(carrier && "no leaf carries the external batch axis");
+      // The unsliced carrier leaf supplies K's FULL tiling for pre-sizing.
+      ResultPtr const carrier_full = le(carrier->first);
+
+      // A single-node scratch: an external spectator axis is not a
+      // persistent-final sharing axis, so the group/replay machinery (which
+      // co-batches cross-term contracted finals) does not apply -- scatter just
+      // this node. The scratch still dedups repeats WITHIN the node's subtree.
+      std::vector<member_t> solo{{&node, K}};
+      auto bs = detail::make_batched_scratch(solo, cache);
+      for (auto const* s : bs.seeds) (void)bs.cache.store(*s, cache.access(*s));
+
+      auto const scope_guard = make_scope_guard(batches.size());
+      (void)scope_guard;
+
+      if (log::printing())
+        log::log("BatchScatter", "Begin",
+                 std::format("external axis over {} blocks", batches.size()));
+
+      ResultPtr dest;
+      for (auto const& [e_lo, e_hi] : batches) {
+        if (e_lo == e_hi) continue;
+        bs.cache.reset();
+        // Slice every leaf carrying K to this block; others pass through.
+        auto le_g = [&le, &K, e_lo = e_lo,
+                     e_hi = e_hi](auto const& leaf_node) -> ResultPtr {
+          ResultPtr r = le(leaf_node);
+          if (auto const p = index_position(leaf_node, K))
+            return r->slice_mode(*p, e_lo, e_hi);
+          return r;
+        };
+        // Reinstall on the scratch so inner axes nest WITHIN this block; le_g
+        // (already sliced to this block) is closed over so inner slices compose
+        // on top of the external one, exactly as the contracted path does.
+        bs.cache.set_custom_evaluator(make_batched_custom_evaluator(
+            std::function<ResultPtr(node_t const&)>{le_g}, target_batch_size,
+            accept, make_scope_guard, is_volatile, persistent_only, depth + 1,
+            peak));
+        ResultPtr part = evaluate(node, le_g, bs.cache);
+        // Pre-size on the first block (learns the result's non-axis extents and
+        // kind from the block partial; the external axis is widened to full).
+        if (!dest)
+          dest = part->pre_sized_zeros_over_mode(*dest_mode, *carrier_full,
+                                                 carrier->second);
+        dest->write_into_slice(*part, *dest_mode, e_lo, e_hi);
+
+        if (peak) {
+          const double cand =
+              static_cast<double>(bs.cache.working_set_hwmark());
+          double cur = peak->load(std::memory_order_relaxed);
+          while (cand > cur && !peak->compare_exchange_weak(
+                                   cur, cand, std::memory_order_relaxed)) {
+          }
+        }
+      }
+      if (log::printing()) log::log("BatchScatter", "End");
+      SEQUANT_ASSERT(dest);
+      return dest;
+    }
+
     // The replay group: the trigger plus every registered persistent key that
     // is not yet alive and batches over an axis with the identical realized
     // partition. All compatible persistent finals stream over the batch axis
diff --git a/SeQuant/core/eval/result.hpp b/SeQuant/core/eval/result.hpp
index 4eaac2a321..f72835e883 100644
--- a/SeQuant/core/eval/result.hpp
+++ b/SeQuant/core/eval/result.hpp
@@ -357,6 +357,29 @@ class Result {
     throw detail::unimplemented_method("write_into_slice");
   }
 
+  ///
+  /// \brief Build a zero-filled result shaped like \c *this but with mode
+  ///        \p mode carrying the FULL extent of an external (spectator) axis.
+  ///
+  /// Used to PRE-SIZE the destination of an external-axis scatter (see
+  /// make_batched_custom_evaluator's External branch): \c *this is one block
+  /// partial (the node's result with the external axis sliced to a single
+  /// block, but full on every other mode), and \p axis_src is the unsliced
+  /// axis-carrying leaf whose mode \p axis_src_mode holds the external axis at
+  /// its FULL extent/tiling. The returned result has \c *this's TiledRange with
+  /// dim \p mode replaced by \c axis_src's dim \p axis_src_mode, zero-filled,
+  /// so the per-block partials can be write_into_slice()d into their disjoint
+  /// slices. \p axis_src's tiling on \p axis_src_mode must be the tiling the
+  /// block partials slice from (guaranteed when both derive from the same
+  /// leaf). Not a pure virtual: only tensor-backed results need it; the default
+  /// throws. Mirrors the slice_mode()/write_into_slice() precedent.
+  ///
+  [[nodiscard]] virtual ResultPtr pre_sized_zeros_over_mode(
+      std::size_t /*mode*/, Result const& /*axis_src*/,
+      std::size_t /*axis_src_mode*/) const {
+    throw detail::unimplemented_method("pre_sized_zeros_over_mode");
+  }
+
   ///
   /// \brief Add other Result object into this object.
   ///
diff --git a/tests/unit/test_eval_ta.cpp b/tests/unit/test_eval_ta.cpp
index 3d26db8b19..6fbcfdd9ca 100644
--- a/tests/unit/test_eval_ta.cpp
+++ b/tests/unit/test_eval_ta.cpp
@@ -2539,6 +2539,124 @@ TEST_CASE("eval_batched_custom_evaluator nests two axes on one node",
   CHECK(state.live.empty());
 }
 
+TEST_CASE("batched_eval_external_axis_scatter", "[eval][batched-external]") {
+  // Task 5 exactness gate: a batch axis stamped EXTERNAL on a node is a
+  // spectator index that survives FREE onto the node's result (a Hadamard /
+  // batched-matmul mode present on every operand and the result, contracted at
+  // no node). The runtime must SCATTER the per-block partials into DISJOINT
+  // slices of a pre-sized result (write_into_slice), NOT accumulate them
+  // (add_inplace, correct only for a contracted axis). Because the blocks tile
+  // the axis without overlap, the scattered result equals the unbatched one
+  // EXACTLY -- a memory schedule, never an approximation.
+  //
+  // The spectator here is an AUXILIARY index x_1 rather than an occupied one
+  // only because canonicalize forbids a NON-auxiliary index shared among > 2
+  // tensor slots (no well-defined bra/ket slot type); a high-order aux
+  // hyperindex carried into the result IS supported. The runtime scatter
+  // mechanism under test is axis-agnostic -- occ vs aux matters only at the
+  // DP/cost level (covered by the [dryrun-occ-*] gates). Same rationale as
+  // "eval_forest_over_external_occ nests intra-term aux batching".
+  using sequant::evaluate;
+  using sequant::make_batched_custom_evaluator;
+  using TA::TArrayD;
+  using node_t = sequant::FullBinaryNode<sequant::EvalExprTA>;
+  using cache_t = sequant::CacheManager<node_t>;
+
+  auto& world = TA::get_default_world();
+  // virtual single-tiled (4); aux x multi-tiled (12 in tiles of 4 -> 3 tiles)
+  // so the external spectator axis genuinely partitions into > 1 block.
+  rand_tensor_yield<double, TA::DensePolicy> yield_{world, /*nocc=*/4,
+                                                    /*nvirt=*/4, /*naux=*/12};
+  yield_.set_max_tile(4);
+
+  // A flat, fully binary tree whose result carries aux x_1 as a pure spectator:
+  //   inner = g*h  -> {a_1, a_3, x_1}   (contracts a_2)
+  //   root  = inner*p -> {a_1, a_4, x_1} (contracts a_3)
+  // x_1 is present on g, h, p AND the result, contracted at no node; a_1, a_4
+  // are ordinary external modes. The ResultExpr LHS pins x_1 EXTERNAL (the
+  // ExprPtr binarize would instead infer it contracted); stamping x_1 External
+  // on the root and the inner node exercises the scatter branch at both levels.
+  auto const res_expr = sequant::deserialize<sequant::ResultExpr>(
+      L"R{a_1;a_4;x_1} = ((g{a_1;a_2;x_1} * h{a_2;a_3;x_1}) * p{a_3;a_4;x_1})");
+  auto node = eval_node(res_expr);  // mutable: External axis stamped below
+  std::string const target = node->annot();
+
+  auto const aux_space =
+      sequant::get_default_context().index_space_registry()->retrieve(L"x");
+  auto accept_aux = [aux_space](sequant::Index const& ix) {
+    return ix.space() == aux_space;
+  };
+
+  // The spectator axis x_1, taken from the node's free/result outer modes so
+  // the Index object matches the parsed one exactly (a plain outer mode, no
+  // protos).
+  sequant::Index axis;
+  for (auto const& ix : node->canon_indices())
+    if (accept_aux(ix) && !ix.has_proto_indices()) {
+      axis = ix;
+      break;
+    }
+  REQUIRE(axis.nonnull());
+  REQUIRE(sequant::index_position(node, axis).has_value());  // free on result
+
+  // Stamp External on the root AND the inner node (the axis appears free at
+  // both levels).
+  node->set_batch_axes({{axis, sequant::AxisKind::External}});
+  node_t* inner = nullptr;
+  auto find_inner = [&](auto&& self, node_t& n) -> void {
+    if (n.leaf()) return;
+    if (&n != &node && sequant::index_position(n, axis).has_value()) inner = &n;
+    self(self, n.left());
+    self(self, n.right());
+  };
+  find_inner(find_inner, node);
+  REQUIRE(inner != nullptr);
+  REQUIRE(sequant::index_position(*inner, axis).has_value());
+  (*inner)->set_batch_axes({{axis, sequant::AxisKind::External}});
+
+  // Reference: plain unbatched evaluation (batch_axes are ignored without a
+  // custom evaluator). Computed first so yield_'s random leaves are generated
+  // and cached, then reused by the batched run below.
+  auto const ref = evaluate(node, target, yield_)->get<TArrayD>();
+  REQUIRE(TA::norm2(ref) > 0.0);  // guard: reference is nontrivially nonzero
+
+  // Spy scope-guard: records the block count each time the evaluator FIRES
+  // (picks an axis partitioning into > 1 block). A silently-ignored External
+  // stamp would never fire -- this is the RED/GREEN witness that the ON path
+  // actually blocked.
+  std::vector<std::size_t> guard_calls;
+  auto spy = [&guard_calls](std::size_t n) {
+    guard_calls.push_back(n);
+    return sequant::no_scope_guard{};
+  };
+
+  // Two block sizes, both strictly below x_1's extent (12): 4 -> 3 blocks,
+  // 8 -> 2 blocks. Exactness must hold for every partition.
+  for (std::size_t const target_batch_size : {std::size_t{4}, std::size_t{8}}) {
+    guard_calls.clear();
+    auto cache = cache_t::empty();
+    cache.set_custom_evaluator(make_batched_custom_evaluator(
+        yield_,
+        [target_batch_size](sequant::Index const&) -> std::size_t {
+          return target_batch_size;
+        },
+        accept_aux, spy, sequant::never_volatile{}));
+    auto const res = evaluate(node, target, yield_, cache)->get<TArrayD>();
+
+    // Exactness: scattering disjoint blocks reconstructs the whole result.
+    TArrayD diff;
+    diff("i,j,k") = ref("i,j,k") - res("i,j,k");
+    REQUIRE(TA::norm2(diff) < 1e-12);
+
+    // The ON path blocked: the root fired at least once, partitioning into
+    // > 1 block (block size strictly less than x_1's extent).
+    REQUIRE_FALSE(guard_calls.empty());
+    for (auto const n : guard_calls) CHECK(n > 1);
+    std::size_t const expected_root_blocks = target_batch_size == 4 ? 3 : 2;
+    CHECK(guard_calls.front() == expected_root_blocks);
+  }
+}
+
 TEST_CASE(
     "eval_batched_custom_evaluator nested scope guards compose "
     "multiplicatively",

From 18dd6b162eafa3d5a1d2066ba5962857f59d0768 Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Sun, 12 Jul 2026 06:55:45 +0300
Subject: [PATCH 76/78] eval: include external batch axes in
 make_batched_scratch seed/sharing signature

Extend make_batched_scratch's per-node slicing signature and its
seed/consistency predicates to range over the batch's External axes as
well as its contracted member axis. A node carrying any batched External
(spectator) axis is non-invariant under the external slice, so it is
never seeded full from the real cache and never shared across
occurrences whose external signature differs; it is recomputed sliced.
The External axis set is obtained exactly as the evaluator obtains it
(partition batch_axes() by AxisKind). With no External axis in play the
list is empty and the contracted-only path is byte-identical.

Also add the ToT ResultTensorOfTensorTA::pre_sized_zeros_over_mode
override (carried from Task 5's flat-only pre-size): widen the first
block partial's outer axis mode to the carrier leaf's full tiling and
zero-fill with well-formed (empty-inner) outer tiles, a valid
destination the ToT write_into_slice scatter overwrites. CSV/PNO-CCSD
residuals use ToT tiles.

Tests (tag [eval][batched-external]): batched_scratch_no_seed_external
asserts an invariant persistent node carrying a batched External axis is
excluded from the seeds (with a no-External control that still seeds it);
batched_scratch_tot_presize_scatter drives pre_sized_zeros_over_mode +
write_into_slice for a ToT and requires exact reassembly.
---
 .../core/eval/backends/tiledarray/result.hpp  |  42 +++++
 SeQuant/core/eval/eval.hpp                    |  60 ++++++-
 tests/unit/test_eval_ta.cpp                   | 160 ++++++++++++++++++
 3 files changed, 255 insertions(+), 7 deletions(-)

diff --git a/SeQuant/core/eval/backends/tiledarray/result.hpp b/SeQuant/core/eval/backends/tiledarray/result.hpp
index 56debce4f5..de62af4b1f 100644
--- a/SeQuant/core/eval/backends/tiledarray/result.hpp
+++ b/SeQuant/core/eval/backends/tiledarray/result.hpp
@@ -707,6 +707,48 @@ class ResultTensorOfTensorTA final : public Result {
     write_array_into_mode(dest, block.get<ArrayT>(), mode, tile_lo, tile_hi);
   }
 
+  [[nodiscard]] ResultPtr pre_sized_zeros_over_mode(
+      std::size_t mode, Result const& axis_src,
+      std::size_t axis_src_mode) const override {
+    auto const& self = get<ArrayT>();
+    auto const rank = self.trange().rank();
+    SEQUANT_ASSERT(mode < rank);
+    // The axis-carrying leaf supplying K's FULL tiling for mode `mode` may be
+    // nested (this_type) or flat (that_type, e.g. an integral over the external
+    // occ index): read the widened axis TiledRange1 from whichever kind. Only
+    // this one OUTER TiledRange1 is needed; every other mode of a block partial
+    // is already at full extent, so *this's own outer tiling supplies them.
+    TA::TiledRange1 const axis_dim = [&]() -> TA::TiledRange1 {
+      if (axis_src.is<this_type>()) {
+        auto const& src = axis_src.get<ArrayT>();
+        SEQUANT_ASSERT(axis_src_mode < src.trange().rank());
+        return src.trange().dim(axis_src_mode);
+      }
+      SEQUANT_ASSERT(axis_src.is<that_type>());
+      auto const& src = axis_src.get<compatible_regular_distarray_type>();
+      SEQUANT_ASSERT(axis_src_mode < src.trange().rank());
+      return src.trange().dim(axis_src_mode);
+    }();
+    std::vector<TA::TiledRange1> dims;
+    dims.reserve(rank);
+    for (std::size_t d = 0; d < rank; ++d) dims.push_back(self.trange().dim(d));
+    dims[mode] = axis_dim;
+    // A zero ToT is represented with empty inner tiles (tot_inner_rank() == 0):
+    // build the widened OUTER trange, then give every local outer tile a
+    // well-formed (empty-inner) outer tile over its range -- exactly the zero
+    // ToT that slice_array_over_mode() emits, and a valid destination that the
+    // ToT write_array_into_mode() block-assignment overwrites per scatter. The
+    // batches tile the widened `mode` axis with no gaps, so every outer tile is
+    // subsequently overwritten by some block's real inner tensors.
+    using value_type = typename ArrayT::value_type;
+    ArrayT dest(self.world(), TA::TiledRange(dims.begin(), dims.end()));
+    for (auto it = dest.begin(); it != dest.end(); ++it)
+      if (dest.is_local(it.index())) *it = value_type{it.make_range()};
+    dest.world().gop.fence();
+    log_ta_tensor_host_memory_use();
+    return eval_result<this_type>(std::move(dest));
+  }
+
   [[nodiscard]] ResultPtr prod(Result const& other,
                                std::array<std::any, 3> const& annot,
                                DeNest DeNestFlag) const override {
diff --git a/SeQuant/core/eval/eval.hpp b/SeQuant/core/eval/eval.hpp
index 1132dd7aad..7a91afe06b 100644
--- a/SeQuant/core/eval/eval.hpp
+++ b/SeQuant/core/eval/eval.hpp
@@ -1236,23 +1236,61 @@ template <typename TreeNode, bool FHC, typename Members>
     Members const& members, CacheManager<TreeNode, FHC> const& real) {
   using Hasher = TreeNodeHasher<TreeNode, FHC>;
   using Comp = TreeNodeEqualityComparator<TreeNode>;
+
+  // The batch's EXTERNAL axes: obtained exactly as the evaluator obtains them
+  // (partition each member root's batch_axes() by AxisKind). An External axis
+  // is a spectator that survives FREE onto a node's result, so a node carrying
+  // one is NOT batch-invariant under that axis -- its value depends on the
+  // external slice. When the caller nests an External axis OUTSIDE a Contracted
+  // one (the External axis is sliced by an outer re-entry, then this scratch
+  // batches an inner Contracted axis), a persistent intermediate that carries
+  // the External axis but not the Contracted `axis` would look seedable under
+  // `axis` alone -- yet seeding its full (unsliced-external) value would be
+  // wrong under the outer slice. Tracking the External axes in the signature
+  // (below) forbids seeding/sharing such nodes. When there is no External axis
+  // this list is empty and every External-derived test is a no-op, keeping the
+  // Contracted-only behavior byte-identical.
+  container::svector<Index> ext_axes;
+  for (auto const& [root, axis] : members) {
+    if (root->leaf()) continue;
+    for (auto const& [ix, knd] : (*root)->batch_axes())
+      if (knd == AxisKind::External &&
+          std::find(ext_axes.begin(), ext_axes.end(), ix) == ext_axes.end())
+        ext_axes.push_back(ix);
+  }
+
   struct Meta {
     std::size_t count = 0;
     std::optional<std::size_t> sig;
+    // Positions of each External axis (in ext_axes order) in this node's
+    // canonical result indices, or nullopt if the node does not carry it. This
+    // is a function of the (canonical) node alone, so it is identical across
+    // all occurrences of a canonically-equal node.
+    container::svector<std::optional<std::size_t>> ext_sig;
     bool consistent = true;
   };
   std::unordered_map<TreeNode const*, Meta, Hasher, Comp> meta;
 
-  auto visit = [&meta](auto&& self, TreeNode const& n,
-                       Index const& axis) -> void {
+  auto ext_sig_of = [&ext_axes](TreeNode const& n) {
+    container::svector<std::optional<std::size_t>> s;
+    s.reserve(ext_axes.size());
+    for (auto const& e : ext_axes) s.push_back(index_position(n, e));
+    return s;
+  };
+
+  auto visit = [&meta, &ext_sig_of](auto&& self, TreeNode const& n,
+                                    Index const& axis) -> void {
     if (n.leaf()) return;
     auto const sig = index_position(n, axis);
+    auto const esig = ext_sig_of(n);
     auto const [it, first] = meta.try_emplace(&n);
     auto& e = it->second;
-    if (first)
+    if (first) {
       e.sig = sig;
-    else if (e.sig != sig)
+      e.ext_sig = esig;
+    } else if (e.sig != sig || e.ext_sig != esig) {
       e.consistent = false;
+    }
     ++e.count;
     // Prune a re-encounter only when its signature matches the first one:
     // canonical equality maps canonical position p to position p, so an equal
@@ -1263,8 +1301,10 @@ template <typename TreeNode, bool FHC, typename Members>
     // descendant sliced differently only under this (unshared, pruned)
     // occurrence could pass the guard and serve wrong slices. The extra
     // descendant counts are real accesses: an inconsistently-sliced occurrence
-    // is evaluated per occurrence, not served from the scratch at n.
-    if (!first && e.sig == sig) return;
+    // is evaluated per occurrence, not served from the scratch at n. The
+    // External signature is invariant across occurrences (a function of the
+    // canonical node), so folding it into the match only tightens the guard.
+    if (!first && e.sig == sig && e.ext_sig == esig) return;
     self(self, n.left(), axis);
     self(self, n.right(), axis);
   };
@@ -1280,7 +1320,13 @@ template <typename TreeNode, bool FHC, typename Members>
   std::vector<TreeNode const*> seeds;
   for (auto const& [ptr, e] : meta) {
     if (!e.consistent) continue;  // ambiguous slicing: never share
-    bool const seedable = !e.sig && real.persistent(*ptr) && real.alive(*ptr);
+    // A node carrying ANY batched External axis has an external slice its
+    // seeded-full real-cache value would ignore -- so it is never seedable.
+    bool const carries_ext =
+        std::any_of(e.ext_sig.begin(), e.ext_sig.end(),
+                    [](auto const& p) { return p.has_value(); });
+    bool const seedable =
+        !e.sig && !carries_ext && real.persistent(*ptr) && real.alive(*ptr);
     if (seedable) {
       seeds.push_back(ptr);
       seed_keys.insert(*ptr);
diff --git a/tests/unit/test_eval_ta.cpp b/tests/unit/test_eval_ta.cpp
index 6fbcfdd9ca..e1fbe85a40 100644
--- a/tests/unit/test_eval_ta.cpp
+++ b/tests/unit/test_eval_ta.cpp
@@ -2657,6 +2657,166 @@ TEST_CASE("batched_eval_external_axis_scatter", "[eval][batched-external]") {
   }
 }
 
+TEST_CASE("batched_scratch_no_seed_external", "[eval][batched-external]") {
+  // Task 6 (Part A) RED/GREEN witness for the SEED DECISION in
+  // make_batched_scratch. When an EXTERNAL (spectator) axis is batched, a
+  // persistent, alive intermediate that is INVARIANT under the batch's
+  // *contracted* member axis but CARRIES that batched External axis must NOT be
+  // seeded from the real cache: its full, unsliced-external value is wrong
+  // under the external slice, so it must be recomputed sliced. Before this fix
+  // the per-node signature and the `!e.sig && persistent && alive` seed rule
+  // knew only the contracted member axis, so such a node (contracted signature
+  // == absent) was wrongly seeded FULL -- the "seed full i" defect and the root
+  // of the original w8-occbatch abort. After the fix the batch's External axes
+  // enter the signature: a node carrying one is non-invariant and excluded.
+  using node_t = sequant::FullBinaryNode<sequant::EvalExprTA>;
+  using sequant::evaluate;
+  using sequant::Index;
+
+  auto& world = TA::get_default_world();
+  rand_tensor_yield<double, TA::DensePolicy> yield_{world, /*nocc=*/4,
+                                                    /*nvirt=*/4, /*naux=*/12};
+  yield_.set_max_tile(4);
+
+  // P = g*h carries the aux spectator x_1 (the External axis); the volatile
+  // head t makes P a PERSISTENT final. P does not carry the contracted batch
+  // axis played by `mu` below.
+  auto const expr = sequant::deserialize<sequant::ExprPtr>(
+      L"(g{a_2;i_1;x_1} * h{a_2;i_3}) * t{i_3;i_1}");
+  auto n = eval_node(expr);
+  REQUIRE_FALSE(n.leaf());
+  auto const& P = n.left();  // g*h, carries x_1
+  REQUIRE_FALSE(P.leaf());
+
+  // the External spectator axis carried by P (a plain aux outer mode)
+  auto const aux_space =
+      sequant::get_default_context().index_space_registry()->retrieve(L"x");
+  Index x_ext;
+  for (auto const& ix : P->canon_indices())
+    if (ix.space() == aux_space && !ix.has_proto_indices()) {
+      x_ext = ix;
+      break;
+    }
+  REQUIRE(x_ext.nonnull());
+  REQUIRE(sequant::index_position(P, x_ext).has_value());  // P carries it
+
+  // stamp x_ext External on the member root, as the optimizer would; this is
+  // the batch's External-axis set that make_batched_scratch partitions out.
+  n->set_batch_axes({{x_ext, sequant::AxisKind::External}});
+
+  // real cache: P classifies persistent (volatile head t); store a value so it
+  // is ALIVE (the state that makes a node a seed candidate).
+  auto is_volatile_t = [](node_t const& k) {
+    return k.leaf() && k->is_tensor() && k->as_tensor().label() == L"t";
+  };
+  auto real = sequant::cache_manager(std::vector{n}, is_volatile_t);
+  REQUIRE(real.persistent(P));
+  real.store(P, evaluate(P, P->annot(), yield_));
+  REQUIRE(real.alive(P));
+
+  // member axis = a contracted axis P does NOT carry (mu-analog): its per-node
+  // signature over P is 'absent', so on the contracted axis alone P looks
+  // seedable. The External axis is what must veto the seed.
+  Index const mu(L"i_9");  // absent from the tree -> null contracted signature
+  REQUIRE_FALSE(sequant::index_position(P, mu).has_value());
+  std::vector<std::pair<node_t const*, Index>> const members{{&n, mu}};
+
+  sequant::TreeNodeEqualityComparator<node_t> const eq;
+  auto seeds_P = [&](auto const& bs) {
+    return std::any_of(bs.seeds.begin(), bs.seeds.end(),
+                       [&](node_t const* s) { return eq(*s, P); });
+  };
+
+  // POST-FIX: P carries the batched External axis, so it is NOT seeded (it will
+  // be recomputed under the external slice).
+  auto const bs = sequant::detail::make_batched_scratch(members, real);
+  REQUIRE_FALSE(seeds_P(bs));
+
+  // Control: with NO External axis stamped (a purely contracted batch), the
+  // SAME invariant persistent P IS seeded -- proving the exclusion is driven by
+  // the External stamp and that the contracted-only path is byte-identical.
+  n->set_batch_axes({});
+  auto const bs2 = sequant::detail::make_batched_scratch(members, real);
+  REQUIRE(seeds_P(bs2));
+}
+
+TEST_CASE("batched_scratch_tot_presize_scatter", "[eval][batched-external]") {
+  // Task 6 (Part B): the ToT ResultTensorOfTensorTA::pre_sized_zeros_over_mode
+  // must produce a destination that the ToT scatter primitives
+  // (write_into_slice -> write_array_into_mode) reassemble EXACTLY. This is the
+  // ToT analog of the flat pre-size Task 5 added; CSV/PNO-CCSD residuals carry
+  // ToT tiles, so the external-axis scatter needs a ToT pre-size. Here we drive
+  // the exact runtime sequence: pre-size from the FIRST block partial (widening
+  // its OUTER axis mode to the carrier's FULL tiling), then write_into_slice
+  // every disjoint block. The reassembled ToT must equal the original.
+  using sequant::eval_result;
+  using sequant::ResultTensorOfTensorTA;
+  using sequant::slice_array_over_mode;
+  using ToTArray = TA::DistArray<TA::Tensor<TA::Tensor<double>>>;
+  using ResultToT = ResultTensorOfTensorTA<ToTArray>;
+  auto& world = TA::get_default_world();
+
+  // outer mode 0 (the external spectator axis): two size-3 tiles (tile-spanning
+  // split); outer mode 1: one size-2 tile. Inner tensors are 2x2 with
+  // position-dependent values so a mis-scattered block changes the norm.
+  TA::TiledRange const outer_tr{{0, 3, 6}, {0, 2}};
+  TA::Range const inner_r(std::array<std::size_t, 2>{2, 2});
+
+  auto build = [&world, inner_r](TA::TiledRange const& otr,
+                                 bool zero) -> ToTArray {
+    auto tile_fn = [inner_r, zero](TA::Range const& orng) {
+      TA::Tensor<TA::Tensor<double>> t{orng};
+      std::size_t o = 0;
+      for (auto const& coord : orng) {
+        auto& inner = t[o++];
+        inner = TA::Tensor<double>{inner_r};
+        double base = 0.0;
+        if (!zero)
+          for (auto c : coord) base = base * 37.0 + static_cast<double>(c + 1);
+        std::size_t k = 0;
+        for (auto& x : inner) x = zero ? 0.0 : base * 100.0 + (++k);
+      }
+      return t;
+    };
+    ToTArray arr{world, otr};
+    for (auto it = arr.begin(); it != arr.end(); ++it)
+      if (arr.is_local(it.index()))
+        *it = world.taskq.add(tile_fn, it.make_range());
+    world.gop.fence();
+    return arr;
+  };
+
+  ToTArray R = build(outer_tr, /*zero=*/false);
+
+  // gather the disjoint, tile-aligned blocks over outer mode 0 (the external
+  // axis), exactly as the scatter branch's per-block evaluate would produce.
+  auto const b0 = slice_array_over_mode(R, 0, 0, 1);  // outer elements [0,3)
+  auto const b1 = slice_array_over_mode(R, 0, 1, 2);  // outer elements [3,6)
+
+  // PRE-SIZE from the FIRST block partial: widen its OUTER mode 0 (sliced to
+  // [0,3)) to the carrier's full mode-0 tiling. R itself is a ToT carrier of
+  // the full external axis (axis_src.is<this_type>() branch); axis_src_mode =
+  // 0.
+  sequant::ResultPtr const first = eval_result<ResultToT>(b0);
+  sequant::ResultPtr const carrier = eval_result<ResultToT>(R);
+  auto rdest = first->pre_sized_zeros_over_mode(/*mode=*/0, *carrier,
+                                                /*axis_src_mode=*/0);
+  // the pre-sized destination spans the FULL external axis (mode 0: {0,3,6})
+  REQUIRE(rdest->get<ToTArray>().trange().dim(0).tile_extent() == 2);
+  REQUIRE(rdest->get<ToTArray>().trange().dim(1).tile_extent() == 1);
+
+  // SCATTER every block into its disjoint slice of the pre-sized destination.
+  rdest->write_into_slice(*eval_result<ResultToT>(b0), 0, 0, 3);
+  rdest->write_into_slice(*eval_result<ResultToT>(b1), 0, 3, 6);
+
+  auto const& out = rdest->get<ToTArray>();
+  ToTArray diff;
+  diff("i,j;a,b") = out("i,j;a,b") - R("i,j;a,b");
+  REQUIRE(Catch::Approx(diff("i,j;a,b").dot(diff("i,j;a,b"))) == 0.0);
+  // guard against a trivial all-zero pass (e.g. a silently no-op'd scatter).
+  REQUIRE(out("i,j;a,b").dot(out("i,j;a,b")) > 0.0);
+}
+
 TEST_CASE(
     "eval_batched_custom_evaluator nested scope guards compose "
     "multiplicatively",

From 579b7cff3706ac0c413d34114904a135d383c13b Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Sun, 12 Jul 2026 08:54:38 +0300
Subject: [PATCH 77/78] eval,optimize: retire ExternalBatchAxis forest path

The old "forest over a single external batch axis" special case has been
replaced by the unified per-node batch_axes_ (AxisKind::External) mechanism
introduced in the previous commits. Delete the now-dead code and its tests:

- optimize.hpp/.cpp: ExternalBatchAxis struct, OptimizeResult::
  external_batch_axis member, and compute_external_batch_axis.
- eval.hpp: spectator_outer_mode and evaluate_forest_over_external_axis.
- eval_expr.cpp/.hpp: outer_proto_position definition and declaration.
- test_eval_expr.cpp: eval_expr_outer_proto_position and
  eval_expr_outer_proto_position_mixed_node_guard.
- test_eval_ta.cpp: the two eval_forest_over_external_occ TEST_CASEs.
- test_optimize.cpp: the OLD "optimize emits an external batch axis for the
  PPL term" TEST_CASE.

Reworded dangling comments in cost_model.hpp and the kept
[optimize][batch] tests in test_optimize.cpp that referenced the deleted
compute_external_batch_axis by name. The new-unified-path tests
([eval][batched-external] in test_eval_ta.cpp and
reconstruct_axes_emits_external_per_node in test_optimize.cpp) are untouched.
---
 SeQuant/core/eval/eval.hpp           | 188 ----------------
 SeQuant/core/eval/eval_expr.cpp      |  32 ---
 SeQuant/core/eval/eval_expr.hpp      |  46 ----
 SeQuant/core/optimize/cost_model.hpp |  19 +-
 SeQuant/core/optimize/optimize.cpp   |  90 --------
 SeQuant/core/optimize/optimize.hpp   |  53 +----
 tests/unit/test_eval_expr.cpp        | 112 ----------
 tests/unit/test_eval_ta.cpp          | 309 ---------------------------
 tests/unit/test_optimize.cpp         |  96 ++-------
 9 files changed, 25 insertions(+), 920 deletions(-)

diff --git a/SeQuant/core/eval/eval.hpp b/SeQuant/core/eval/eval.hpp
index 7a91afe06b..8e865be9cb 100644
--- a/SeQuant/core/eval/eval.hpp
+++ b/SeQuant/core/eval/eval.hpp
@@ -1754,194 +1754,6 @@ template <class F, class ScopeGuardFactory = make_no_scope_guard>
       policy.persistent_only, /*depth=*/0, peak);
 }
 
-/// \brief Position of the spectator external axis \p axis among a node's OUTER
-/// modes, or nullopt if the node does not carry it.
-///
-/// A spectator external index can occupy a node's outer modes in two ways: as a
-/// plain top-level slot of \c canon_indices() (\c index_position), or -- on a
-/// proto-only tensor-of-tensor node whose legs are all composite (CSV/PNO/OSV),
-/// where the axis appears exclusively as a protoindex -- as one of the distinct
-/// outer protos (\c outer_proto_position). Either way the returned position is
-/// the physical outer-mode index that \c Result::slice_mode() and
-/// \c Result::write_into_slice() address as their \c mode argument.
-///
-/// \note On a MIXED node (a plain non-proto outer index NOT equal to \p axis,
-///       alongside composite proto legs) \c index_position(axis) misses, so
-///       this falls through to \c outer_proto_position, whose precondition
-///       assert fires -- a deliberate signal that the proto-only outer-mode
-///       computation does not model the true interleaved outer-trange position
-///       of a mixed node. The core external-occ spine slices only proto-only or
-///       plain-outer spectator nodes; a mixed spectator carrier requires
-///       upgrading the accessor to compute the interleaved physical position.
-template <typename Node>
-[[nodiscard]] std::optional<std::size_t> spectator_outer_mode(
-    Node const& node, Index const& axis) {
-  if (auto const p = index_position(node, axis)) return p;
-  return outer_proto_position(*node, axis);
-}
-
-/// \brief Co-evaluate a forest of residual summand trees one block of a
-/// free/spectator external axis at a time, on a single shared scratch cache,
-/// assembling each block into a pre-sized destination.
-///
-/// This is the free-axis / explicit-forest generalization of the batched-eval
-/// group/replay loop (\c make_batched_custom_evaluator). The differences:
-///
-///   - The batch axis is a Hadamard/spectator external index -- present on
-///     every operand and the result of every contraction on its path,
-///     contracted nowhere -- rather than a contracted axis. Because it is never
-///     contracted, it is not sliced node-locally by an in-tree custom evaluator
-///     (no node's DP `aprime` can carry it); it is sliced by seeding the outer
-///     block loop here and re-slicing every leaf that carries it per block.
-///   - The co-batched group is the EXPLICIT \p forest (the summands of the
-///     residual Sum), not a \c persistent()-gated cache scan, so volatile term
-///     roots are included.
-///   - The cross-batch combinator is \c Result::write_into_slice (PARTITION:
-///     the blocks are disjoint slices of \p dest), not \c add_inplace
-///     (ACCUMULATE, correct only for a contracted axis). Within a block the
-///     summands are still summed by \c add_inplace (they share the block's
-///     result layout); across blocks they are scattered into disjoint slices.
-///
-/// Per block: reset the shared scratch, evaluate every summand tree with every
-/// leaf carrying \p axis sliced to the block's element range
-/// (\c spectator_outer_mode -> \c slice_mode), sum the summands, and
-/// \c write_into_slice the summed block into \p dest's \p axis slice. Because
-/// the whole forest streams over the same block on ONE registered scratch,
-/// cross-term sub-intermediates (e.g. gC shared between summands) are built
-/// once per block and reused; the per-block reset drops the previous block's
-/// sliced partials while the registration (repeat structure) survives. Exact by
-/// `R = union_blocks R[block]` on the disjoint spectator partition, with each
-/// block itself an exact sum of its summands -- a memory schedule, never an
-/// approximation. Stays on the lazy path: each per-block \c evaluate is an
-/// ordinary decision-at-the-node traversal; \p t amplitudes stay resident in
-/// \p le.
-///
-/// \param forest        the residual summand trees (each already binarized).
-/// \param external_axis the spectator axis + per-block element extent (P1).
-/// \param shared_cache  a registered scratch cache over \p forest (typically
-///                      \c cache_manager(forest, ...)); reset() per block.
-/// \param le            the leaf evaluator (\p t stays resident here).
-/// \param dest          the pre-sized destination result (full spectator
-///                      extent); each block is scattered into its slice.
-/// \param intra_term_batching  OPTIONAL nested intra-term batching (P3). When
-///        engaged, a giant WITHIN a summand tree is additionally batched over
-///        its CONTRACTED aux/PAO/internal-occ axis INSIDE the current external
-///        block, composing the two mechanisms: the external-occ partition is
-///        the OUTER loop (this function), the intra-term batched custom
-///        evaluator is the INNER mechanism (\c make_batched_custom_evaluator),
-///        installed on the shared scratch. The parameter is a FACTORY: it is
-///        handed THIS block's leaf evaluator (already sliced to the external
-///        block), and returns the \c custom_evaluator_type to install on the
-///        shared scratch for the block; because the intra-term evaluator closes
-///        over that external-sliced leaf evaluator, its contracted-axis slices
-///        compose ON TOP of the external slice. The intra-term evaluator starts
-///        at its OWN depth 0 (the external partition is a SEPARATE outer loop,
-///        NOT part of the intra-term depth counter) and nests/caps internally
-///        (cap 8); it builds its own per-interception scratch, so nothing leaks
-///        across external blocks. It is reinstalled per block (the factory
-///        closes over the block's element range). DEFAULT (empty): the shared
-///        scratch carries no custom evaluator and this path is byte-identical
-///        to the un-nested spine (P2).
-/// \return the number of (non-empty) blocks processed (>= 1).
-template <Trace EvalTrace = Trace::Default, meta::can_evaluate_range Nodes,
-          typename F, typename N, bool FHC>
-  requires meta::leaf_node_evaluator<std::ranges::range_value_t<Nodes>, F>
-std::size_t evaluate_forest_over_external_axis(
-    Nodes const& forest, ExternalBatchAxis const& external_axis,
-    CacheManager<N, FHC>& shared_cache, F const& le, ResultPtr const& dest,
-    std::function<typename CacheManager<N, FHC>::custom_evaluator_type(
-        std::function<ResultPtr(N const&)> const&)> const& intra_term_batching =
-        {}) {
-  using node_t = std::ranges::range_value_t<Nodes>;
-  SEQUANT_ASSERT(dest);
-  SEQUANT_ASSERT(std::ranges::begin(forest) != std::ranges::end(forest));
-  Index const& axis = external_axis.axis;
-
-  // The common block-result layout: the first summand's head annotation. Every
-  // summand of a residual shares the result's index layout, so all block
-  // partials permute to this and add_inplace into one accumulator.
-  auto const& head = *std::ranges::begin(forest);
-  auto const layout = head->annot();
-  // The destination outer mode of the spectator axis (the write_into_slice
-  // `mode` argument): the same for dest and every block partial.
-  auto const dest_mode = spectator_outer_mode(head, axis);
-  SEQUANT_ASSERT(dest_mode &&
-                 "forest head does not carry the external spectator axis");
-
-  // Learn the spectator axis's tiling from the first leaf (in any tree) that
-  // carries it, then partition it into tile-aligned element blocks. A leaf's
-  // result knows the axis's true trange (tiles, lobound), so the partition
-  // snaps to whole tiles and preserves a frozen-core element lobound.
-  auto find_carrier = [&axis](auto&& self, node_t const& n)
-      -> std::optional<std::pair<node_t, std::size_t>> {
-    if (n.leaf()) {
-      if (auto const p = spectator_outer_mode(n, axis)) return std::pair{n, *p};
-      return std::nullopt;
-    }
-    if (auto l = self(self, n.left())) return l;
-    return self(self, n.right());
-  };
-  std::optional<std::pair<node_t, std::size_t>> carrier;
-  for (auto const& tree : forest)
-    if ((carrier = find_carrier(find_carrier, tree))) break;
-  SEQUANT_ASSERT(carrier && "no leaf carries the external spectator axis");
-  auto const batches =
-      le(carrier->first)
-          ->mode_batches(carrier->second, external_axis.block_size);
-
-  std::size_t n_blocks = 0;
-  for (auto const& [e_lo, e_hi] : batches) {
-    if (e_lo == e_hi) continue;
-    ++n_blocks;
-    // Fresh block: the previous block's sliced partials are dropped, the
-    // registration (shared-subtree structure) survives, so a cross-term
-    // sub-intermediate is rebuilt once for this block and reused across the
-    // summands that share it.
-    shared_cache.reset();
-
-    // Leaf evaluator that slices every leaf carrying the spectator axis to this
-    // element block; other leaves pass through. `le` (with `t` resident) is the
-    // captured underlying evaluator.
-    auto le_block = [&le, &axis, e_lo = e_lo,
-                     e_hi = e_hi](node_t const& leaf) -> ResultPtr {
-      ResultPtr r = le(leaf);
-      if (auto const p = spectator_outer_mode(leaf, axis))
-        return r->slice_mode(*p, e_lo, e_hi);
-      return r;
-    };
-
-    // Optional NESTED intra-term batching (P3): install a per-block custom
-    // evaluator on the shared scratch so a giant WITHIN a summand is batched
-    // over its CONTRACTED aux/PAO/internal-occ axis INSIDE this external block.
-    // The factory is handed this block's (external-sliced) leaf evaluator, so
-    // the intra-term contracted-axis slices compose ON TOP of the external
-    // slice. Reinstalled here (after reset, with THIS block's le_block) because
-    // le_block closes over the block's element range; the intra-term evaluator
-    // starts at its own depth 0 and manages its own per-interception scratch
-    // and depth cap, independent of this outer loop. When the factory is empty
-    // the shared scratch keeps its (empty) custom evaluator and the loop stays
-    // byte-identical to the un-nested spine.
-    if (intra_term_batching) {
-      std::function<ResultPtr(N const&)> le_block_erased = le_block;
-      shared_cache.set_custom_evaluator(intra_term_batching(le_block_erased));
-    }
-
-    ResultPtr block_acc;
-    for (auto const& tree : forest) {
-      ResultPtr part =
-          evaluate<EvalTrace>(tree, layout, le_block, shared_cache);
-      if (!block_acc)
-        block_acc = std::move(part);
-      else
-        block_acc->add_inplace(*part);
-    }
-    SEQUANT_ASSERT(block_acc);
-    dest->write_into_slice(*block_acc, *dest_mode, e_lo, e_hi);
-  }
-  SEQUANT_ASSERT(n_blocks >= 1);
-  return n_blocks;
-}
-
 }  // namespace sequant
 
 #endif  // SEQUANT_EVAL_EVAL_HPP
diff --git a/SeQuant/core/eval/eval_expr.cpp b/SeQuant/core/eval/eval_expr.cpp
index 795ef4a9fc..b427f5b4a3 100644
--- a/SeQuant/core/eval/eval_expr.cpp
+++ b/SeQuant/core/eval/eval_expr.cpp
@@ -133,38 +133,6 @@ EvalExpr::index_vector const& EvalExpr::canon_indices() const noexcept {
   return canon_indices_;
 }
 
-std::optional<std::size_t> outer_proto_position(EvalExpr const& node,
-                                                Index const& ix) {
-  // Precondition: node has no plain (non-proto) outer mode -- every leg of
-  // canon_indices() must carry proto indices. On a MIXED node (plain outer
-  // index alongside proto outer modes) the "position among distinct protos"
-  // computed below does not correspond to the physical ToT outer-trange
-  // position that slice_mode()/write_into_slice() address, so fail loudly
-  // here instead of silently returning a wrong mode. See the \warning on the
-  // declaration in eval_expr.hpp.
-  SEQUANT_ASSERT(std::ranges::all_of(
-      node.canon_indices(),
-      [](Index const& leg) { return leg.has_proto_indices(); }));
-
-  // Enumerate the node's distinct outer protoindices in canonical order: walk
-  // canon_indices() (already canonical -- no re-canonicalization here) and, for
-  // each composite (proto-bearing) leg, append its proto_indices() that have
-  // not been seen yet, preserving the order of first appearance. That
-  // deduplicated sequence is the outer-mode order of the tensor-of-tensor
-  // array, so the match position is the `mode` argument slice_mode() addresses.
-  container::svector<Index> distinct;
-  for (auto const& leg : node.canon_indices()) {
-    if (!leg.has_proto_indices()) continue;
-    for (auto const& proto : leg.proto_indices())
-      if (std::ranges::find(distinct, proto) == distinct.end())
-        distinct.push_back(proto);
-  }
-
-  for (std::size_t p = 0; p < distinct.size(); ++p)
-    if (distinct[p] == ix) return p;
-  return std::nullopt;
-}
-
 EvalExpr::EvalExpr(Tensor const& tnsr)
     : op_type_{std::nullopt},
       result_type_{ResultType::Tensor},
diff --git a/SeQuant/core/eval/eval_expr.hpp b/SeQuant/core/eval/eval_expr.hpp
index db71c082e8..45da61728c 100644
--- a/SeQuant/core/eval/eval_expr.hpp
+++ b/SeQuant/core/eval/eval_expr.hpp
@@ -316,52 +316,6 @@ struct EvalOpSetter {
   void reset(EvalExpr& expr) { expr.op_type_ = std::nullopt; }
 };
 
-///
-/// \brief Position of \p ix among \p node's distinct outer protoindices, in
-///        canonical order, or nullopt if \p ix is not one of them.
-///
-/// \details Proto-aware sibling of \c index_position (which scans top-level
-///          canonical slots only). A spectator index can appear on a node
-///          exclusively as a protoindex of composite (CSV/PNO/OSV) legs like
-///          `a<i,j>`, with no top-level slot in \c canon_indices() -- so
-///          \c index_position misses it. For a PROTO-ONLY node (every leg of
-///          \c canon_indices() is composite, e.g. the PPL residual W) the
-///          tensor-of-tensor array's OUTER modes are precisely the distinct
-///          protoindices of its composite legs, in canonical order; that is
-///          the position \c Result::slice_mode()/\c write_into_slice() address
-///          as their `mode` argument.
-///
-///          The distinct outer protoindices are enumerated by walking
-///          \c canon_indices() (whose order is already canonical -- this does
-///          NOT rerun slot canonicalization), collecting the \c proto_indices()
-///          of each composite leg, and deduplicating while preserving the
-///          canonical order of first appearance. The returned position indexes
-///          that deduplicated sequence.
-///
-/// \pre Every index in \p node.canon_indices() carries proto indices (i.e.
-///      \p node has no plain, non-proto outer mode). Violating this aborts
-///      (via \c SEQUANT_ASSERT) rather than returning a silently wrong
-///      position.
-///
-/// \warning On a MIXED node -- one that carries both a plain non-proto
-///          top-level outer index and proto outer modes -- the "position
-///          among distinct protos" computed here does NOT correspond to the
-///          physical ToT outer-trange position that \c slice_mode() addresses
-///          (the plain outer index also occupies an outer trange mode, but is
-///          not counted by this function). Computing the correct physical
-///          position for a mixed node requires interleaving the plain and
-///          proto outer modes in their true trange order, which this
-///          function does not attempt; such callers must not use this
-///          accessor as-is.
-///
-/// \param node A (typically tensor-of-tensor) EvalExpr node with no plain
-///             (non-proto) outer modes; see \pre.
-/// \param ix   The index to locate among \p node's distinct outer protos.
-/// \return The 0-based outer-mode position of \p ix, or nullopt if absent.
-///
-[[nodiscard]] std::optional<std::size_t> outer_proto_position(
-    EvalExpr const& node, Index const& ix);
-
 struct BinarizationOptions {
   /// Whether to merge indices of intermediate tensors into a single list
   /// (stored as aux indices) instead of retaining the bra, ket and aux
diff --git a/SeQuant/core/optimize/cost_model.hpp b/SeQuant/core/optimize/cost_model.hpp
index 9a406a6bf0..012e951eda 100644
--- a/SeQuant/core/optimize/cost_model.hpp
+++ b/SeQuant/core/optimize/cost_model.hpp
@@ -1090,16 +1090,15 @@ struct PeakBatchedModel {
                    container::vector<State> const& st) const {
     std::size_t const root = (std::size_t{1} << ctx.nt) - 1;
     int const best = select_root(ctx, st);  // shared helper (see below)
-    // Term-level "should batch spectator axes" gate, reproducing the OLD
-    // compute_external_batch_axis conditions (ii) perf-first objective and
-    // (iv) unseeded root peak (bytes) exceeds peak_threshold, on top of (i)
-    // batch_spectator_indices already required below. select_root(ctx, st)
-    // above defaults to root_B=0 (unseeded) and this is the SAME model
-    // (same perf_first / peak_threshold / numeric_size) that
-    // seeded_root_peak_batched reads via select_root(ctx, st, /*root_B=*/0),
-    // so st[root][0][best].peak * numeric_size is exactly the byte-peak the
-    // old path compared to peak_threshold -- no extra seeded-model pass
-    // needed to reproduce (iv).
+    // Term-level "should batch spectator axes" gate: emit only when the
+    // perf-first objective is selected AND the selected root's unseeded byte
+    // peak exceeds peak_threshold, on top of batch_spectator_indices already
+    // being required below. select_root(ctx, st) above defaults to root_B=0
+    // (unseeded) and this is the SAME model (same perf_first / peak_threshold
+    // / numeric_size) that seeded_root_peak_batched reads via
+    // select_root(ctx, st, /*root_B=*/0), so st[root][0][best].peak *
+    // numeric_size is exactly the byte-peak compared to peak_threshold here
+    // -- no extra seeded-model pass needed.
     double const root_peak_bytes = st[root][0][best].peak * numeric_size;
     bool const emit_external = batch_spectator_indices && perf_first &&
                                (root_peak_bytes > peak_threshold);
diff --git a/SeQuant/core/optimize/optimize.cpp b/SeQuant/core/optimize/optimize.cpp
index 3a9870b4aa..6df8cf6442 100644
--- a/SeQuant/core/optimize/optimize.cpp
+++ b/SeQuant/core/optimize/optimize.cpp
@@ -268,92 +268,6 @@ ExprPtr optimize_impl(ExprPtr const& expr, OptimizeOptions const& opts,
   return expr->clone();
 }
 
-/// Task 4 (forest batching): decide whether \p expr's optimized form should be
-/// evaluated blocked over a spectator external axis, and if so which axis and
-/// block size. Returns std::nullopt unless ALL of the trigger conditions hold
-/// (see the doc of the public \ref optimize_result). The perf-first
-/// PeakBatchedModel is built EXACTLY as single_term_opt's DenseTimeSpaceBatched
-/// arm builds it, so the chosen factorization the caller keeps and this
-/// analysis agree.
-std::optional<ExternalBatchAxis> compute_external_batch_axis(
-    ExprPtr const& expr, OptimizeOptions const& opts) {
-  // (i) disabled.
-  if (!opts.batch_policy.batch_spectator_indices) return std::nullopt;
-  // (ii) perf-first batched objective only. peak_threshold is NOT a
-  // factorization gate for this objective; it is consulted below only to decide
-  // WHEN to emit the axis.
-  if (opts.objective_function != ObjectiveFunction::DenseTimeSpaceBatched)
-    return std::nullopt;
-  // (iii) a single tensor Product with at least one factorization (>= 3
-  // tensors); anything else has no giant to batch.
-  if (!expr->is<Product>()) return std::nullopt;
-  container::svector<ExprPtr> tensors;
-  for (auto const& f : expr->as<Product>().factors())
-    if (f->is<Tensor>()) tensors.push_back(f);
-  if (tensors.size() < 3) return std::nullopt;
-  TensorNetwork net{tensors};
-
-  // Build the perf-first batched model with the same knobs single_term.hpp's
-  // DenseTimeSpaceBatched arm uses (idxsz, batch policy, inner_pow, roofline,
-  // accumulation_factor, peak_threshold); perf_first is set to true.
-  using Model = opt::detail::PeakBatchedModel<index_to_extent_t>;
-  Model model{opts.idx_to_extent,
-              opts.batch_policy.is_batchable_index,
-              opts.batch_policy.batch_target_size,
-              opts.batch_policy.is_volatile_leaf,
-              opts.inner_pow,
-              opts.volatile_weight,
-              opts.roofline.machine_balance,
-              opts.roofline.fast_mem_elems,
-              opts.roofline.block_tiles,
-              opts.roofline.block_prefactor,
-              opts.batch_policy.persistent_only,
-              opts.peak_flops_tolerance,
-              opts.batch_policy.accumulation_factor,
-              opts.batch_policy.peak_threshold};
-  model.perf_first = true;
-
-  container::svector<Index> const tidxs{};
-  auto ctx = model.build_context(net, tidxs);
-
-  // (iii, cont.) find a genuine external-occupied spectator axis: open on the
-  // root, contracted at no node (is_spectator_axis), and in a pure-occupied
-  // space. The proto pass of batchable_index_list admits such a protoindex to
-  // ctx.aux regardless of is_batchable, so it is discoverable here.
-  auto isr = get_default_context().index_space_registry();
-  std::optional<Index> occ_axis;
-  for (std::size_t k = 0; k < ctx.m; ++k) {
-    if (isr && !isr->is_pure_occupied(ctx.aux[k].space())) continue;
-    if (!model.is_spectator_axis(ctx, k)) continue;
-    occ_axis = ctx.aux[k];
-    break;
-  }
-  if (!occ_axis) return std::nullopt;
-
-  // The per-block extent for the spectator comes from batch_target_size, like
-  // any batchable index; snap it down to the axis extent.
-  std::size_t const target =
-      opts.batch_policy.batch_target_size
-          ? opts.batch_policy.batch_target_size(*occ_axis)
-          : 0;
-  if (target == 0) return std::nullopt;
-  std::size_t const ext =
-      opts.idx_to_extent ? opts.idx_to_extent(*occ_axis) : target;
-  std::size_t const block = ext > 0 ? std::min(target, ext) : target;
-
-  // Seed the axis into the DP root frontier to size the tree under the occ
-  // slice, and read the UNSEEDED peak for the trigger gate.
-  auto sr = opt::detail::seeded_root_peak_batched(model, net, tidxs, *occ_axis,
-                                                  block);
-
-  // (iv) only emit when the term actually needs batching to fit the budget:
-  // the unseeded (whole) peak exceeds peak_threshold. (+inf default => never.)
-  if (!(sr.unseeded_peak_bytes > opts.batch_policy.peak_threshold))
-    return std::nullopt;
-
-  return ExternalBatchAxis{sr.seeded_axis.value_or(*occ_axis), block};
-}
-
 }  // namespace
 
 ExprPtr optimize(ExprPtr const& expr, OptimizeOptions opts) {
@@ -367,10 +281,6 @@ OptimizeResult optimize_result(ExprPtr const& expr, OptimizeOptions opts) {
   OptimizeResult res;
   res.expr = optimize_impl(expr, opts, opts.reorder == ReorderSum::Reorder,
                            /*parallel_outer=*/true);
-  // The forest signal is derived from the ORIGINAL term's tensor network (the
-  // batched DP is order-independent), so it does not depend on the chosen
-  // parenthesization above.
-  res.external_batch_axis = compute_external_batch_axis(expr, opts);
   return res;
 }
 
diff --git a/SeQuant/core/optimize/optimize.hpp b/SeQuant/core/optimize/optimize.hpp
index d4584980e2..e40da552c2 100644
--- a/SeQuant/core/optimize/optimize.hpp
+++ b/SeQuant/core/optimize/optimize.hpp
@@ -10,29 +10,9 @@
 
 namespace sequant {
 
-/// A forest-level batching signal: the single spectator external index (an
-/// index that is open on the whole network's result but contracted at NO node
-/// -- e.g. one carried only as a composite protoindex on the result) over which
-/// the whole optimized term should be evaluated in blocks of \c block_size, so
-/// every intermediate carrying that axis shrinks by ~block_size/extent while
-/// total work is unchanged (partitioning a spectator is work-neutral). Because
-/// a never-contracted axis has no eval node to hang on, this is reported per
-/// optimized term rather than as a per-node \c EvalExpr::batch_axes entry; the
-/// runtime and downstream consumers read it here.
-struct ExternalBatchAxis {
-  /// The spectator external axis to block over.
-  Index axis;
-  /// The per-block extent (== \c batch_target_size(axis), snapped down to the
-  /// axis extent).
-  std::size_t block_size = 0;
-};
-
-/// Result of \ref optimize_result: the optimized expression plus an optional
-/// \ref ExternalBatchAxis (empty when no spectator-index batching was
-/// selected).
+/// Result of \ref optimize_result: the optimized expression.
 struct OptimizeResult {
   ExprPtr expr;
-  std::optional<ExternalBatchAxis> external_batch_axis;
 };
 
 /// Optimize the expression for lower evaluation cost.
@@ -45,36 +25,9 @@ struct OptimizeResult {
 /// \return Optimized expression.
 ExprPtr optimize(ExprPtr const& expr, OptimizeOptions opts = {});
 
-/// Forest-batching entry point: optimize \p expr, and additionally report an
-/// optional \ref ExternalBatchAxis --- the spectator external axis over which
-/// the whole term should be evaluated in blocks of
-/// \c opts.batch_policy.batch_target_size(axis) (snapped down to the axis
-/// extent).
-///
-/// The axis is emitted only when ALL of the following hold:
-///   (i)   \p opts.batch_policy.batch_spectator_indices == true (false =
-///         disabled; then \c external_batch_axis is empty and the optimized
-///         expression is byte-identical to \ref optimize);
-///   (ii)  \p opts.objective_function == \c DenseTimeSpaceBatched (the
-///         perf-first batched objective);
-///   (iii) \p expr is a single tensor Product with a genuine spectator external
-///         axis (open on the root, contracted at no node); and
-///   (iv)  the perf-first factorization's UNSEEDED peak exceeds
-///         \p opts.batch_policy.peak_threshold --- i.e. the term actually needs
-///         batching to fit the budget. (perf-first ignores \c peak_threshold
-///         for FACTORIZATION selection; it is consulted here only to decide
-///         WHEN to emit the axis.)
-/// Otherwise \c external_batch_axis is empty.
-///
-/// The chosen factorization (\c OptimizeResult::expr) is byte-identical to what
-/// \ref optimize produces under the same \p opts; only the extra signal is
-/// computed.
+/// \copydoc optimize(ExprPtr const&, OptimizeOptions)
 ///
-/// \param expr Expression to be optimized.
-/// \param opts Optimization parameters; see \ref OptimizeOptions. The spectator
-///             per-block extent comes from
-///             \c opts.batch_policy.batch_target_size(axis).
-/// \return The optimized expression paired with the optional forest signal.
+/// \return The optimized expression, wrapped in \ref OptimizeResult.
 OptimizeResult optimize_result(ExprPtr const& expr, OptimizeOptions opts = {});
 
 /// \copydoc optimize(ExprPtr const&, OptimizeOptions)
diff --git a/tests/unit/test_eval_expr.cpp b/tests/unit/test_eval_expr.cpp
index 621b0adece..4c81ac7847 100644
--- a/tests/unit/test_eval_expr.cpp
+++ b/tests/unit/test_eval_expr.cpp
@@ -560,118 +560,6 @@ TEST_CASE("eval_expr", "[EvalExpr]") {
   }
 }
 
-TEST_CASE("eval_expr_outer_proto_position",
-          "[EvalExpr][outer-proto-position]") {
-  using namespace sequant;
-
-  // A proto-only spectator node: both legs are PNO-like composites
-  // a_1<i_1,i_2> and a_2<i_1,i_2> that share the occ protos i_1, i_2. The occ
-  // indices appear ONLY as protoindices; there is no top-level occ slot. Yet
-  // the tensor-of-tensor array's outer modes are exactly these distinct protos,
-  // in canonical order, which is what slice_mode()/write_into_slice() address.
-  //
-  // Build the node directly via the low-level EvalExpr ctor with canon_indices
-  // = the two composite legs, mirroring a real contraction intermediate (e.g.
-  // the PPL residual W) whose proto-only externals are dropped from the result
-  // slots by binarize (target_indices, eval_expr.cpp). The leaf ctor is NOT
-  // used here: its per-tensor slot canonicalization promotes the shared protos
-  // to top-level named slots, which is not the proto-only shape under test.
-  auto const tnsr = parse_tensor(L"W{a_1<i_1,i_2>;a_2<i_1,i_2>}",
-                                 {.def_perm_symm = Symmetry::Nonsymm});
-  EvalExpr::index_vector composite_legs;
-  for (auto const& ix : tnsr.const_indices())
-    if (ix.has_proto_indices()) composite_legs.push_back(ix);
-  EvalExpr const node{EvalOp::Product,
-                      ResultType::Tensor,
-                      tnsr.clone(),
-                      composite_legs,  //
-                      /*phase=*/1,     //
-                      /*hash=*/0,      //
-                      /*connectivity=*/nullptr};
-
-  // The node is a tensor-of-tensor whose canonical legs are all composite (they
-  // each carry proto indices) -- so there is no top-level plain occ slot.
-  REQUIRE(node.tot());
-  auto const& legs = node.canon_indices();
-  REQUIRE(legs.size() == 2);
-  REQUIRE(std::all_of(legs.begin(), legs.end(),
-                      [](Index const& ix) { return ix.has_proto_indices(); }));
-
-  // The occ protos, in the order they appear on a leg == their canonical outer
-  // order (both legs share the same, canonicalized, proto list).
-  Index const i1 = legs.front().proto_indices().front();
-  Index const i2 = legs.front().proto_indices().back();
-  REQUIRE(i1 != i2);
-
-  // Distinct outer protos in canonical order: {i1, i2} -> positions 0, 1.
-  auto const p1 = outer_proto_position(node, i1);
-  REQUIRE(p1.has_value());
-  REQUIRE(*p1 == 0);
-
-  auto const p2 = outer_proto_position(node, i2);
-  REQUIRE(p2.has_value());
-  REQUIRE(*p2 == 1);
-
-  // An index that is not one of the node's outer protos -> nullopt.
-  Index const absent{L"i_5"};
-  REQUIRE_FALSE(outer_proto_position(node, absent).has_value());
-
-  // The occ proto has no top-level slot: it does not appear as a top-level
-  // entry of canon_indices() (the proto-only property that makes index_position
-  // -- which scans top-level slots only -- miss it).
-  REQUIRE(std::none_of(legs.begin(), legs.end(),
-                       [&](Index const& ix) { return ix == i1; }));
-}
-
-TEST_CASE("eval_expr_outer_proto_position_mixed_node_guard",
-          "[EvalExpr][outer-proto-position]") {
-  using namespace sequant;
-
-  // A MIXED node: one plain (non-proto) top-level outer index p_1 alongside a
-  // composite proto-bearing leg a_1<i_1,i_2>. Unlike the proto-only node
-  // above, here "position among distinct protos" does not correspond to the
-  // node's physical ToT outer-trange position (the plain leg p_1 also
-  // occupies an outer trange mode, uncounted by outer_proto_position), so the
-  // accessor must refuse to answer instead of silently mis-slicing. Built via
-  // the same low-level EvalExpr ctor technique as the proto-only case, but
-  // keeping BOTH legs (not filtering to composites only) so canon_indices()
-  // actually mixes a plain index with a proto-bearing one.
-  auto const tnsr = parse_tensor(L"W{p_1;a_1<i_1,i_2>}",
-                                 {.def_perm_symm = Symmetry::Nonsymm});
-  EvalExpr::index_vector mixed_legs;
-  for (auto const& ix : tnsr.const_indices()) mixed_legs.push_back(ix);
-  EvalExpr const node{EvalOp::Product,
-                      ResultType::Tensor,
-                      tnsr.clone(),
-                      mixed_legs,   //
-                      /*phase=*/1,  //
-                      /*hash=*/0,   //
-                      /*connectivity=*/nullptr};
-
-  auto const& legs = node.canon_indices();
-  REQUIRE(legs.size() == 2);
-
-  // Confirm this is genuinely mixed: NOT all legs carry proto indices (that
-  // is precisely the precondition outer_proto_position's guard checks).
-  bool const all_have_protos =
-      std::all_of(legs.begin(), legs.end(),
-                  [](Index const& ix) { return ix.has_proto_indices(); });
-  REQUIRE_FALSE(all_have_protos);
-
-  Index const i1 = [&] {
-    for (auto const& ix : legs)
-      if (ix.has_proto_indices()) return ix.proto_indices().front();
-    throw std::logic_error("no proto-bearing leg found");
-  }();
-
-  // Misuse on a mixed node must fail loudly (SEQUANT_ASSERT throws in this
-  // build, SEQUANT_ASSERT_BEHAVIOR=THROW) rather than silently returning a
-  // wrong outer-trange position.
-  if (sequant::assert_behavior() == sequant::AssertBehavior::Throw) {
-    REQUIRE_THROWS_AS(outer_proto_position(node, i1), sequant::Exception);
-  }
-}
-
 TEST_CASE("eval_expr_batch_axes_typed", "[EvalExpr][batch-axes]") {
   using namespace sequant;
   auto const tnsr =
diff --git a/tests/unit/test_eval_ta.cpp b/tests/unit/test_eval_ta.cpp
index e1fbe85a40..96c67d8e51 100644
--- a/tests/unit/test_eval_ta.cpp
+++ b/tests/unit/test_eval_ta.cpp
@@ -3551,312 +3551,3 @@ TEST_CASE("shape_provider_denest_to_flat", "[shape-provider]") {
     REQUIRE(equal_tarrays(res, ref, "i,j"));
   }
 }
-
-// Task 8 (P3) crux-3 gate: numeric invariance of the free/spectator external
-// axis forest evaluator. A small forest of two summand trees shares an EXTERNAL
-// spectator occupied index i_1 (present -- as a composite protoindex -- on
-// every operand and result, contracted NOWHERE) and a cross-term
-// sub-intermediate S = g*h. Evaluated UNBATCHED (multi-root sum) it is the
-// reference R = F1 + F2. evaluate_forest_over_external_axis partitions i_1 into
-// blocks, co-evaluates the forest one block at a time on a shared scratch (S
-// built once per block, reused by both summands), sums the summands per block,
-// and write_into_slice's each block into the pre-sized destination. The
-// assembled destination must equal R ELEMENTWISE for every block size -- a
-// memory schedule, not an approximation. The occupied outer mode i_1 is
-// multi-tiled (occ_tile_size > 1) so blocks are tile-aligned multi-element
-// (and, for one size, tile-spanning).
-TEST_CASE("eval_forest_over_external_occ", "[eval][forest-external-occ]") {
-  using sequant::eval_result;
-  using sequant::evaluate;
-  using sequant::evaluate_forest_over_external_axis;
-  using sequant::ExternalBatchAxis;
-  using sequant::ResultPtr;
-  using node_t = sequant::FullBinaryNode<sequant::EvalExprTA>;
-
-  auto& world = TA::get_default_world();
-  // occ i_1 extent 6 in tiles of <= 2 -> 3 tiles (occ_tile_size == 2 > 1); the
-  // virtual (OSV) space extent 3 (single-occ protos a<i_1>).
-  rand_tensor_yield<double, TA::DensePolicy> yield{world, /*nocc=*/6,
-                                                   /*nvirt=*/3};
-  yield.set_max_tile(2);
-
-  using ArrayToT = typename decltype(yield)::array_tot_type;
-  using ResultToT = sequant::ResultTensorOfTensorTA<ArrayToT>;
-
-  // Two summand trees sharing S = g*h (a proto-only ToT carrying i_1 as its
-  // sole outer/spectator mode). Every leg is a single-occ OSV composite a<i_1>,
-  // so i_1 is a pure spectator: an outer Hadamard mode, contracted at no node.
-  // The contracted indices are the inner virtuals (a_2, a_4).
-  //   F1 = (g{a1<i1>;a2<i1>} * h{a2<i1>;a4<i1>}) * p{a4<i1>;a5<i1>}
-  //   F2 = (g{a1<i1>;a2<i1>} * h{a2<i1>;a4<i1>}) * r{a4<i1>;a5<i1>}
-  // Both produce {a1<i1>;a5<i1>}; R = F1 + F2.
-  auto const e1 = sequant::deserialize<sequant::ExprPtr>(
-      L"(g{a1<i1>;a2<i1>} * h{a2<i1>;a4<i1>}) * p{a4<i1>;a5<i1>}");
-  auto const e2 = sequant::deserialize<sequant::ExprPtr>(
-      L"(g{a1<i1>;a2<i1>} * h{a2<i1>;a4<i1>}) * r{a4<i1>;a5<i1>}");
-  auto const n1 = eval_node(e1);
-  auto const n2 = eval_node(e2);
-  std::vector<node_t> const forest{n1, n2};
-
-  // The spectator axis: i_1, extracted from a composite leg's protos (so the
-  // Index object exactly matches the parsed one). Also confirm proto-only
-  // shape.
-  sequant::Index axis;
-  for (auto const& leg : n1->canon_indices())
-    if (leg.has_proto_indices()) {
-      axis = leg.proto_indices()[0];
-      break;
-    }
-  REQUIRE(axis.nonnull());
-  REQUIRE(
-      axis.space() ==
-      sequant::get_default_context().index_space_registry()->retrieve(L"i"));
-  // Structural precondition: the shared sub-intermediate S = g*h repeats across
-  // the forest (cache_manager registers it with max_life 2), so a per-block
-  // shared scratch builds it once per block and reuses it across F1 and F2.
-  {
-    sequant::TreeNodeEqualityComparator<node_t> const eq;
-    REQUIRE(eq(n1.left(), n2.left()));  // both left children are S
-    auto cm = sequant::cache_manager(forest, 2);
-    REQUIRE(cm.max_life(n1.left()) == 2);
-  }
-  // The ToT annotation convention (NestedTensorIndices -> indices_annot) hoists
-  // the spectator's protoindex into a plain top-level outer slot of the TA
-  // node's canon_indices (so the "outer;inner" annotation can name it as an
-  // outer mode). So i_1 is addressed as outer mode 0 directly by
-  // index_position; the proto-only outer_proto_position fallback (Task 7) is
-  // not needed for these hoisted nodes and its mixed-node guard is never
-  // tripped (the spine consults index_position first). Calling
-  // outer_proto_position directly on this hoisted (mixed: plain i_1 + composite
-  // legs) node WOULD trip its proto-only precondition guard, which is exactly
-  // why the spine's spectator_outer_mode tries index_position first.
-  REQUIRE(sequant::index_position(n1, axis) == std::size_t{0});
-
-  // Unbatched reference R = F1 + F2 (each in the head's natural layout).
-  std::string const target = n1->annot();
-  ResultPtr ref = evaluate(n1, target, yield);
-  ref->add_inplace(*evaluate(n2, target, yield));
-  auto const& R = ref->get<ArrayToT>();
-  double const ref_dot = R(target).dot(R(target));
-  REQUIRE(ref_dot > 0.0);  // guard: reference is nontrivially nonzero
-
-  // block sizes (in elements of i_1, extent 6, tiles of 2):
-  //   1000 -> 1 block (no partition; the trivial schedule)
-  //   4    -> 2 blocks [0,4),[4,6) (first block SPANS two tiles)
-  //   2    -> 3 blocks [0,2),[2,4),[4,6) (one tile each)
-  for (std::size_t const block_size :
-       {std::size_t{1000}, std::size_t{4}, std::size_t{2}}) {
-    // Pre-sized, ZERO destination with R's exact ToT structure (R - R). A block
-    // that silently no-op'd would leave a zero region and fail the equality.
-    ArrayToT dest_arr;
-    dest_arr(target) = R(target) - R(target);
-    world.gop.fence();
-    auto dest = eval_result<ResultToT>(dest_arr);
-
-    // Fresh registered scratch per run (registration = the shared-subtree map;
-    // the evaluator reset()s alive values between blocks).
-    auto scratch = sequant::cache_manager(forest, 2);
-    ExternalBatchAxis const ext{axis, block_size};
-    auto const n_blocks =
-        evaluate_forest_over_external_axis(forest, ext, scratch, yield, dest);
-
-    // partition sanity: expected block counts for the tiling above.
-    std::size_t const expected_blocks =
-        (block_size >= 6) ? 1 : (block_size == 4 ? 2 : 3);
-    REQUIRE(n_blocks == expected_blocks);
-
-    // ELEMENTWISE numeric invariance: ||dest - R||^2 == 0 exactly (ToT norm via
-    // self-dot of the difference; TA::norm2 is unsupported for ToT tiles).
-    auto const& out = dest->get<ArrayToT>();
-    ArrayToT diff;
-    diff(target) = out(target) - R(target);
-    world.gop.fence();
-    REQUIRE(Catch::Approx(diff(target).dot(diff(target))).margin(1e-12) == 0.0);
-    // and the assembled result is nonzero (guards a trivial all-zero pass).
-    REQUIRE(out(target).dot(out(target)) == Catch::Approx(ref_dot));
-  }
-}
-
-// P3 nesting gate: intra-term (contracted-aux) batching NESTED inside the
-// external forest loop. Each summand carries BOTH (i) a shared external
-// spectator x_9 -- a Hadamard outer mode present on every operand and the
-// result, contracted at no node -- AND (ii) a contracted aux axis x_1 whose
-// intermediate S = g*h carries x_1 free (a batching target). The external
-// partition is the OUTER loop; WITHIN each external block the intra-term
-// batched custom evaluator slices x_1 on the shared scratch. The assembled
-// destination must equal the unbatched reference R = F1 + F2 ELEMENTWISE for
-// every external block size (a memory schedule, never an approximation), and
-// the intra-term evaluator must ACTUALLY FIRE inside each block (proven by a
-// spy scope guard that records every firing). external axis tiled (> 1 tile).
-//
-// NOTE on the external axis space: the spectator here is an AUXILIARY index
-// (x_9), NOT an occupied one. TNv3::canonicalize_slots deliberately forbids a
-// *non-auxiliary* index shared among >2 tensor slots (it has no well-defined
-// bra/ket slot type); a high-order AUX hyperindex carried into the result IS
-// supported (same case exercised in "eval_with_tiledarray"). The forest +
-// nested-batching MECHANISM under test is axis-agnostic, so an aux spectator
-// exercises it identically. Occupied-external RECOGNITION and SIZING (where
-// the occ-vs-aux distinction actually matters) are covered at the DP/cost
-// level by the [dryrun-occ-recognize] / [dryrun-occ-sizing] gates.
-TEST_CASE("eval_forest_over_external_occ nests intra-term aux batching",
-          "[eval][forest-external-occ][forest-external-occ-nested]") {
-  using sequant::eval_result;
-  using sequant::evaluate;
-  using sequant::evaluate_forest_over_external_axis;
-  using sequant::ExternalBatchAxis;
-  using sequant::make_batched_custom_evaluator;
-  using sequant::ResultPtr;
-  using node_t = sequant::FullBinaryNode<sequant::EvalExprTA>;
-  using cache_t = sequant::CacheManager<node_t>;
-
-  auto& world = TA::get_default_world();
-  // aux x (both x_9 and x_1 live in this space) extent 6 in tiles of 2 -> 3
-  // tiles: the external axis x_9 partitions into 1/2/3 blocks, and the inner
-  // axis x_1 partitions into 3 aux batches at target size 2 (so intra-term
-  // batching genuinely engages); virt extent 4. (nocc unused here.)
-  rand_tensor_yield<double, TA::DensePolicy> yield{world, /*nocc=*/6,
-                                                   /*nvirt=*/4, /*naux=*/6};
-  yield.set_max_tile(2);
-  using ArrayT = typename decltype(yield)::array_type;
-  using ResultT = sequant::ResultTensorTA<ArrayT>;
-
-  // Two flat summand trees sharing S = g*h. x_9 is a Hadamard spectator: it
-  // rides every tensor (in the aux slot) and is declared external (in the
-  // result's aux slot via the ResultExpr LHS) so binarize keeps it uncontracted
-  // on every node -- a high-order AUX hyperindex carried into the result. x_1
-  // rides g and the final factor and is CONTRACTED at each root; S = g*h
-  // carries x_1 free, so the root's x_1 contraction is a batching target whose
-  // intermediate is S. (The deprecated binarize(ExprPtr) would infer x_9 as
-  // contracted; the ResultExpr API pins it external -- same mechanism as the
-  // GAM{...;i1,i2} = t T2 Hadamard test above.)
-  //   F1 = (g{a_1;a_2;x_1,x_9} * h{a_2;a_5;x_9}) * p{a_5;a_6;x_1,x_9}
-  //   F2 = (g{a_1;a_2;x_1,x_9} * h{a_2;a_5;x_9}) * q{a_5;a_6;x_1,x_9}
-  // Both produce R{a_1;a_6;x_9}; R = F1 + F2.
-  auto const e1 = sequant::deserialize<sequant::ResultExpr>(
-      L"R{a_1;a_6;x_9} = "
-      L"(g{a_1;a_2;x_1,x_9} * h{a_2;a_5;x_9}) * p{a_5;a_6;x_1,x_9}");
-  auto const e2 = sequant::deserialize<sequant::ResultExpr>(
-      L"R{a_1;a_6;x_9} = "
-      L"(g{a_1;a_2;x_1,x_9} * h{a_2;a_5;x_9}) * q{a_5;a_6;x_1,x_9}");
-  auto const n1 = eval_node(e1);
-  auto const n2 = eval_node(e2);
-  std::vector<node_t> const forest{n1, n2};
-
-  auto const isr = sequant::get_default_context().index_space_registry();
-  auto const aux_space = isr->retrieve(L"x");
-
-  // The external spectator axis: the aux index carried in the head's result
-  // (uncontracted) -- i.e. among the root node's free/canon indices. The
-  // contracted inner batch axis x_1 is summed at the root, so it is absent
-  // there; the sole aux among the root's free modes is the spectator x_9.
-  sequant::Index axis;
-  for (auto const& ix : n1->canon_indices())
-    if (ix.space() == aux_space && !ix.has_proto_indices()) {
-      axis = ix;
-      break;
-    }
-  REQUIRE(axis.nonnull());
-  REQUIRE(axis.space() == aux_space);
-  // Structural preconditions: S = g*h repeats across the forest (shared scratch
-  // builds it once per external block), and x_9 is a plain outer mode.
-  {
-    sequant::TreeNodeEqualityComparator<node_t> const eq;
-    REQUIRE(eq(n1.left(), n2.left()));  // both left children are S
-    auto cm = sequant::cache_manager(forest, 2);
-    REQUIRE(cm.max_life(n1.left()) == 2);
-  }
-  REQUIRE(sequant::index_position(n1, axis).has_value());
-  // The intra-term batch axis is the CONTRACTED aux index at the root (x_1),
-  // and S carries it free (so it is a real batching target, not the external
-  // spectator x_9). accept_inner_aux matches aux indices OTHER than the
-  // external spectator so the inner evaluator never tries to batch x_9.
-  auto accept_inner_aux = [aux_space, axis](sequant::Index const& ix) {
-    return ix.space() == aux_space && ix != axis;
-  };
-  auto const root_axis = sequant::batch_axis(n1, accept_inner_aux);
-  REQUIRE(root_axis.has_value());
-  REQUIRE(root_axis->space() == aux_space);
-  REQUIRE(*root_axis != axis);
-
-  // Unbatched reference R = F1 + F2 (each in the head's natural layout).
-  std::string const target = n1->annot();
-  ResultPtr ref = evaluate(n1, target, yield);
-  ref->add_inplace(*evaluate(n2, target, yield));
-  auto const& R = ref->get<ArrayT>();
-  double const ref_nrm = TA::norm2(R);
-  REQUIRE(ref_nrm > 0.0);  // guard: reference is nontrivially nonzero
-
-  // The intra-term batching FACTORY: given THIS block's (external-sliced) leaf
-  // evaluator, build a make_batched_custom_evaluator that batches the aux axis
-  // x_1. A spy scope guard records every firing so the test can prove the
-  // intra-term evaluator engaged INSIDE the external blocks (not just once).
-  std::vector<std::size_t> guard_calls;
-  auto spy = [&guard_calls](std::size_t n) {
-    guard_calls.push_back(n);
-    return sequant::no_scope_guard{};
-  };
-  std::function<std::size_t(sequant::Index const&)> const aux_target =
-      [](sequant::Index const&) -> std::size_t { return 2; };
-  std::function<cache_t::custom_evaluator_type(
-      std::function<ResultPtr(node_t const&)> const&)>
-      intra_factory = [&](std::function<ResultPtr(node_t const&)> const& le_blk)
-      -> cache_t::custom_evaluator_type {
-    return make_batched_custom_evaluator(le_blk, aux_target, accept_inner_aux,
-                                         spy, sequant::never_volatile{});
-  };
-
-  // block sizes (in elements of x_9, extent 6, tiles of 2):
-  //   1000 -> 1 block; 4 -> 2 blocks (first spans two tiles); 2 -> 3 blocks.
-  for (std::size_t const block_size :
-       {std::size_t{1000}, std::size_t{4}, std::size_t{2}}) {
-    std::size_t const expected_blocks =
-        (block_size >= 6) ? 1 : (block_size == 4 ? 2 : 3);
-
-    // (A) NESTED run: external-occ partition (outer) WITH intra-term aux
-    // batching (inner). Assert exactness AND that intra-term batching fired
-    // once per (external block, summand) -- i.e. INSIDE every block.
-    guard_calls.clear();
-    ArrayT dest_arr;
-    dest_arr(target) = R(target) - R(target);  // pre-sized zero
-    world.gop.fence();
-    auto dest = eval_result<ResultT>(dest_arr);
-    auto scratch = sequant::cache_manager(forest, 2);
-    ExternalBatchAxis const ext{axis, block_size};
-    auto const n_blocks = evaluate_forest_over_external_axis(
-        forest, ext, scratch, yield, dest, intra_factory);
-    REQUIRE(n_blocks == expected_blocks);
-
-    auto const& out = dest->get<ArrayT>();
-    ArrayT diff;
-    diff(target) = out(target) - R(target);
-    world.gop.fence();
-    REQUIRE(TA::norm2(diff) < 1e-12);
-    REQUIRE(TA::norm2(out) == Catch::Approx(ref_nrm));
-
-    // Nesting fired inside blocks: the root of each of the 2 summands is
-    // intercepted and batched over x_1 in EACH external block -> n_blocks * 2
-    // firings, each partitioning x_1 into 3 aux batches. size > n_summands is
-    // the RED/GREEN gate that intra-term batching ran INSIDE the blocks (not
-    // once globally).
-    REQUIRE(guard_calls.size() == expected_blocks * forest.size());
-    for (auto const n : guard_calls) CHECK(n == 3);
-
-    // (B) DEFAULT (no intra-term batching): byte-identical spine, same result,
-    // and the spy is never touched.
-    guard_calls.clear();
-    ArrayT dest_arr2;
-    dest_arr2(target) = R(target) - R(target);
-    world.gop.fence();
-    auto dest2 = eval_result<ResultT>(dest_arr2);
-    auto scratch2 = sequant::cache_manager(forest, 2);
-    auto const n_blocks2 =
-        evaluate_forest_over_external_axis(forest, ext, scratch2, yield, dest2);
-    REQUIRE(n_blocks2 == expected_blocks);
-    auto const& out2 = dest2->get<ArrayT>();
-    ArrayT diff2;
-    diff2(target) = out2(target) - R(target);
-    world.gop.fence();
-    REQUIRE(TA::norm2(diff2) < 1e-12);
-    REQUIRE(guard_calls.empty());  // default path never installs the evaluator
-  }
-}
diff --git a/tests/unit/test_optimize.cpp b/tests/unit/test_optimize.cpp
index 04d7124698..a004b42b94 100644
--- a/tests/unit/test_optimize.cpp
+++ b/tests/unit/test_optimize.cpp
@@ -2022,75 +2022,6 @@ TEST_CASE("PPL: form 4-PNO W vs fold-t (peak-neutral, flop tie-break)",
   CHECK(tbat_w_tight == flops_w);
 }
 
-// Task 4 (forest batching, G4): the public optimize_result() surfaces the
-// chosen spectator external axis + block size as a forest-level signal
-// (ExternalBatchAxis) that the runtime and downstream consumers read. In this
-// (chemistry) test the PPL residual carries its external occ (i_1,i_2) ONLY as
-// a composite protoindex on the output PNOs a<i,i> (never a contracted
-// top-level slot), so no eval node hangs it -- it is emitted per optimized term
-// instead. The perf-first DenseTimeSpaceBatched factorization forms the 4-PNO W
-// giant
-// (~40 MB here); with a budget it exceeds, optimize_result() reports the
-// spectator axis sliced to batch_target_size=10, enabled by the domain-neutral
-// BatchPolicy::batch_spectator_indices flag.
-TEST_CASE("optimize emits an external batch axis for the PPL term",
-          "[optimize][external-occ]") {
-  using namespace sequant;
-  auto ctx_resetter = set_scoped_default_context(get_default_context().clone());
-  auto reg = get_default_context().mutable_index_space_registry();
-  mbpt::add_df_spaces(reg);
-  mbpt::add_pao_spaces(reg, mbpt::Spin::any);
-  mbpt::add_ao_spaces(reg, mbpt::Spin::any);
-  for (auto&& [k, v] :
-       std::initializer_list<std::pair<std::wstring_view, size_t>>{
-           {L"i", 16}, {L"a", 12}, {L"μ̃", 170}, {L"Κ", 472}})
-    reg->retrieve_ptr(k)->approximate_size(v);
-  auto aux = reg->retrieve(L"Κ");
-
-  // Same PPL residual as the form-W test above: R_ij^{a1 a2} = (a1 a3|a2 a4)
-  // t_ij^{a3 a4}, DF-factored, i_1/i_2 external occ carried only as protos.
-  auto prod = deserialize(
-      L"C{a_1<i_1,i_2>;μ̃_1} g{μ̃_1;μ̃_2;Κ_1} C{μ̃_2;a_3<i_1,i_2>} "
-      L"C{a_2<i_1,i_2>;μ̃_3} g{μ̃_3;μ̃_4;Κ_1} C{μ̃_4;a_4<i_1,i_2>} "
-      L"t{a_3<i_1,i_2>,a_4<i_1,i_2>;i_1,i_2}");
-
-  OptimizeOptions opts;
-  opts.objective_function = ObjectiveFunction::DenseTimeSpaceBatched;
-  opts.reorder = ReorderSum::NoReorder;
-  opts.idx_to_extent = [](Index const& ix) -> std::size_t {
-    return ix.nonnull() ? ix.space().approximate_size() : std::size_t{1};
-  };
-  opts.inner_pow = [](Index const&, std::size_t) -> double { return 12.0; };
-  opts.batch_policy.is_batchable_index = [aux](Index const& ix) {
-    return ix.space() == aux;
-  };
-  // All batch sizes live together on BatchPolicy: the DF aux Κ keeps its 236
-  // slice; the spectator occ axis "i" gets its own per-block extent of 10.
-  auto occ = reg->retrieve(L"i");
-  opts.batch_policy.batch_target_size = [occ](Index const& ix) -> std::size_t {
-    return ix.space() == occ ? 10 : 236;
-  };
-  opts.batch_policy.is_volatile_leaf = [](Tensor const& t) {
-    return t.label() == L"t";
-  };
-  // A budget the unseeded 4-PNO W giant (~40 MB) exceeds: 1 MB.
-  opts.batch_policy.peak_threshold = 1.0e6;
-  // Enable spectator-index batching (the domain-neutral trigger).
-  opts.batch_policy.batch_spectator_indices = true;
-
-  auto res = optimize_result(prod, opts);
-  REQUIRE(res.external_batch_axis.has_value());
-  CHECK(res.external_batch_axis->axis.space().base_key() == L"i");
-  CHECK(res.external_batch_axis->block_size == 10);
-  REQUIRE(static_cast<bool>(res.expr));
-
-  // batch_spectator_indices == false disables the signal (the default
-  // optimize() path is byte-identical; the [optimize] suite is its witness).
-  opts.batch_policy.batch_spectator_indices = false;
-  auto res_off = optimize_result(prod, opts);
-  CHECK_FALSE(res_off.external_batch_axis.has_value());
-}
-
 // Quadratic-bubble (g·t2·t2) exchange term in PNO/CSV basis: the two competing
 // factorizations of one residual contribution.
 //
@@ -2582,15 +2513,14 @@ TEST_CASE("binarize stamps per-node batch axes from optimize()",
 
 // Task 3/4: reconstruct_axes must emit AxisKind::External entries for a
 // genuine spectator (external, never-contracted) axis at every node whose
-// subset carries it, gated by BOTH BatchPolicy::batch_spectator_indices (i)
-// AND the Task 4 term-level emit_external gate (perf-first objective (ii) +
-// unseeded root peak over peak_threshold (iv)), reproducing the OLD
-// compute_external_batch_axis trigger exactly. i_1 lives only on the first
-// tensor of a 4-tensor chain -- a genuine external spectator that is never
-// contracted anywhere, so is_spectator_axis(i_1) holds regardless of the
-// chosen factorization -- while Kappa_1 (the DF aux shared by the first two
-// tensors) is a genuine CONTRACTED axis, never a spectator. Distinguishes the
-// two kinds even though both get admitted into ctx.aux.
+// subset carries it, gated by BOTH BatchPolicy::batch_spectator_indices AND
+// the term-level emit_external gate (perf-first objective selected AND the
+// selected root's unseeded byte peak exceeds peak_threshold). i_1 lives only
+// on the first tensor of a 4-tensor chain -- a genuine external spectator
+// that is never contracted anywhere, so is_spectator_axis(i_1) holds
+// regardless of the chosen factorization -- while Kappa_1 (the DF aux shared
+// by the first two tensors) is a genuine CONTRACTED axis, never a spectator.
+// Distinguishes the two kinds even though both get admitted into ctx.aux.
 TEST_CASE("reconstruct_axes_emits_external_per_node", "[optimize][batch]") {
   using namespace sequant;
   auto ctx_resetter = set_scoped_default_context(get_default_context().clone());
@@ -2690,11 +2620,11 @@ TEST_CASE("reconstruct_axes_emits_external_per_node", "[optimize][batch]") {
   CHECK(node_without_external);
 
   // Assertion 2: peak_threshold = +infinity (the term never "needs" batching
-  // under any budget) with batch_spectator_indices still true => gate (iv)
-  // fails => ZERO External entries anywhere. This is exactly the OLD
-  // compute_external_batch_axis condition (iv); before the Task 4 gate,
-  // reconstruct_axes emitted External regardless of peak_threshold, so this
-  // assertion fails without the fix and passes with it.
+  // under any budget) with batch_spectator_indices still true => the
+  // unseeded-peak-over-threshold gate fails => ZERO External entries
+  // anywhere. Before the Task 4 gate, reconstruct_axes emitted External
+  // regardless of peak_threshold, so this assertion fails without the fix
+  // and passes with it.
   axes_map->clear();
   opts.batch_policy.peak_threshold = std::numeric_limits<double>::infinity();
   auto optimized_inf = optimize(expr, opts);

From 874bfb43f1c44db4ed12cc8d6533b683f73dbe86 Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Sun, 12 Jul 2026 09:48:28 +0300
Subject: [PATCH 78/78] eval: tests for multi-mode and Hadamard external batch
 axes

Add three [eval][batched-external] tests: two occupied External axes
nested on one product node (product-of-blocks firing witness),
a genuinely Hadamard External axis shared by both operands of a
contraction plus the result, and an External axis on an outer node
nested with a Contracted axis on an inner node.
---
 tests/unit/test_eval_ta.cpp | 364 ++++++++++++++++++++++++++++++++++++
 1 file changed, 364 insertions(+)

diff --git a/tests/unit/test_eval_ta.cpp b/tests/unit/test_eval_ta.cpp
index 96c67d8e51..6c625e4bbf 100644
--- a/tests/unit/test_eval_ta.cpp
+++ b/tests/unit/test_eval_ta.cpp
@@ -2817,6 +2817,370 @@ TEST_CASE("batched_scratch_tot_presize_scatter", "[eval][batched-external]") {
   REQUIRE(out("i,j;a,b").dot(out("i,j;a,b")) > 0.0);
 }
 
+TEST_CASE("batched_eval_external_two_occ", "[eval][batched-external]") {
+  // Task 9 (rank-2 multi-mode): batched_eval_external_axis_scatter stamps a
+  // SINGLE spectator axis External; this test stamps TWO DISTINCT occupied
+  // indices External on the SAME (only) product node and proves the runtime
+  // nests both scatter loops as a PRODUCT of block counts, not just one
+  // axis's worth. Structurally this is the External/scatter analog of
+  // "eval_batched_custom_evaluator nests two axes on one node" (which does
+  // the same two-axes-per-node nesting for AxisKind::Contracted).
+  //
+  // R{i_1;i_2} = g{i_1;a_1} * h{a_1;i_2}: i_1 is free on g and the result
+  // only (not shared with h); i_2 is free on h and the result only (not
+  // shared with g); a_1 is contracted between g and h. Because i_1 and i_2
+  // each appear on only ONE operand (as ordinary result indices), plain
+  // ExprPtr binarization already keeps them free -- unlike the aux
+  // hyperindex in batched_eval_external_axis_scatter (shared by > 2 tensor
+  // slots there), no ResultExpr pinning is needed to keep them external.
+  using sequant::evaluate;
+  using sequant::make_batched_custom_evaluator;
+  using TA::TArrayD;
+  using node_t = sequant::FullBinaryNode<sequant::EvalExprTA>;
+  using cache_t = sequant::CacheManager<node_t>;
+
+  auto& world = TA::get_default_world();
+  // occupied multi-tiled (12 in tiles of 4 -> 3 tiles) so BOTH occ
+  // spectator axes i_1, i_2 partition into > 1 block; virtual single-tiled
+  // (4, the contracted mode a_1).
+  rand_tensor_yield<double, TA::DensePolicy> yield_{world, /*nocc=*/12,
+                                                    /*nvirt=*/4};
+  yield_.set_max_tile(4);
+
+  auto const expr =
+      sequant::deserialize<sequant::ExprPtr>(L"(g{i_1;a_1} * h{a_1;i_2})");
+  std::string const target = "i_1,i_2";
+  auto node = eval_node(expr);  // mutable: batch axes stamped below
+
+  auto const occ =
+      sequant::get_default_context().index_space_registry()->retrieve(L"i");
+  auto accept_occ = [occ](sequant::Index const& ix) {
+    return ix.space() == occ;
+  };
+
+  // The two distinct occupied result indices, taken from the node's own
+  // canonical (free/result) indices -- both must be free on the node.
+  sequant::container::svector<sequant::Index> occ_axes;
+  for (auto const& ix : node->canon_indices())
+    if (accept_occ(ix)) occ_axes.push_back(ix);
+  REQUIRE(occ_axes.size() == 2);
+  REQUIRE(occ_axes[0] != occ_axes[1]);
+  REQUIRE(sequant::index_position(node, occ_axes[0]).has_value());
+  REQUIRE(sequant::index_position(node, occ_axes[1]).has_value());
+
+  // Stamp BOTH occupied indices External on the single product node.
+  node->set_batch_axes({{occ_axes[0], sequant::AxisKind::External},
+                        {occ_axes[1], sequant::AxisKind::External}});
+
+  // Reference: plain unbatched evaluation (the OFF path -- batch_axes are
+  // ignored without a custom evaluator). Computed first so yield_'s random
+  // leaf arrays are generated and cached, then reused by the batched run.
+  auto const ref = evaluate(node, target, yield_)->get<TArrayD>();
+  REQUIRE(TA::norm2(ref) > 0.0);  // guard: reference is nontrivially nonzero
+
+  // Distinct per-axis target sizes (as in "nests two axes on one node") so
+  // the two nested levels realize DIFFERENT batch counts and their product
+  // is unambiguous: occ_axes[0] -> target 4 over extent 12 = 3 blocks;
+  // occ_axes[1] -> target 8 = 2 blocks (two tiles fused, then the
+  // remainder). Both target sizes are strictly below the axis extent (12),
+  // i.e. the ON configuration for both axes.
+  auto const& axis0 = occ_axes[0];
+  auto target_batch_size = [axis0](sequant::Index const& ix) -> std::size_t {
+    return ix == axis0 ? std::size_t{4} : std::size_t{8};
+  };
+
+  // Firing-witness: records the block count each time the scatter evaluator
+  // fires, and the product of the two live (outer, inner) counts whenever
+  // both levels are simultaneously live -- the RED/GREEN proof that the two
+  // External loops genuinely NEST as a PRODUCT rather than only one axis
+  // firing or the second axis being silently skipped.
+  struct GuardState {
+    std::vector<std::size_t> live;
+    std::vector<std::size_t> counts;
+    std::vector<std::size_t> products_at_depth2;
+    std::size_t max_depth = 0;
+  } state;
+  struct TrackingGuard {
+    GuardState* st;
+    TrackingGuard(GuardState* s, std::size_t n) : st(s) {
+      st->counts.push_back(n);
+      st->live.push_back(n);
+      st->max_depth = std::max(st->max_depth, st->live.size());
+      if (st->live.size() == 2)
+        st->products_at_depth2.push_back(st->live[0] * st->live[1]);
+    }
+    TrackingGuard(TrackingGuard const&) = delete;
+    TrackingGuard& operator=(TrackingGuard const&) = delete;
+    ~TrackingGuard() { st->live.pop_back(); }
+  };
+  auto make_tracking_guard = [&state](std::size_t n) {
+    return TrackingGuard(&state, n);
+  };
+
+  auto cache = cache_t::empty();
+  cache.set_custom_evaluator(make_batched_custom_evaluator(
+      yield_, target_batch_size, accept_occ, make_tracking_guard,
+      sequant::never_volatile{}));
+  auto const res = evaluate(node, target, yield_, cache)->get<TArrayD>();
+
+  // Exactness: scattering disjoint blocks over both axes reconstructs the
+  // whole result.
+  TArrayD diff;
+  diff("i,j") = ref("i,j") - res("i,j");
+  REQUIRE(TA::norm2(diff) < 1e-10);
+
+  // Depth-2 nesting engaged: occ_axes[0] sliced at the outer level (3
+  // blocks), occ_axes[1] at the inner level (2 blocks) WITHIN each outer
+  // block.
+  REQUIRE(state.max_depth == 2);
+  REQUIRE(state.counts.size() == 4);  // 1 outer firing + 3 inner firings
+  CHECK(std::count(state.counts.begin(), state.counts.end(), 3u) == 1);
+  CHECK(std::count(state.counts.begin(), state.counts.end(), 2u) == 3);
+  // Every depth-2 instant multiplies 3 (outer) by 2 (inner) = 6: BOTH
+  // external loops were live together with DISTINCT partitions, i.e. the
+  // PRODUCT of block counts, not just one axis's worth.
+  REQUIRE(state.products_at_depth2.size() == 3);
+  for (auto const p : state.products_at_depth2) CHECK(p == 6);
+  CHECK(state.live.empty());
+}
+
+TEST_CASE("batched_eval_external_hadamard", "[eval][batched-external]") {
+  // Task 9 (genuine Hadamard external): guards the "slice EVERY carrying
+  // operand to the same block" contract. i_3 is shared ELEMENTWISE (not
+  // summed) between BOTH operands of ONE product node and survives to the
+  // result -- a true Hadamard mode, not merely a free index that happens to
+  // pass through a single operand untouched (that weaker shape is what the
+  // free-only fixtures, e.g. batched_scratch_no_seed_external's g/h/t tree,
+  // already exercise). A bug that sliced only ONE of the two operands
+  // carrying i_3 (leaving the other at its full extent) would make the
+  // per-block elementwise product over i_3 mismatched/wrong for THIS
+  // fixture, whereas a free-only fixture (where only one operand ever
+  // carries the axis) cannot distinguish "slice every carrying operand" from
+  // "slice the first carrying operand" -- there is only ever one.
+  //
+  // R{i_3;a_1,a_2} = (g{i_3;a_1} * h{i_3;a_2}): i_3 appears on g, on h, AND
+  // on the result, contracted at no node (a pure elementwise/outer product
+  // over i_3 combined with a_1 from g and a_2 from h). Because i_3 is
+  // repeated across exactly 2 operand tensors (the is_valid cap is > 2), it
+  // is syntactically legal directly on the occupied space; plain binarize
+  // would default to CONTRACTING a repeated-and-otherwise-unlisted index, so
+  // the ResultExpr LHS pins i_3 into R's free/output indices (the same
+  // technique batched_eval_external_axis_scatter uses for its aux
+  // spectator).
+  using sequant::evaluate;
+  using sequant::make_batched_custom_evaluator;
+  using TA::TArrayD;
+  using node_t = sequant::FullBinaryNode<sequant::EvalExprTA>;
+  using cache_t = sequant::CacheManager<node_t>;
+
+  auto& world = TA::get_default_world();
+  // occupied multi-tiled (12 in tiles of 4 -> 3 tiles) so the Hadamard
+  // spectator i_3 genuinely partitions into > 1 block; virtual single-tiled
+  // (4).
+  rand_tensor_yield<double, TA::DensePolicy> yield_{world, /*nocc=*/12,
+                                                    /*nvirt=*/4};
+  yield_.set_max_tile(4);
+
+  auto const res_expr = sequant::deserialize<sequant::ResultExpr>(
+      L"R{i_3;a_1,a_2} = (g{i_3;a_1} * h{i_3;a_2})");
+  auto node = eval_node(res_expr);  // mutable: External axis stamped below
+  std::string const target = node->annot();
+
+  auto const occ =
+      sequant::get_default_context().index_space_registry()->retrieve(L"i");
+  auto accept_occ = [occ](sequant::Index const& ix) {
+    return ix.space() == occ;
+  };
+
+  // The Hadamard spectator i_3, taken from the node's own free/result outer
+  // modes.
+  sequant::Index axis;
+  for (auto const& ix : node->canon_indices())
+    if (accept_occ(ix)) {
+      axis = ix;
+      break;
+    }
+  REQUIRE(axis.nonnull());
+  REQUIRE(sequant::index_position(node, axis).has_value());  // free on result
+
+  // Confirm i_3 is genuinely carried by BOTH operands (not just one) -- the
+  // structural property that makes this fixture "genuinely Hadamard" rather
+  // than free-only.
+  REQUIRE(sequant::index_position(node.left(), axis).has_value());
+  REQUIRE(sequant::index_position(node.right(), axis).has_value());
+
+  node->set_batch_axes({{axis, sequant::AxisKind::External}});
+
+  // Reference: plain unbatched evaluation (the OFF path).
+  auto const ref = evaluate(node, target, yield_)->get<TArrayD>();
+  REQUIRE(TA::norm2(ref) > 0.0);  // guard: reference is nontrivially nonzero
+
+  // Firing-witness spy, as in batched_eval_external_axis_scatter: records the
+  // block count each time the evaluator fires. A silently-ignored External
+  // stamp (or a stamp that degraded to a no-op because only one operand got
+  // sliced and the runtime bailed) would never fire this.
+  std::vector<std::size_t> guard_calls;
+  auto spy = [&guard_calls](std::size_t n) {
+    guard_calls.push_back(n);
+    return sequant::no_scope_guard{};
+  };
+
+  // Two block sizes, both strictly below i_3's extent (12): 4 -> 3 blocks,
+  // 8 -> 2 blocks (the ON configuration for both).
+  for (std::size_t const target_batch_size : {std::size_t{4}, std::size_t{8}}) {
+    guard_calls.clear();
+    auto cache = cache_t::empty();
+    cache.set_custom_evaluator(make_batched_custom_evaluator(
+        yield_,
+        [target_batch_size](sequant::Index const&) -> std::size_t {
+          return target_batch_size;
+        },
+        accept_occ, spy, sequant::never_volatile{}));
+    auto const res = evaluate(node, target, yield_, cache)->get<TArrayD>();
+
+    // Exactness: if the runtime had sliced only ONE of the two Hadamard
+    // operands, the per-block elementwise product over i_3 would combine
+    // mismatched slices and this would fail (or the two mismatched ranges
+    // would not even align into a well-formed contraction).
+    TArrayD diff;
+    diff("i,j,k") = ref("i,j,k") - res("i,j,k");
+    REQUIRE(TA::norm2(diff) < 1e-12);
+
+    // The ON path blocked: the evaluator fired at least once, partitioning
+    // into > 1 block.
+    REQUIRE_FALSE(guard_calls.empty());
+    for (auto const n : guard_calls) CHECK(n > 1);
+    std::size_t const expected_blocks = target_batch_size == 4 ? 3 : 2;
+    CHECK(guard_calls.front() == expected_blocks);
+  }
+}
+
+TEST_CASE("batched_eval_external_nested_contracted",
+          "[eval][batched-external]") {
+  // Task 9 (bonus, carried from Task 5's review): an External axis on an
+  // OUTER node nested with a Contracted axis on an INNER node -- the mirror
+  // image of "eval_batched_custom_evaluator nests inner axis" (which nests
+  // Contracted-over-Contracted). Here the SCATTER branch (Task 5) at the
+  // root must re-enter and let a plain accumulate (Contracted) fire WITHIN
+  // each external block, i.e. "for external-block: for contracted-block:
+  // accumulate, then scatter the block". This exercises the opposite
+  // composition order from batched_eval_external_axis_scatter (which nests
+  // External outside External at two DIFFERENT nodes, never mixing kinds).
+  //
+  // inner = u{i_1;i_2;x_1,x_2} * v{i_1;i_3;x_2}: contracts i_1 and x_2
+  // (both present on both operands, absent from the term's declared free
+  // set), leaving free x_1, i_2, i_3.
+  // root = inner * p{i_3;i_6;x_1}: contracts i_3 (present on inner and p,
+  // summed), leaving free x_1, i_2, i_6. x_1 is present on BOTH root
+  // operands (inner and p) and is declared part of R's free indices, so it
+  // is EXTERNAL (scattered) at the root -- a plain ExprPtr would instead
+  // default to contracting a doubly-repeated, undeclared index, so (as in
+  // batched_eval_external_axis_scatter) the ResultExpr LHS pins x_1 free.
+  using sequant::evaluate;
+  using sequant::make_batched_custom_evaluator;
+  using TA::TArrayD;
+  using node_t = sequant::FullBinaryNode<sequant::EvalExprTA>;
+  using cache_t = sequant::CacheManager<node_t>;
+
+  auto& world = TA::get_default_world();
+  // occ/virt single-tiled (4, unused as batch axes here); aux multi-tiled
+  // (12 in tiles of 4 -> 3 tiles) so both x_1 (outer, External) and x_2
+  // (inner, Contracted) partition into > 1 block.
+  rand_tensor_yield<double, TA::DensePolicy> yield_{world, 4, 4, 12};
+  yield_.set_max_tile(4);
+
+  auto const res_expr = sequant::deserialize<sequant::ResultExpr>(
+      L"R{i_2;i_6;x_1} = ((u{i_1;i_2;x_1,x_2} * v{i_1;i_3;x_2})"
+      L" * p{i_3;i_6;x_1})");
+  auto node = eval_node(res_expr);  // mutable: batch axes stamped below
+  std::string const target = node->annot();
+
+  auto const aux_space =
+      sequant::get_default_context().index_space_registry()->retrieve(L"x");
+  auto accept_aux = [aux_space](sequant::Index const& ix) {
+    return ix.space() == aux_space;
+  };
+
+  // The External spectator x_1, taken from the ROOT's own free/result outer
+  // modes (a plain outer mode, no protos).
+  sequant::Index x1_axis;
+  for (auto const& ix : node->canon_indices())
+    if (accept_aux(ix) && !ix.has_proto_indices()) {
+      x1_axis = ix;
+      break;
+    }
+  REQUIRE(x1_axis.nonnull());
+  REQUIRE(sequant::index_position(node, x1_axis).has_value());  // free on R
+
+  // The inner node (u*v) carries a DIFFERENT aux axis (x_2), contracted
+  // there -- locate it the same way "nests inner axis" does, by its
+  // contracted aux index rather than tree position (robust to binarize's
+  // operand ordering).
+  node_t* inner = nullptr;
+  std::optional<sequant::Index> x2_axis;
+  auto find_inner = [&](auto&& self, node_t& n) -> void {
+    if (n.leaf()) return;
+    if (&n != &node) {
+      if (auto ax = sequant::batch_axis(n, accept_aux)) {
+        inner = &n;
+        x2_axis = *ax;
+      }
+    }
+    self(self, n.left());
+    self(self, n.right());
+  };
+  find_inner(find_inner, node);
+  REQUIRE(inner != nullptr);
+  REQUIRE(x2_axis.has_value());
+  REQUIRE(*x2_axis != x1_axis);  // the two nested axes differ
+
+  // Stamp the root's spectator External, the inner's contracted axis
+  // Contracted.
+  node->set_batch_axes({{x1_axis, sequant::AxisKind::External}});
+  (*inner)->set_batch_axes({{*x2_axis, sequant::AxisKind::Contracted}});
+
+  // Reference: plain unbatched evaluation (the OFF path). Computed first so
+  // yield_'s random leaf arrays are generated and cached, then reused below.
+  auto const ref = evaluate(node, target, yield_)->get<TArrayD>();
+  REQUIRE(TA::norm2(ref) > 0.0);  // guard: reference is nontrivially nonzero
+
+  // Firing-witness spy: records the block count each time EITHER level
+  // fires (the root's scatter or the inner's accumulate). Distinct target
+  // sizes for x_1 (outer, External) vs x_2 (inner, Contracted) make the two
+  // levels' partitions unambiguous: x_1 -> target 4 over extent 12 = 3
+  // blocks; x_2 -> target 8 = 2 blocks.
+  auto target_batch_size = [x1_axis](sequant::Index const& ix) -> std::size_t {
+    return ix == x1_axis ? std::size_t{4} : std::size_t{8};
+  };
+  std::vector<std::size_t> guard_calls;
+  auto spy = [&guard_calls](std::size_t n) {
+    guard_calls.push_back(n);
+    return sequant::no_scope_guard{};
+  };
+
+  auto cache = cache_t::empty();
+  cache.set_custom_evaluator(make_batched_custom_evaluator(
+      yield_, target_batch_size, accept_aux, spy, sequant::never_volatile{}));
+  auto const res = evaluate(node, target, yield_, cache)->get<TArrayD>();
+
+  // Exactness: External-scatter-outside-Contracted-accumulate composes to
+  // the same result as the unbatched contraction.
+  TArrayD diff;
+  diff("i,j,k") = ref("i,j,k") - res("i,j,k");
+  REQUIRE(TA::norm2(diff) < 1e-10);
+
+  // Depth-2 nesting engaged: the root fires once over x_1 (3 blocks) and,
+  // per x_1 block, the inner fires once over x_2 (2 blocks) -- 1 + 3 = 4
+  // firings, counts a permutation of {3, 2, 2, 2}. Before Task 5/6 this
+  // composition (External outside Contracted) did not exist, so this is the
+  // RED/GREEN witness that the scatter branch's per-block reinstall lets an
+  // inner Contracted axis nest exactly as it does under an outer Contracted
+  // axis.
+  REQUIRE(guard_calls.size() == 4);
+  CHECK(std::count(guard_calls.begin(), guard_calls.end(), 3u) == 1);
+  CHECK(std::count(guard_calls.begin(), guard_calls.end(), 2u) == 3);
+}
+
 TEST_CASE(
     "eval_batched_custom_evaluator nested scope guards compose "
     "multiplicatively",