Method reconcile_store_with_backend

crates/openshell-server/src/compute/mod.rs:1036–1081

(&self, grace_period: Duration)

    }

    async fn reconcile_store_with_backend(&self, grace_period: Duration) -> Result<(), String> {
        let sweep_started_at_ms = openshell_core::time::now_ms();
        let backend_sandboxes = self
            .driver
            .list_sandboxes(Request::new(ListSandboxesRequest {}))
            .await
            .map_err(|e| e.to_string())?
            .into_inner()
            .sandboxes;
        let backend_ids = backend_sandboxes
            .iter()
            .map(|sandbox| sandbox.id.clone())
            .collect::<std::collections::HashSet<_>>();

        for sandbox in backend_sandboxes {
            self.reconcile_snapshot_sandbox(sandbox, sweep_started_at_ms)
                .await?;
        }

        let records = self
            .store
            .list(Sandbox::object_type(), 500, 0)
            .await
            .map_err(|e| e.to_string())?;

        let grace_ms = grace_period.as_millis().try_into().unwrap_or(i64::MAX);

        for record in records {
            let sandbox = match Sandbox::decode(record.payload.as_slice()) {
                Ok(sandbox) => sandbox,
                Err(err) => {
                    warn!(error = %err, "Failed to decode sandbox record during reconciliation");
                    continue;
                }
            };

            if backend_ids.contains(sandbox.object_id()) {
                continue;
            }

            self.prune_missing_sandbox(record, sweep_started_at_ms, grace_ms)
                .await?;
        }

        Ok(())
    }

    async fn apply_watch_event(&self, event: WatchSandboxesEvent) -> Result<(), String> {
        match event.payload {