feat: prefetch visible interface descriptors

crates/wip-tui/src/app.rs

@@ -612,6 +612,30 @@ impl App {
         visible
     }
 
+    /// Returns interface references advertised by fresh visible Objects in display
+    /// and per-Object declaration order, with duplicates removed.
+    #[must_use]
+    pub fn visible_interface_references(&self) -> Vec<String> {
+        let mut references = Vec::new();
+        let mut seen = BTreeSet::new();
+        for path in self.visible_paths() {
+            let Some(object) = self
+                .entries
+                .get(&path)
+                .filter(|entry| entry.state == ViewState::Fresh)
+                .and_then(|entry| entry.object.as_ref())
+            else {
+                continue;
+            };
+            for reference in &object.interfaces {
+                if seen.insert(reference.clone()) {
+                    references.push(reference.clone());
+                }
+            }
+        }
+        references
+    }
+
     fn collect_visible(&self, path: &str, seen: &mut BTreeSet<String>, visible: &mut Vec<String>) {
         if !seen.insert(path.to_owned()) {
             return;
@@ -780,6 +804,52 @@ mod tests {
         ));
     }
 
+    #[test]
+    fn visible_interface_references_are_ordered_deduplicated_and_fresh() {
+        let mut app = App::new("https://example.test/wip");
+        app.apply_tree(TreeObservation {
+            path: "/".into(),
+            children: vec!["/a".into(), "/stale".into()],
+            revision: request_id(),
+            state: ObservationState::Fresh,
+        });
+        app.apply_object(ObjectObservation {
+            path: "/".into(),
+            object: Some(object("", &["root", "shared"])),
+            validator: None,
+            state: ObservationState::Fresh,
+        });
+        app.apply_object(ObjectObservation {
+            path: "/a".into(),
+            object: Some(object("a", &["shared", "child"])),
+            validator: None,
+            state: ObservationState::Fresh,
+        });
+        app.apply_object(ObjectObservation {
+            path: "/stale".into(),
+            object: Some(object("stale", &["ignored"])),
+            validator: None,
+            state: ObservationState::Stale,
+        });
+        app.apply_tree(TreeObservation {
+            path: "/a".into(),
+            children: vec!["/a/hidden".into()],
+            revision: request_id(),
+            state: ObservationState::Fresh,
+        });
+        app.apply_object(ObjectObservation {
+            path: "/a/hidden".into(),
+            object: Some(object("hidden", &["hidden"])),
+            validator: None,
+            state: ObservationState::Fresh,
+        });
+
+        assert_eq!(
+            app.visible_interface_references(),
+            ["root", "shared", "child"]
+        );
+    }
+
     #[test]
     fn focus_modal_and_explicit_confirmation_gate_execution() {
         let mut app = App::new("https://example.test/wip");

crates/wip-tui/src/runtime.rs

@@ -408,7 +408,9 @@ impl<T: Transport> Runtime<T> {
         if self.app.connection != ConnectionState::Connected {
             return;
         }
-        for path in self.app.visible_paths() {
+        let paths = self.app.visible_paths();
+        let references = self.app.visible_interface_references();
+        for path in paths {
             match self.client.ensure_children_observed(&self.session, &path) {
                 Ok(Some(request)) => {
                     self.dispatch(request, InFlightKind::Tree(path), false);
@@ -420,6 +422,18 @@ impl<T: Transport> Runtime<T> {
                 }
             }
         }
+        for reference in references {
+            match self.client.ensure_interface(&self.session, &reference) {
+                Ok(Some(request)) => {
+                    self.dispatch(request, InFlightKind::Interface(reference), false);
+                }
+                Ok(None) => {}
+                Err(error) => {
+                    self.local_error("interface lookahead", error);
+                    break;
+                }
+            }
+        }
     }
 
     fn dispatch(&mut self, request: PreparedRequest, kind: InFlightKind, operation: bool) {