Net the trip debt to one figure, and show payer, category and search on Shared

Shared view: the query already returned owner_name and effective_category, the
table just never rendered them. Paid by sits next to Splits because together
they are whose money went out and whose share it was. Search is client-side —
this endpoint returns all 1,267 split rows in one request with no pagination, so
there is nothing for a round-trip to narrow, and the sort was already
client-side. It matches description, merchant, notes, category and payer, but not
participant names: the dropdown does that, and "sonu" matching every row she is
split on would read as broken.

Trip owed collapses to one settle-up figure per person, with the breakdown
beside it so the net is auditable rather than asserted.

I argued against netting a few hours ago and was wrong. The claim was that the
grouped-payment allocation cleared each trip against the one-directional gross,
so netting would redefine that debt after the fact. The rows say otherwise:
Europe's $802.75 is 56 transactions Sonu actually paid across Rome, Venice, the
Dolomites, Bellagio, Lucerne and Paris on which I hold 25%, and paid_by_me is
$0.00 on every row of every trip because nothing has ever been recorded going
from me to her. Her side looked settled only because the allocation derived her
payment split from her gross, so it lands on zero by construction. The
one-directional view was hiding a live obligation, not protecting an allocation.

Nets now: Auckland Sonu +$1,077.25, Europe Sonu -$802.75, Sonu + Sunny -$936.34,
Europe Molina -$816.16.

Also correcting an error in my own reporting: I said Auckland's mirror was
$0.00. It is $428.39 — 17 Auckland rows Sonu paid that I hold a split on. Two
ad-hoc verification queries mis-joined on a nullable scope column and
under-reported the mirror side. The app code was never affected and the owed
column is still byte-identical.

The footnote now states the trap the netting exposes: a debt settled by a payment
left on the household tab still reads as outstanding on the trip. Payment 5
(Molina to Sonu, $1,605.49) is exactly that case and is left alone as a data
decision.

277 passing, build clean.

src/__tests__/integration/queries.test.ts

@@ -935,10 +935,11 @@ describe("trip owed — both directions, never netted", () => {
     expect(Number(alice.paid_by_me)).toBeCloseTo(100);
   });
 
-  // Netting the two would redefine the debt the grouped-payment allocation was
-  // computed against, turning a settled trip into an overpayment and leaving
-  // household understated by the same amount.
-  it("does not net the two directions against each other", async () => {
+  // The API returns both halves whole; the trip page nets them for display. The
+  // halves must stay separately available so that net is decomposable — a net
+  // nobody can audit is how a wrong figure survives, and it is what let Europe
+  // read "settled" while concealing 56 rows Sonu had paid.
+  it("returns each direction whole rather than pre-netted", async () => {
     const { ownerId, otherId } = await seedParticipants(pool);
     const tripId = await seed(ownerId, otherId, ownerId);
     // A second row, paid the other way, so both directions are live at once.
@@ -957,10 +958,40 @@ describe("trip owed — both directions, never netted", () => {
     const bob = participant_splits.find((r) => r.participant_id === otherId)!;
     expect(Number(bob.owed)).toBeCloseTo(100);
     expect(Number(bob.i_owe)).toBeCloseTo(30);
-    // Emphatically not 70.
+    // What the page displays as the single settle-up figure.
     expect(Number(bob.owed) - Number(bob.i_owe)).toBeCloseTo(70);
   });
 
+  // Europe 2026's shape exactly: her side paid in full, his side never paid at
+  // all. The one-directional view called that "settled"; the net must not.
+  it("nets a fully-paid side against an unpaid opposite side", async () => {
+    const { ownerId, otherId } = await seedParticipants(pool);
+    const tripId = await seed(ownerId, otherId, ownerId);
+    // Bob pays his $100 share in full, scoped to the trip.
+    await pool.query(
+      `INSERT INTO split_payments (from_participant_id, to_participant_id, amount, payment_date, trip_id)
+       VALUES ($1, $2, 100, '2026-06-20', $3)`,
+      [otherId, ownerId, tripId]
+    );
+    // But Alice holds a share of something Bob paid for, and never settled it.
+    const bobsTx = await insertTransaction(pool, otherId, { amount: 40, category: "travel" });
+    await pool.query(
+      `INSERT INTO transaction_overrides (transaction_id, trip_id) VALUES ($1, $2)`,
+      [bobsTx, tripId]
+    );
+    await pool.query(
+      `INSERT INTO transaction_splits (transaction_id, participant_id, share_percent)
+       VALUES ($1, $2, 50)`,
+      [bobsTx, ownerId]
+    );
+
+    const { participant_splits } = await getTripAnalytics(tripId, ownerId);
+    const bob = participant_splits.find((r) => r.participant_id === otherId)!;
+    expect(Number(bob.owed)).toBeCloseTo(0);      // his side: settled
+    expect(Number(bob.i_owe)).toBeCloseTo(20);    // her side: never paid
+    expect(Number(bob.owed) - Number(bob.i_owe)).toBeCloseTo(-20); // net: you owe them
+  });
+
   it("reports whether the viewer owns the trip", async () => {
     const { ownerId, otherId } = await seedParticipants(pool);
     const tripId = await seed(ownerId, otherId, ownerId);