Rebase MISTER EXO's ida-codemode port onto the current tree

Mechanical part of the port: the 27-file patch was cut against a base ~148
commits behind us, so it did not apply. Resolved 11 conflicts (all of them
diff drift, not semantic clashes) and the three file deletions:

- app.py: the patch re-inserted _do_rename/_do_name_addr/_seek_split etc. as
  "theirs" because our tree moved them to edit_ctl.py/trace_ctl.py. Kept ours
  and applied the real intent (WorkerClient->CodeModeClient, .call->.invoke,
  _open_worker_client->_open_database_client) at their current homes.
- domain.py: kept Head as a NamedTuple -- the patch reverted it to a frozen
  dataclass, which the perf work measured at 2.9us vs 1.9us per row on a
  quarter-million-row walk. Dropped _fetch_output (no download_url under Code
  Mode) and its now-dead urllib/json imports.
- pane.py: the patch's deletion swallowed our zellij support along with the
  worker-reaping block it meant to remove. Kept zellij, removed the reaping.
- test_scenarios.py: the idb_save->save_database teardown hunk belongs to
  tests/_fixtures.py in our tree; applied it there and kept our pc_num_format
  scenario that the drift landed on.

Three defects in the patch itself, fixed here:

- It made "import idatui" hard-require ida_codemode, so every offline suite
  died at import -- including the pure ones (graph/index/trace) that are the
  house rule for "tests/run.py --fast". The import is now deferred and gated
  on the binding, which is also what lets the port's own contract tests
  inject a fake DatabaseHandle.
- project.stage() inlined an ida_codemode.registry import and treated "library
  not installed" as "someone owns this database", which broke IDA-free project
  staging. Ownership lookup moved to codemode_client.database_owner().
- tests/test_codemode_client.py had no NEEDS_IDA marker, which tests/run.py
  rejects outright.

Offline suite: 301 passed, 0 failed. Against master's 344 the whole delta is
accounted for: -40 worker_client (module deleted), -18 launch sweep checks
(behaviour deliberately removed) +3 guarding that it stays removed, +2 pool
(GUI-save semantics), +13 new codemode_client contract tests.

NOT yet done, and the port is not functional without it: the adapter is
missing five operations our tree grew since the patch's base (flowchart,
op_format, pc_nums, pc_num_format, survey_binary) and its "heads" predates
back-walking and digest/expect.

1 files changed, 49 insertions, 51 deletions

diff --git a/experiments/worker_smoke.py b/experiments/worker_smoke.py
index b215a57..9b55138 100644
--- a/experiments/worker_smoke.py
+++ b/experiments/worker_smoke.py
@@ -1,58 +1,56 @@
-"""Runnable read-path smoke: drives the REAL domain.Program through WorkerClient
-(our idalib worker over a unix socket). Run when idalib can spawn:
-    ~/ida-venv/bin/python experiments/worker_smoke.py
-"""
-import os, sys, shutil, time
-REPO=os.path.expanduser("~/dev/ida-tui-maybe"); sys.path.insert(0, REPO); os.chdir(REPO)
-# fresh copy so the worker's idalib doesn't fight any running server
-src=f"{REPO}/targets/echo"; tmp="/tmp/echo_worker"
-shutil.copy(src, tmp)
-for e in ".i64 .id0 .id1 .id2 .nam .til".split(): 
-    try: os.remove(tmp+e)
-    except OSError: pass
-
-from idatui.worker_client import WorkerClient
-from idatui.domain import Program
-
-print("spawning worker + opening echo…", flush=True)
-t=time.time()
-cl=WorkerClient(tmp)
-cl.connect(progress=lambda m: None)
-print(f"  worker ready in {time.time()-t:.2f}s  session={cl.resolve_db()}", flush=True)
-prog=Program(cl)
+"""Exercise the real domain.Program through an IDA Code Mode lease.
 
-# --- drive the REAL domain layer through the worker (read path) ---
-main=prog.resolve("main")
-print("resolve('main') =", hex(main), flush=True)
-
-idx=prog.functions(); idx.load_all()
-print("functions() ->", len(idx), "funcs", flush=True)
-
-fn=prog.function_of(main)
-print("function_of(main) ->", fn.name, hex(fn.addr), "size", fn.size, flush=True)
+A matching registered GUI is reused; otherwise Code Mode starts a managed
+idalib worker. Usage: ``uv run python experiments/worker_smoke.py FILE``.
+"""
+from __future__ import annotations
 
-b=prog.read_bytes(main, 16)
-print("read_bytes(main,16) ->", b.hex(), flush=True)
+import os
+import sys
+import time
 
-lm=prog.listing(main)
-for _ in range(3): lm.load_next_page()
-rows=[lm.get(i) for i in range(min(6,len(lm)))]
-print("listing() first rows:", flush=True)
-for h in rows:
-    if h: print("   ", hex(h.ea), h.kind, repr(h.text[:44]), flush=True)
+from idatui.codemode_client import CodeModeClient
+from idatui.domain import Program
 
-d=prog.decompile(main)
-print("decompile(main) -> failed?", d.failed, "lines:", len((d.code or '').splitlines()), flush=True)
 
-regs=prog.file_regions()
-print("file_regions ->", len(regs), "segments", flush=True)
+def main() -> int:
+    target = os.path.abspath(sys.argv[1] if len(sys.argv) > 1 else "experiments/fibonacci.elf")
+    print(f"attaching Code Mode to {target}…", flush=True)
+    started = time.time()
+    client = CodeModeClient(target)
+    client.connect(progress=lambda message: print(f"  {message}", flush=True))
+    print(
+        f"  ready in {time.time() - started:.2f}s; backend={client.backend}; "
+        f"session={client.resolve_db()}",
+        flush=True,
+    )
+    program = Program(client)
+    try:
+        index = program.functions()
+        index.load_all()
+        print(f"functions() -> {len(index)}", flush=True)
+        first = index.get(0)
+        if first is None:
+            print("VERDICT: FAIL — no functions", flush=True)
+            return 1
+        fn = program.function_of(first.addr)
+        data = program.read_bytes(first.addr, 16)
+        decompilation = program.decompile(first.addr)
+        print(f"function_of() -> {fn}", flush=True)
+        print(f"read_bytes() -> {data.hex()}", flush=True)
+        print(
+            f"decompile() -> failed={decompilation.failed}; "
+            f"lines={len((decompilation.code or '').splitlines())}",
+            flush=True,
+        )
+        print(f"file_regions() -> {len(program.file_regions())}", flush=True)
+        ok = fn is not None and bool(data) and bool(program.file_regions())
+        print(f"VERDICT: {'OK' if ok else 'FAIL'}", flush=True)
+        return 0 if ok else 1
+    finally:
+        program.close()
+        client.close()
 
-# xrefs to a called function
-callee=next((f.addr for f in idx.all_loaded() if f.name.startswith("sub_")), None)
-if callee:
-    xr=prog.xrefs_to(callee)
-    print("xrefs_to(", hex(callee), ") ->", len(xr), "refs", flush=True)
 
-ok = (fn.name=="main" and len(idx)>100 and b and not d.failed and len(regs)>0)
-print("VERDICT:", "OK — domain.Program runs unchanged on the worker" if ok else "FAIL", flush=True)
-cl.close()
+if __name__ == "__main__":
+    raise SystemExit(main())