Merge the IDA Code Mode port

Replaces the private idalib worker (idatui/worker.py + worker_client.py, with
server/patch_server.py injecting tools into ida-pro-mcp) with an ordinary
client of ida_codemode.client.DatabaseHandle. A database open by an IDA GUI is
reused; otherwise Code Mode starts or shares a managed idalib worker. The TUI
no longer owns an IDA process, and closing it releases only its lease.

Based on Duncan Ogilvie's port, rebased onto ~150 commits of local work it
predated. The rebase itself was mechanical; landing it was not. Nine defects
had to be fixed before the feature set was whole again, none of which the
patch's own tests could catch:

  - DatabaseHandle.open() takes image_base, not loading_address: every
    connect() would have raised TypeError on the first call
  - five operations our tree had grown were simply missing (flowchart, so the
    graph view was dead; op_format/pc_nums/pc_num_format, so 'o'/'O' were;
    survey_binary)
  - set_comments wrote only the disassembly comment, so comments never
    appeared in pseudocode
  - xref_query returned rows in raw IDA order, and 'follow the call' silently
    followed the fall-through instead
  - rename accepted one edit per category, so bulk symbol import was dead
  - decompile ran decomp_map's full per-column ctree sweep to fill in a
    per-line address anchor
  - heads shipped without operand extents or the digest protocol
  - the package became unimportable without ida_codemode installed, which
    killed the offline test suites

Verified against the pre-codemode tag rather than against assumptions: the
full suite is 788 passed / 0 failed, and the pilot's 301 checks match the old
backend exactly. Performance is within 2x on the listing hot path and faster
on decompile, disasm and connect, after fixing two runtime costs that are
documented for upstream in docs/CODEMODE_UPSTREAM.md.

Test runtime came down from ~9m20s to 115s along the way -- not by removing
checks, but by removing four kinds of waiting-on-a-guess that were also
hiding real failures.

1 files changed, 37 insertions, 1 deletions

diff --git a/tests/_fixtures.py b/tests/_fixtures.py
index 766ecd5..0b72856 100644
--- a/tests/_fixtures.py
+++ b/tests/_fixtures.py
@@ -37,6 +37,36 @@ def cache_is_fresh(binary: str) -> bool:
     return os.path.exists(c) and os.path.getmtime(c) >= os.path.getmtime(binary)
 
 
+#: Generated targets live here so their pristine caches survive between runs.
+#: Gitignored; safe to delete (the next run rebuilds both).
+SYNTHETIC_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), ".synthetic")
+
+
+def synthetic(name: str, build) -> str:
+    """A generated binary at a STABLE path, rebuilt only when its bytes change.
+
+    Generated targets used to be written into a fresh TemporaryDirectory on
+    every run, which quietly defeated the whole pristine-cache scheme: a new
+    path with new bytes every time means auto-analysis is paid in full, every
+    run, forever. `test_blob_ui`'s 64KB blob cost ~40s a run that way.
+
+    ``build()`` must be DETERMINISTIC and return bytes. That is also what makes
+    the suites reproducible: a blob built from os.urandom can, by luck, contain
+    something IDA reads as a function, and then a test asserting "no functions"
+    fails for reasons no one can reproduce.
+    """
+    os.makedirs(SYNTHETIC_DIR, exist_ok=True)
+    path = os.path.join(SYNTHETIC_DIR, name)
+    data = build()
+    if not os.path.exists(path) or open(path, "rb").read() != data:
+        with open(path, "wb") as fh:          # content changed -> cache is stale
+            fh.write(data)
+        for stale in (cache_path(path), path + ".i64"):
+            if os.path.exists(stale):
+                os.remove(stale)
+    return path
+
+
 async def build_pristine(binary: str, cache: str, app_factory) -> None:
     """Analyse ``binary`` once and keep the database as a golden copy.
 
@@ -50,7 +80,13 @@ async def build_pristine(binary: str, cache: str, app_factory) -> None:
             await pilot.pause(0.05)
             if app._func_index is not None and app._func_index.complete:
                 break
-        app.program.client.call("idb_save", timeout=600.0)
+        app.program.client.save_database()
+    # Textual's headless run_test context does not reliably emit App.Unmount on
+    # every platform/version; release the Code Mode lease explicitly.
+    if app.program is not None:
+        app.program.close()
+    if app.client is not None:
+        app.client.close()
     db = binary + ".i64"
     if os.path.exists(db):
         shutil.copy2(db, cache)