projects phase 4: cross-binary back, linkage-guided pre-warm, project verbs

Three things, all following from phase 3 making cross-binary jumps ordinary.

**A cross-binary jump was a one-way door.** Nav history is per-binary, so
arriving in another binary — a project search hit, or now following an import
into the library that implements it — landed you in an empty history with nothing
to take you back. _switch_then_goto records the binary it came FROM, and
action_back falls through to that hop once local history is spent: Esc walks back
through the function you were in, then the binary you were in. Manual Ctrl+O
switching records nothing, because that isn't navigation.

**Pre-warm follows the linkage graph, not list order.** _prewarm_provider warms
the binary providing the most of this one's imports — where a follow is most
likely to go, so its startup is paid before you ask for it. "Next in the list"
would have been arbitrary; phase 3 gave us something better to ask.

pool.prewarm() refuses rather than making room. Evicting a binary the user
visited to speculatively load one they haven't is a straight downgrade, and it
throws away that binary's caches as well; at a tight budget pre-warm just does
nothing. The cost of a worker that doesn't exist yet can only be estimated, so it
uses the largest resident one (same program, different database) — and if that
estimate proves wrong, the speculative worker is the one evicted, never a chosen
one.

**Driving a project.** pane spawn --project FILE [--open BIN]; `binaries` lists
the inventory (active / resident / indexed / where Esc returns to) and `switch
{binary,addr?}` makes another active — with an address it takes the search-hit
path, so it records a hop. state gains `binary` and `hops`, which it should have
had the moment project mode existed.

Verified on real sessions: drive binaries/switch against an echo+cat project
pane; Esc crossing back from a switch; and prewarm on echo+libc picking libc
(provider of echo's imports) and warming it after an evict.

tests: +5 pool (prewarm warms, no-ops when resident, refuses at budget, evicts
nothing when refusing, ignores unknown labels) and +4 project UI (jump records
the hop, Esc crosses back, hop consumed). Confirmed the Esc-back checks fail with
the branch removed. 195/0 scenarios, 27/0 project UI, 36/0 index, 27/0 pool,
33/0 project.

Left open: project-level persistence across sessions.

1 files changed, 51 insertions, 1 deletions

diff --git a/idatui/app.py b/idatui/app.py
index 39a4b94..cef58f1 100644
--- a/idatui/app.py
+++ b/idatui/app.py
@@ -3170,6 +3170,7 @@ class IdaTui(App):
         self._states: dict[str, BinaryState] = {}
         self._pending_restore = None          # entry to reopen after a switch
         self._goto_after_switch = None        # cross-binary search hit to land on
+        self._hops: list[str] = []            # binaries a navigation crossed FROM
         self._nav_seq = 0                     # bumped per navigation; drops stale ones
         # None = teardown wasn't an explicit quit (crash/kill): save defensively.
         # False = the user chose discard, or we already saved on the way out.
@@ -3486,6 +3487,41 @@ class IdaTui(App):
         self.app.call_from_thread(self._auto_land)
         self._index_binary()  # project mode: keep the cross-binary index fresh
 
+    @work(thread=True, exclusive=True, group="prewarm")
+    def _prewarm_provider(self) -> None:
+        """Warm the binary this one leans on hardest, once we're idle.
+
+        Not "the next in the list" — phase 3 tells us something better. The
+        binary providing the most of this one's imports is where a follow is
+        most likely to take you, so paying its startup now is the switch you
+        would otherwise wait for. Refuses to evict anything (see pool.prewarm),
+        so at a tight budget this simply does nothing.
+        """
+        if self._pool is None or self._index is None or self._binary is None:
+            return
+        try:
+            imps, _ = self.program.linkage()
+        except Exception:  # noqa: BLE001
+            return
+        if not imps:
+            return
+        from collections import Counter
+        votes: Counter = Counter()
+        for name in {i.name for i in imps}:
+            for h in self._index.providers(name, exclude=self._binary):
+                votes[h.binary] += 1
+        resident = set(self._pool.resident())
+        cand = next((b for b, _ in votes.most_common() if b not in resident), None)
+        if cand is None:
+            return
+        n = votes[cand]
+        try:
+            if self._pool.prewarm(cand):
+                self.app.call_from_thread(
+                    self._status, f"pre-warmed {cand} (provides {n} imports)")
+        except Exception:  # noqa: BLE001 -- speculative work must never surface
+            pass
+
     @work(thread=True, exclusive=True, group="index")
     def _index_binary(self) -> None:
         """Fold this binary's symbols + strings into the project index, so it can
@@ -3516,6 +3552,7 @@ class IdaTui(App):
             return
         self.app.call_from_thread(
             self._status, f"indexed {self._binary}: {n} symbols, strings + linkage")
+        self._prewarm_provider()
 
     # -- initial landing --------------------------------------------------- #
     #: function names tried (in order) as the startup landing spot
@@ -3695,7 +3732,15 @@ class IdaTui(App):
 
     def _switch_then_goto(self, binary: str, addr: int) -> None:
         """A project-wide hit in another binary: switch to it, then jump there
-        once its index has loaded."""
+        once its index has loaded.
+
+        Records the hop so Esc can come back. Nav history is per-binary, so
+        without this a cross-binary jump — a project search hit, or following an
+        import into the library that implements it — is a one-way door: you
+        arrive in a binary whose history is empty and nothing takes you back.
+        """
+        if self._binary is not None and binary != self._binary:
+            self._hops.append(self._binary)
         self._goto_after_switch = addr
         self._switch_binary(binary)
 
@@ -4117,6 +4162,11 @@ class IdaTui(App):
             dest = self._nav[-1]
             self._status(f"\u25c2 back to {dest.name}\u2026")
             self._open_entry(dest, push=False)
+        elif self._hops:
+            # Local history is spent, but we got here from another binary.
+            label = self._hops.pop()
+            self._status(f"\u25c2 back to {label}\u2026")
+            self._switch_binary(label)   # _states restores its nav and position
         elif self.query_one("#left", FunctionsPanel).display:
             table.focus()
         else: