iris is the framework alone; the app is one crate in app-rust/

Iris: "the organization of the rust rewrite is a mess right now... there
shouldn't be anything related to the app inside of iris. Iris is supposed
to be the UI framework alone." And, on the crate count: "I'm confused why
the app only code needs more than one crate though."

Nine cargo workspaces become three, and the port's project code -- which
sat in five places, four of them inside the framework -- becomes one crate,
`ai-app`, in `app-rust/`:

  client-core                -> app-rust/src/client
  iris/transcript-ui         -> app-rust/src/ui
  iris/transcript-fixture    -> app-rust/src/ui/fixture.rs + tests/ + touch/
  iris/desktop-app           -> app-rust/src/desktop + src/bin_desktop.rs
  iris/android-app           -> app-rust/src/android + android-project/
  android-shell              -> app-rust/src/shell

iris/ keeps core, macro, the iris crate, tabs-ui and rig-input, and now
mentions no session, transcript, setup or server anywhere.

Only two of the old splits had a reason that survived reading. event-model
stays a crate at the repo root because server/ depends on it too, so a
crate is what makes the backend and the app agree by construction. The two
Android .so names looked like a hard constraint -- a package produces one
library artifact -- until P2 turned out to already plan merging those two
Android apps into one; both faces now come out of libai_app.so, picked
apart by features so `--no-default-features --features shell` keeps wgpu,
parley and iris out of the Compose app's APK. docs/RUST.md's "One app
crate" has the rest, including what each remaining feature is for.

DECISIONS.md and SUBAGENTS.md move into docs/ with everything else.

Verified: ./run-tests.sh and `cd iris && cargo test` green, clippy and fmt
clean in all five workspaces, `cargo ndk -t x86_64` links libai_app.so,
build-apk.sh produces an APK that installs and launches on this checkout's
emulator (Gl ... virgl, as expected), and the phone-sized headless
screenshot renders the transcript unchanged.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

app-rust/src/ui/tap.rs

@@ -0,0 +1,80 @@
+//! A tap on something in the transcript, and holding the reader's edge
+//! while what they tapped changes height.
+//!
+//! Both halves are shared by everything in the transcript that opens: a
+//! tool card and its group ([`crate::ui::tool`]), and a message's "Show all"
+//! ([`crate::ui::row`]). They are here rather than in either of those because
+//! there is one right answer to "was that a tap?" on this screen, and two
+//! copies of it would eventually disagree -- which on a scrolling screen
+//! means one of them firing at the end of a pan.
+
+use crate::ui::selection::Selection;
+use iris::prelude::*;
+use std::{cell::RefCell, rc::Rc};
+
+/// Register `f` as `ptr`'s **tap**, panning the list instead when the
+/// finger moves.
+///
+/// `Selection::drag` with no row is the same call `row.rs` makes with one:
+/// it drives the shared `DragArbiter`, so a drag starting on a card
+/// scrolls (and flings) the transcript exactly as one starting on a
+/// paragraph does, and only a press that committed to nothing comes back
+/// as `Tapped`. A bare `CursorSense::click()` would be a second,
+/// disagreeing detector -- it fires at the end of a pan too, so every
+/// scroll that began on a card would also toggle it.
+pub(crate) fn on_tap<Rsc: HasEvents>(
+    rsc: &mut Rsc,
+    ptr: WeakWidget<WidgetPtr>,
+    list: WeakWidget<LazySpan>,
+    selection: Rc<RefCell<Selection>>,
+    f: impl Fn(&mut Rsc) + 'static,
+) where
+    Rsc::State: FocusHost + OpenUrl,
+{
+    // The whole `drag_senses()` set -- what any widget driving a
+    // `DragGesture` registers, `Cancel` included. See `row.rs`'s twin
+    // registration for what leaving `Cancel` out did.
+    ptr.on(CursorSense::drag_senses(), move |ctx, rsc| {
+        let outcome = selection.borrow_mut().drag(
+            rsc,
+            list,
+            None,
+            ctx.data.cursor.pos,
+            ctx.data.sense,
+            ctx.data.cursor.time,
+            ctx.data.pointer,
+        );
+        if outcome == GestureOutcome::Tapped {
+            f(rsc);
+        }
+    })
+    .add(rsc);
+}
+
+/// Hold the edge the reader is looking at while row `key` changes height.
+///
+/// `LazySpan::note_tap` wants a viewport-relative position and a row only
+/// knows its own box, so `LazySpan::extent` (last frame's on-screen box
+/// for this key) turns the two into the position `lazy_span.rs`'s
+/// hold-the-edge pass resolves against -- the two-step contract that
+/// module's doc describes for `AGENTS.md`'s `holdTopEdge`.
+///
+/// Call it **before** the change, from every handler that makes a row
+/// taller or shorter: opening a card, opening a group, asking for the
+/// whole of a capped block or message. A handler that skips it is one
+/// where the transcript jumps under the reader's finger.
+pub(crate) fn hold_edge(rsc: &mut impl UiRsc, list: WeakWidget<LazySpan>, key: RowKey) {
+    // Only when the list actually has an extent for this row. `None`
+    // means the row has not been drawn yet -- which happens the moment
+    // something opens a group before the first frame
+    // (`TranscriptScreen::expand_tail_tools`, the headless screenshot) --
+    // and standing in `0.0` for it tells the layout pass to hold an edge
+    // at the top of the viewport that nothing was ever at. The whole list
+    // then places itself against that invented anchor: rows drawn at each
+    // other's cached heights, tool cards as empty bars with their text a
+    // group's height below them (`docs/bench/p1b-2026-09-06/`'s first
+    // attempt). Nothing to hold is not the same as an edge at zero.
+    if let Some((top, _bottom)) = list(rsc).extent(key) {
+        list(rsc).note_tap(top);
+    }
+}