refactor(committor): track cleanup resources separately

Replace retained transaction strategies with compact cleanup records for
each preparation attempt. Records contain buffer identities, acquired ALT
reservations, and the uniqueness nonce used by that attempt. Keep them in
the execution report before entering cancellable preparation futures.

Release executable tasks and their account payloads after use. Recovery
helpers now update remaining work without cloning tasks or returning dummy
strategies for cleanup. Rename commit_stage_task to buffer_task to reflect
its buffer preparation and closure role.

Record ALT acquisitions inside TableMania as they occur, including partial
failure and cancellation. Separate attempts retain separate reservations
even when their keys match, so cleanup cannot under-release repeated
reservations or release a key that an attempt never acquired.

Close each recorded buffer at most once after successful intent execution,
using its recorded nonce. Failed execution still releases ALT reservations
without closing buffers that another attempt could reuse. Cleanup no longer
rescans executable tasks to recover resource identities.

Adapt the existing lifecycle, nonce-recovery, and cleanup tests. Extend the
recovery regression to exercise real TableMania reference counts across
repeated reservations, partial failure, and cancellation while preserving
another intent's reservation. Check buffer closure and nonce association
through the cleanup handle.

Validation: make fmt; make ci-fmt; cargo check for the committor and TableMania
packages with --tests; the recovery_preserves_progress_and_resources test;
cargo clippy --workspace --all-targets -- -D warnings; cargo test --workspace
(nextest is unavailable locally); git diff --check.

Closes #1842.

Author: snawaz

committor/src/intent_engine/intent_execution_engine.rs

@@ -493,6 +493,7 @@ mod tests {
         test_utils,
         transaction_preparator::{
             TransactionPreparator,
+            cleanup_resources::CleanupResources,
             delivery_preparator::{BufferExecutionError, DeliveryPreparatorResult},
             error::PreparatorResult,
         },
@@ -506,14 +507,15 @@ mod tests {
             &self,
             _authority: &Keypair,
             _transaction_strategy: &mut TransactionStrategy,
+            _cleanup: &mut CleanupResources,
         ) -> PreparatorResult<VersionedMessage> {
             panic!("mock transaction preparator should not prepare a strategy")
         }
 
-        async fn cleanup_for_strategy(
+        async fn cleanup_resources(
             &self,
             _authority: &Keypair,
-            _transaction_strategy: &TransactionStrategy,
+            _resources: &CleanupResources,
             _close_buffers: bool,
         ) -> DeliveryPreparatorResult<(), BufferExecutionError> {
             Ok(())

committor/src/intent_executor/cleanup_handle.rs

@@ -1,14 +1,16 @@
+use std::collections::HashSet;
+
 use futures_util::future::join_all;
 use solana_keypair::Keypair;
 
-use crate::{
-    tasks::task_strategist::TransactionStrategy,
-    transaction_preparator::{TransactionPreparator, delivery_preparator::BufferExecutionError},
+use crate::transaction_preparator::{
+    TransactionPreparator, cleanup_resources::CleanupResources,
+    delivery_preparator::BufferExecutionError,
 };
 
 pub struct CleanupHandle<T> {
     authority: Keypair,
-    junk: Vec<TransactionStrategy>,
+    resources: Vec<CleanupResources>,
     /// When false (execution failed), only releases ALT reservations without
     /// closing buffer PDAs — avoids a race condition where a concurrent
     /// executor may still be using them.
@@ -19,22 +21,28 @@ pub struct CleanupHandle<T> {
 impl<T: TransactionPreparator> CleanupHandle<T> {
     pub(crate) fn new(
         authority: Keypair,
-        junk: Vec<TransactionStrategy>,
+        resources: Vec<CleanupResources>,
         close_buffers: bool,
         transaction_preparator: T,
     ) -> Self {
         Self {
-            junk,
+            resources,
             close_buffers,
             authority,
             transaction_preparator,
         }
     }
 
-    pub async fn clean(self) -> Result<(), BufferExecutionError> {
+    pub async fn clean(mut self) -> Result<(), BufferExecutionError> {
         let close_buffers = self.close_buffers;
-        let cleanup_futs = self.junk.iter().map(|to_cleanup| {
-            self.transaction_preparator.cleanup_for_strategy(
+        // Retries can prepare the same buffer again. Close it once, but release
+        // every ALT reservation, even when separate attempts used identical keys.
+        let mut buffers = HashSet::new();
+        for resources in &mut self.resources {
+            resources.buffers.retain(|task| buffers.insert((task.pubkey, task.commit_id)));
+        }
+        let cleanup_futs = self.resources.iter().map(|to_cleanup| {
+            self.transaction_preparator.cleanup_resources(
                 &self.authority,
                 to_cleanup,
                 close_buffers,

committor/src/intent_executor/executor.rs

@@ -246,7 +246,7 @@ where
 
         let cleanup_handle = CleanupHandle::new(
             self.ctx.authority,
-            report.junk,
+            report.cleanup,
             result.is_ok(),
             self.ctx.transaction_preparator,
         );

committor/src/intent_executor/executor/tests.rs

@@ -387,7 +387,10 @@ async fn intent_execution_preserves_recovery_and_completion() {
         let cleaned = preparator.cleaned.lock().unwrap();
         assert!(cleaned.iter().all(|(_, close_buffers)| *close_buffers == succeeds));
         assert_eq!(
-            cleaned.iter().filter(|(keys, _)| keys.contains(&RESERVED_ALT_KEY)).count(),
+            cleaned
+                .iter()
+                .filter(|(resources, _)| resources.alt_reservation.contains(&RESERVED_ALT_KEY))
+                .count(),
             expected_tasks.len()
         );
     }

committor/src/intent_executor/mod.rs

@@ -27,7 +27,8 @@ use crate::{
         error::{IntentExecutorError, IntentExecutorResult},
         intent_execution_client::IntentExecutionClient,
     },
-    tasks::{task_info_fetcher::CacheTaskInfoFetcher, task_strategist::TransactionStrategy},
+    tasks::task_info_fetcher::CacheTaskInfoFetcher,
+    transaction_preparator::cleanup_resources::CleanupResources,
 };
 
 #[async_trait]
@@ -116,19 +117,15 @@ impl IntentExecutionResult {
 #[derive(Default)]
 pub struct IntentExecutionReport {
     pub progress: ExecutionProgress,
-    /// Junk that needs to be cleaned up
-    junk: Vec<TransactionStrategy>,
+    /// Resource ownership from each preparation attempt, including failed attempts.
+    cleanup: Vec<CleanupResources>,
     /// Errors we patched trying to recover intent
     patched_errors: Vec<TransactionStrategyExecutionError>,
     /// Report of scheduled callbacks
     callbacks_report: Vec<Result<Signature, CallbackScheduleError>>,
 }
 
 impl IntentExecutionReport {
-    pub fn dispose(&mut self, value: TransactionStrategy) {
-        self.junk.push(value);
-    }
-
     pub fn add_patched_error(&mut self, value: TransactionStrategyExecutionError) {
         self.patched_errors.push(value);
     }
@@ -147,8 +144,4 @@ impl IntentExecutionReport {
     ) {
         self.callbacks_report.extend(values);
     }
-
-    pub fn junk(&self) -> &Vec<TransactionStrategy> {
-        &self.junk
-    }
 }

committor/src/intent_executor/strategy_executor/recovery.rs

@@ -33,14 +33,14 @@ pub(in crate::intent_executor) struct TransactionRecovery<'a, F, A> {
 }
 
 impl<F: TaskInfoFetcher, A: ActionsCallbackScheduler> TransactionRecovery<'_, F, A> {
-    /// Repairs rejected work and returns resources to clean up before completion.
+    /// Repairs rejected work; preparation records already own its cleanup resources.
     /// Follow-ups cannot repair commits, and standalone actions cannot be replayed.
     pub(in crate::intent_executor) async fn recover(
         &self,
         err: &TransactionStrategyExecutionError,
         strategy: &mut TransactionStrategy,
         report: &mut IntentExecutionReport,
-    ) -> IntentExecutorResult<ControlFlow<(), TransactionStrategy>> {
+    ) -> IntentExecutorResult<ControlFlow<()>> {
         let can_repair_commits = report.progress.confirmed_commit.is_none()
             && !self.committed_pubkeys.is_empty()
             && strategy
@@ -51,7 +51,7 @@ impl<F: TaskInfoFetcher, A: ActionsCallbackScheduler> TransactionRecovery<'_, F,
             return Ok(ControlFlow::Break(()));
         }
 
-        let cleanup = match err {
+        match err {
             TransactionStrategyExecutionError::ActionsError(err, signature) => {
                 handle_actions_result(
                     &self.authority.pubkey(),
@@ -88,28 +88,25 @@ impl<F: TaskInfoFetcher, A: ActionsCallbackScheduler> TransactionRecovery<'_, F,
                     .await
                     .map_err(IntentExecutorError::FailedPreparation)?
                     .map_err(IntentExecutorError::FailedExecution)?;
-                TransactionStrategy::default()
             }
             TransactionStrategyExecutionError::UndelegationError(_, _)
                 if strategy
                     .optimized_tasks
                     .iter()
                     .any(|task| matches!(task, BaseTaskImpl::Undelegate(_))) =>
             {
-                let mut removed = handle_undelegation_error(&self.authority.pubkey(), strategy);
                 // Report only discarded actions; retained actions still need to execute.
-                let callbacks = removed.extract_action_callbacks();
+                let callbacks = handle_undelegation_error(&self.authority.pubkey(), strategy);
                 if !callbacks.is_empty() {
                     report.add_callback_report(self.callback_scheduler.schedule(
                         callbacks,
                         err.signature(),
                         Err(ActionError::from(err)),
                     ));
                 }
-                removed
             }
             _ => return Ok(ControlFlow::Break(())),
         };
-        Ok(ControlFlow::Continue(cleanup))
+        Ok(ControlFlow::Continue(()))
     }
 }

committor/src/intent_executor/strategy_executor/transaction.rs

@@ -1,4 +1,4 @@
-use std::{mem, ops::ControlFlow, time::Duration};
+use std::{mem, time::Duration};
 
 use mbv_core::traits::{ActionError, ActionsCallbackScheduler};
 use program::outbox::PendingTransaction;
@@ -32,7 +32,7 @@ use crate::{
         task_info_fetcher::TaskInfoFetcher,
         task_strategist::{TransactionPlan, TransactionStrategy},
     },
-    transaction_preparator::TransactionPreparator,
+    transaction_preparator::{TransactionPreparator, cleanup_resources::CleanupResources},
 };
 
 #[cfg(test)]
@@ -106,14 +106,13 @@ where
                         && self.has_tasks_after_commit()
                         && err.is_recoverable_by_splitting() =>
                 {
-                    let (current, follow_up, cleanup) = handle_cpi_limit_error(
+                    let (current, follow_up) = handle_cpi_limit_error(
                         &self.ctx.authority.pubkey(),
                         mem::take(&mut self.current),
                     );
                     self.current = current;
                     self.follow_up = Some(follow_up);
                     self.current_attempt = 0;
-                    self.report.dispose(cleanup);
                     self.report.add_patched_error(err);
                     continue;
                 }
@@ -137,7 +136,7 @@ where
                     result.as_ref().map(|_| ()).map_err(ActionError::from),
                 );
             }
-            self.report.dispose(mem::take(&mut self.current));
+            drop(mem::take(&mut self.current));
 
             match result {
                 Ok(signature) => {
@@ -158,12 +157,7 @@ where
                         return Ok(output);
                     }
                 }
-                Err(err) => {
-                    if let Some(follow_up) = self.follow_up.take() {
-                        self.report.dispose(follow_up);
-                    }
-                    return Err(err);
-                }
+                Err(err) => return Err(err),
             }
         }
     }
@@ -175,10 +169,10 @@ where
         if self.current.has_actions_callbacks()
             || self.follow_up.as_ref().is_some_and(TransactionStrategy::has_actions_callbacks)
         {
-            if let Some(time_left) = time_left {
-                if let Ok(result) = timeout(time_left, self.execute_current()).await {
-                    return result;
-                }
+            if let Some(time_left) = time_left
+                && let Ok(result) = timeout(time_left, self.execute_current()).await
+            {
+                return result;
             }
             // Only callbacks expire. Keep actions and resolve any pending transaction
             // before preparing another one, since the cancelled send may still land.
@@ -235,12 +229,14 @@ where
 
             self.current_attempt += 1;
 
-            // Prepare message
+            // Keep this attempt's resources outside the cancellable preparation future.
+            let cleanup = self.report.cleanup.push_mut(CleanupResources::default());
             let prepared_transaction = prepare_transaction(
                 &ctx.intent_client,
                 &ctx.authority,
                 &ctx.transaction_preparator,
                 &mut self.current,
+                cleanup,
             )
             .await
             .map_err(IntentExecutorError::FailedPreparation)?;
@@ -292,12 +288,10 @@ where
                 self.report.progress.transaction = TransactionProgress::Rejected(*signature);
             }
             let flow = recovery.recover(&execution_err, &mut self.current, self.report).await?;
-            let cleanup = match flow {
-                ControlFlow::Continue(value) => value,
-                ControlFlow::Break(()) => return Ok(Err(execution_err)),
-            };
+            if flow.is_break() {
+                return Ok(Err(execution_err));
+            }
             ctx.intent_client.invalidate_cached_blockhash().await;
-            self.report.dispose(cleanup);
 
             if let Some(commit_signature) = confirmed_commit
                 && self.current.optimized_tasks.is_empty()
@@ -345,25 +339,23 @@ where
     }
 
     fn execute_callbacks(&mut self, signature: Option<Signature>, result: Result<(), ActionError>) {
-        let cleanup = handle_actions_result(
+        handle_actions_result(
             &self.ctx.authority.pubkey(),
             &self.ctx.actions_callback_executor,
             self.report,
             &mut self.current,
             signature,
             result.clone(),
         );
-        self.report.dispose(cleanup);
         if let (Err(_), Some(follow_up)) = (&result, &mut self.follow_up) {
-            let cleanup = handle_actions_result(
+            handle_actions_result(
                 &self.ctx.authority.pubkey(),
                 &self.ctx.actions_callback_executor,
                 self.report,
                 follow_up,
                 signature,
                 result,
             );
-            self.report.dispose(cleanup);
         }
     }