fix(supervisor): retry stalled Claude source reads and remove helpers Docker creates late

crates/freshell-server/src/managed_provider_launch_tests.rs

@@ -504,11 +504,12 @@ impl RuntimeBackend for BrokerAuthorizedBackend {
         owner: &freshell_supervisor::backend::ClaudeSourceOwner,
         request: &ObserveClaudeSourcesRequest,
         test_run_id: &str,
+        until: tokio::time::Instant,
     ) -> Result<freshell_platform::claude_inputs::observation::ObservationReply, BackendError> {
         self.authorize_claude_candidate(owner, request).await?;
         let reply = match self
             .real()
-            .observe_claude_sources(owner, request, test_run_id)
+            .observe_claude_sources(owner, request, test_run_id, until)
             .await
         {
             Ok(reply) => reply,

crates/freshell-server/src/managed_provider_references/claude.rs

@@ -632,6 +632,7 @@ mod tests {
                 owner: &ClaudeSourceOwner,
                 request: &ObserveClaudeSourcesRequest,
                 _: &str,
+                _: tokio::time::Instant,
             ) -> Result<freshell_platform::claude_inputs::observation::ObservationReply, BackendError>
             {
                 assert!(matches!(owner, ClaudeSourceOwner::Initial { .. }));

crates/freshell-server/src/managed_runtime_opencode_replan_tests.rs

@@ -43,6 +43,7 @@ mod uncertain_launch {
             _: &ClaudeSourceOwner,
             request: &ObserveClaudeSourcesRequest,
             _: &str,
+            _: tokio::time::Instant,
         ) -> Result<freshell_platform::claude_inputs::observation::ObservationReply, BackendError>
         {
             let r = &request.observation_request;

crates/freshell-supervisor/src/backend.rs

@@ -1,5 +1,7 @@
 mod claude_source_observation;
 pub mod docker;
+mod helper_lifecycle;
+pub(crate) use helper_lifecycle::CLAUDE_SOURCE_READER_RETRY;
 mod input_publisher;
 mod native_auth;
 mod native_history;
@@ -138,11 +140,14 @@ pub enum ClaudeSourceOwner {
 
 #[async_trait]
 pub trait RuntimeBackend: Send + Sync {
+    /// Observe Claude sources through the fixed reader. The read, its owned
+    /// cleanup included, ends by `until`.
     async fn observe_claude_sources(
         &self,
         _owner: &ClaudeSourceOwner,
         _request: &freshell_runtime_protocol::ObserveClaudeSourcesRequest,
         _test_run_id: &str,
+        _until: tokio::time::Instant,
     ) -> Result<freshell_platform::claude_inputs::observation::ObservationReply, BackendError> {
         Err(BackendError::Unavailable(
             "Claude native source reader unavailable; retain inputs and reprepare".into(),
@@ -230,6 +235,8 @@ pub trait RuntimeBackend: Send + Sync {
 #[derive(Clone)]
 pub struct DockerEngineBackend {
     socket_path: PathBuf,
+    /// The supervisor's lifecycle JSONL, for helper retry and cleanup events.
+    lifecycle_log: Option<std::sync::Arc<PathBuf>>,
     input_publishers:
         std::sync::Arc<std::sync::Mutex<BTreeMap<String, input_publisher::HeldPublisher>>>,
     input_publication_claims: std::sync::Arc<std::sync::Mutex<std::collections::BTreeSet<String>>>,
@@ -239,11 +246,19 @@ impl DockerEngineBackend {
     pub fn new(socket_path: impl Into<PathBuf>) -> Self {
         Self {
             socket_path: socket_path.into(),
+            lifecycle_log: None,
             input_publishers: Default::default(),
             input_publication_claims: Default::default(),
         }
     }
 
+    /// Record helper retry and late-cleanup events in the supervisor's
+    /// lifecycle JSONL.
+    pub fn with_lifecycle_log(mut self, path: impl Into<PathBuf>) -> Self {
+        self.lifecycle_log = Some(std::sync::Arc::new(path.into()));
+        self
+    }
+
     pub async fn ping(&self) -> Result<(), BackendError> {
         let response = self.request("GET", "/_ping", None).await?;
         if response.status == 200 && response.body.starts_with(b"OK") {
@@ -709,12 +724,14 @@ impl RuntimeBackend for DockerEngineBackend {
         owner: &ClaudeSourceOwner,
         request: &freshell_runtime_protocol::ObserveClaudeSourcesRequest,
         test_run_id: &str,
+        until: tokio::time::Instant,
     ) -> Result<freshell_platform::claude_inputs::observation::ObservationReply, BackendError> {
-        self.read_claude_source_helper(
+        self.observe_claude_sources_with(
+            &helper_lifecycle::CLAUDE_SOURCE_READER_RETRY,
             owner,
             request,
             test_run_id,
-            std::time::Duration::from_secs(25),
+            until,
         )
         .await
     }