REPL

• The JS REPL now shares scope across evaluations — each submission runs through indirect eval so declarations land on the global object and persist, with a leading let/const rewritten to var so it survives too, matching the Node REPL.

Missions

• A second OpenAI-compatible provider: the local and URL providers fold into one configurable OpenAICompatibleProvider, so a remote endpoint can be set alongside the local one. The mission sheet accepts optional API keys for compatible providers, and duplicate /v1 segments collapse when building request URLs. Thanks @eunhhu!
• The latest streamed mission reply stays visible until it is persisted — the live assistant text now clears on an explicit liveTextCleared event emitted once the turn is saved, rather than on messageStop/finalMessage, so navigating away and back no longer drops it. Thanks @eunhhu!

Fixes & internals

• Compiler diagnostics surface on failure: CompileFailure conforms to LocalizedError, so the underlying message and collected diagnostics reach the user instead of the opaque "LumaCore.CompileFailure error 1" default.
• Tracer hook globals are declared for type checking — the defineHandler ambient declarations feed the hook compiler, wrapped in a declare-global module so they stay out of package and custom-instrument compiles that share the workspace root.
• The Nix version-bump automation is fixed.

r2 in the REPL (new)

The REPL gains radare2 as a first-class language alongside JavaScript.
The prompt is a clickable mode toggle, and :, :r2, :js switch
from the keyboard. r2 input routes through the session disassembler
and renders JSON commands as an inspectable value tree, everything
else as ANSI-parsed styled text.

• Autocompletion for both languages: r2 commands complete via r2's
  own help tree and arguments against flag and symbol names; JS
  completions are annotated with Frida types from the embedded
  frida-gum typings.
• px/x hexdumps render in the interactive hex view with real
  addresses; r2 results keep their colors when pinned to the
  notebook.
• The REPL seeds its seek to the main module base on open, and
  persists the r2 seek as an address anchor that re-bases across runs.
• Output and prompt reworked: long lines scroll horizontally instead
  of wrapping, long text reveals in chunks with show-more / show-all,
  the prompt is a single mode-colored glyph, and the empty state
  shows a per-mode example.

Markdown rendering (new)

A block-level Markdown renderer ported into LumaCore and shared by
both frontends: headings, lists, tables, task lists, blockquotes,
code blocks, and footnotes, with inline spans, LaTeX-to-Unicode
rewriting, and StyledText code highlighting. Based on code by
@trufae.

Sidebar: modules & threads

• Modules and threads move from tabs into collapsible sidebar groups
  that mirror the hooks UX — a few top picks plus a browse popover
  for the rest, with threads collapsed by default. One sidebar-row
  and one browser-popover component is now shared across hooks,
  modules, and threads in both frontends.
• Instrument hooks get a disclosure chevron with per-instrument
  collapsed state persisted in session UI state.
• Module analysis is lazy with a per-module Analyze action and status
  indicator; persisted analyses replay into a fresh r2 core on attach
  to restore last session's warm state without blocking.
• Program modules group ahead of system ones.

Disassembly

• Hex address operands are clickable for the pointer actions while
  the rest of the line stays selectable; the reread/reanalyze buttons
  overlay instead of pushing content down.
• First-view disassembly analyzes the function on demand so it stops
  at the function end instead of overshooting, and draws jump/call
  flow arrows sourced from pdj/pDj.
• Fixed operand address context menus that the system selection menu
  was hiding (macOS) or opening alongside (GTK).

Collaboration

• The redundant "driver" seat is gone; session interaction gates on
  ownership. Hosting is claimed through an acknowledged request and
  attaches only once the server accepts, instead of optimistically.
  Spawn/attach/re-attach controls gate on owner + lab-joined + seat
  free, and re-attach is disabled while offline.
• Host-ownership checks resolve before the collaboration bus connects
  via Engine.localUserID (falling back to the GitHub identity), so
  the banner, REPL, and host badge are correct before reconnect.
• Token poll retries on transient network loss, so switching to the
  browser to authorize on iOS no longer kills sign-in.

Fixes & internals

• Existing project databases gain the REPL, seek, and styled-notebook
  columns on open — create-if-not-exists never altered shipped
  tables, so saves failed.
• Custom instrument handling hardened; runtime parsing and rendering
  guarded; mission transcript updates throttled and context reads
  optimized; agent bundles generated through a SwiftPM plugin. Thanks
  to Sunwoo Moon (@eunhhu).
• JS REPL completion no longer dumps global scope; out-of-range JS
  numbers no longer trap.

Packaging

• The Nix flake exposes an overlay and extracts package.nix so the
  package can be consumed standalone. Thanks to Abhi (@AbhiTheModder).

Collaboration

• Join labs from https://luma.frida.re/l/<code> invite links
  alongside the luma:// scheme. iOS delivers universal links via
  NSUserActivity and opens a project from the welcome screen to
  consume the join queue; the associated-domains entitlement is added
  on iOS and macOS.

Fixes

• Notes & AI chat stay open while approving a tool call. Approve and
  reject now appear inline in the address-note chat with the tool's
  code preview, and the global action-queue popover no longer evicts
  the chat for ambient note-reply actions. In-flight reply text is
  tracked on the engine so it survives the chat closing and restores
  on reopen. On GTK the chat is hosted in an Adw.Dialog so it can
  stay open while the reply streams.
• Only locally created notes auto-enter edit mode — empty new notes
  broadcast immediately, so previously every client auto-edited.
• REPL input no longer re-steals focus after resigning first
  responder, which had interrupted lab-title editing.

Fixes

• Tracer hooks dedup by resolved address. An imported symbol anchors
  to the linked library path while a search anchors to the defining
  module, so anchor-string equality never matched and the search
  offered Add instead of Go to Hook. Both frontends now match by the
  agent-resolved address, and resolve() accepts a module identified
  by path, not just leaf name.
• Module symbol rows get a full-row address menu: right-clicking
  anywhere on an export/import/symbol row opens the address menu, with
  the copy item labeled "Copy Address". On macOS each cell carries the
  menu and hover-warms facts.

Fixes

• Address facts resolve on hover rather than eagerly per row. Eager
  resolution ran r2 function analysis on the main actor for every
  visible pointer cell, flooding the console and starving table
  selection; now only the pointed-at address is analyzed and the menu
  opens populated.
• radare2's own stderr echo is silenced (log.quiet) on both
  disassembler cores, so read-only function probes no longer flood
  the console. Error detection is unchanged.

Missions

• Claude subprocess retries surface as live notices, so model
  overload is visible instead of a silent spinner. When claude
  exits with empty stderr, the streamed error detail is shown
  instead.

Fixes

• Session UI selection applies synchronously: clicking a row reflects
  immediately instead of reverting on the next render. Only the
  SQLite write is deferred.

Address facts & gated actions (new)

Luma now resolves what an address is — executable, a function
start, data, or unmapped — from page protection and the
disassembler, cached per process identity. A single shared
value+menu component per frontend renders pointer values with a
context menu gated by those facts: Copy, Open Disassembly when
executable, Open Memory when mapped, then the hook actions. This
replaces the per-site menus, and extends to the CFG view, where
right-clicking an instruction offers the same gated actions.

• Resolution is skipped while detached and the cache is invalidated
  when re-attaching to a different process.
• Facts resolution is kept off the selection path (@ObservationIgnored
  caches), so resolving a value no longer rebuilds tables mid-click.

Thread register view

• Registers reflow into a multi-column grid in both frontends, with
  selectable values and a narrower thread list to make room.
• arm64 register order is canonicalized in the snapshot — GPRs, then
  sp/pc/nzcv, then vectors — and shared with the CFG view via
  CpuRegisterLayout.
• Vector registers are hex-encoded (they're ArrayBuffers, previously
  rendered as [object ArrayBuffer]).

Disassembly & modules

• Page Up/Down, Home, End, and auto-select of the first instruction
  in the address-insight disassembly, in both frontends.
• Module pane fills with a centered detached/error message instead of
  collapsing when symbols are unavailable; undefined symbols are
  skipped since they only duplicate the imports list.
• Hook and insight names derive from the resolved symbol rather than
  module!symbol / module+offset strings, and navigating to a
  function start reuses the existing named insight instead of minting
  a sub_<offset> duplicate.

Tracer & ITrace

• Tracer errors route to a per-hook loadFailed status surfaced by
  the sidebar indicator and suppressed from the raw event log;
  cleared on the next config apply.
• ITrace is capped by captures rather than invocations, so raising the
  limit or re-arming resumes capture instead of staying stuck at the
  old count.
• Trace instructions carry their real address, so callers map lines
  without assuming fixed-width instructions.

GTK frontend

• Fixed a CFG context-menu crash: the popover anchors to the captured
  toplevel root so it survives the right-clicked widget being rebuilt,
  and is built from a plain popover and box so it sizes to its
  contents.

Build & dependencies

• Agent regenerates reliably on macOS's Make 3.81 (the grouped-target
  &: syntax it predates ran the bundle recipe twice).
• frida-swift / frida-core bumped; gir2swift and SwiftHarfBuzz bumped
  for the GTK build.

GTK frontend

• Document handling aligned with the GNOME HIG: .luma bundles open
  via a folder picker, dirty state tracks store commits with a title
  dot, Save (Ctrl+S) is wired, and closing prompts on unsaved
  changes.
• Open documents are restored on launch: whatever windows remain at
  exit come back next time, like gnome-text-editor. Entries whose
  files are gone are pruned.
• App icons re-rendered from icon-mac.svg (hicolor PNGs, snap icon,
  Windows .ico) to match the coral L SwiftUI icon.
• REPL session boundary centers its label between two rules and reads
  "New process attached at ", matching the SwiftUI frontend.
• Banner layout no longer stretches the divider or floats the icon
  for wrapped, multi-line messages.

Agent

• Thread registers read via toJSON() — register fields are
  non-enumerable accessors, so Object.entries returned nothing.
• Single-thread lookups use findThreadById instead of enumerating
  every thread.

Dependencies

• frida-core / frida-swift bumped; @types/frida-gum to 19.7.0.

Dependencies

• frida-core and frida-swift bumped; frida-swift now tracks
  FridaCore 17.14.0.

Target picker

• Each process now shows its command line beneath the name, so
  several processes sharing a name — multiple python3, helper
  processes and the like — can be told apart at a glance. The PID
  folds into that subtitle (PID 1234 · …) and the filter matches
  the command line too. Falls back to just the PID when the OS
  reports no arguments. Both the macOS and GTK frontends.

Packaging

• Nix flake runtime deps completed: glib-networking for the GIO
  TLS backend — without it all HTTPS via libsoup/WebKit silently
  failed — plus libgee, atk, sqlite and libxml2, with the libxml2
  replace-needed retargeted onto libFoundationXML, its actual
  consumer. A flake.lock is now committed for reproducible builds.

Dependencies

• frida-core / frida-swift bumped: process enumeration gains a
  full-scope argv parameter (Windows, macOS, Linux, FreeBSD),
  exposed through ProcessDetails.argv.