M2: the full job lifecycle — chat, hiring, geocoding, quotes, bookings, reviews

Closes the funnel. Before this the product could match two people and then
stopped: `quotes`, `bookings` and `reviews` had tables and state machines and
nothing that wrote a row, the entry deck's right swipe was wired to an empty
handler, and every address resolved to the city centre.

Jobs tab and chat
- message router: thread, send, markRead, unreadTotal. A thread is a MATCH, not
  a job — one job with three interested pros is three private conversations.
- Current/Past segments derived from ACTIVE_JOB_STATUSES, job detail listing the
  pros who accepted, and the conversation itself with attachments.

Hiring from the deck
- A right swipe on the entry deck opened nothing. It now resolves "which job?"
  through a sheet — sign in, pick an open job, or post one — and calls the same
  deck.swipe the per-job deck does, so the open-request cap and row lock apply
  exactly once. Swipes are vetoable so closing the sheet returns the card.

Geocoding
- ST_Distance and ST_DWithin rank and filter every deck, and both operands were
  placeholders. Addresses now resolve through Mapbox (permanent=true, which is
  what licenses storing the coordinates), the server resolves points rather than
  trusting client-supplied lat/lng, and every stored point records how it was
  obtained. A `city`-precision base cannot reach the verification queue.

Quote -> booking -> review
- The commercial chain, minus payments. Accepting a quote is the only place a
  booking is created; confirming completion is what unlocks reviews and moves
  the pro's completed_jobs.
- Reviews publish double-blind with no sweeper: each is written with
  published_at already set to its embargo deadline and every read filters
  published_at <= now(), so it publishes itself. The second review pulls both
  forward. A silent counterparty cannot bury a bad review by never replying.

State machine changes, both deliberate
- booked -> matched: a cancelled booking is not a cancelled job.
- scheduled -> awaiting_confirmation: in_progress is optional, so a pro who
  never tapped Start can still say the work is done.

Test suite
- api tests ran files in parallel against one database and failed roughly one
  run in three on whichever file lost the race. Serialised, and three fixtures
  that grabbed "the first client" pinned to the seeded accounts.

Also includes work from a parallel session: admin verification queue, pro
public profile and reviews read path, notification sending, denormalised stats
recompute, search, and observability.

318 tests passing; typecheck and lint clean across 7 packages.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

packages/geocode/test/geocode.test.ts

@@ -0,0 +1,122 @@
+/**
+ * Unit tests. No network, no credentials — everything here runs offline against
+ * recorded Mapbox payloads.
+ *
+ * The thing worth testing is the precision mapping. A geocoder always returns
+ * *something*: ask it for a misspelled street and it hands back the city, very
+ * confidently. Treating that as a located address is precisely the bug this
+ * package exists to remove, so "did we get a result" must never be the signal.
+ */
+import { describe, expect, it } from 'vitest';
+import { GeocodeError, parseResponse, precisionOf } from '../src/index';
+
+/** Shaped like a real v6 feature, trimmed to the fields we read. */
+function feature(overrides: {
+  featureType?: string;
+  id?: string;
+  fullAddress?: string;
+  name?: string;
+  placeFormatted?: string;
+  lat?: number;
+  lng?: number;
+}) {
+  return {
+    properties: {
+      mapbox_id: overrides.id ?? 'dXJuOm1ieGFkcjo=',
+      feature_type: overrides.featureType,
+      full_address: overrides.fullAddress,
+      name: overrides.name,
+      place_formatted: overrides.placeFormatted,
+      coordinates: { longitude: overrides.lng ?? 2.1686, latitude: overrides.lat ?? 41.3874 },
+    },
+  };
+}
+
+describe('precisionOf', () => {
+  it('calls a street address exact', () => {
+    expect(precisionOf('address')).toBe('exact');
+    expect(precisionOf('secondary_address')).toBe('exact');
+  });
+
+  it('calls anything coarser than a building approximate', () => {
+    for (const t of ['street', 'block', 'postcode', 'neighborhood', 'locality']) {
+      expect(precisionOf(t)).toBe('approximate');
+    }
+  });
+
+  it('calls a city-or-wider result what it is', () => {
+    // The failure mode that matters: a bad query returns the city, and if that
+    // ranked as a location every distance in the product would be a lie.
+    expect(precisionOf('place')).toBe('city');
+    expect(precisionOf('region')).toBe('city');
+    expect(precisionOf('country')).toBe('city');
+  });
+
+  it('degrades an unknown feature type rather than trusting it', () => {
+    // Mapbox can add types. A new one must not silently rank as exact.
+    expect(precisionOf('something_new')).toBe('city');
+    expect(precisionOf(undefined)).toBe('city');
+  });
+});
+
+describe('parseResponse', () => {
+  it('maps a full address feature', () => {
+    const [result] = parseResponse({
+      features: [
+        feature({
+          featureType: 'address',
+          id: 'addr-1',
+          fullAddress: 'Carrer de Sants 12, 08014 Barcelona, Spain',
+          lat: 41.3751,
+          lng: 2.1339,
+        }),
+      ],
+    });
+
+    expect(result).toEqual({
+      providerId: 'addr-1',
+      label: 'Carrer de Sants 12, 08014 Barcelona, Spain',
+      coordinates: { lat: 41.3751, lng: 2.1339 },
+      precision: 'exact',
+    });
+  });
+
+  it('builds a label from name and place when there is no full address', () => {
+    const [result] = parseResponse({
+      features: [feature({ featureType: 'street', name: 'Carrer de Sants', placeFormatted: 'Barcelona, Spain' })],
+    });
+    expect(result?.label).toBe('Carrer de Sants, Barcelona, Spain');
+    expect(result?.precision).toBe('approximate');
+  });
+
+  it('drops a feature with nothing to show or nothing to re-resolve by', () => {
+    // A row we cannot label is a row the user cannot choose between; a row with
+    // no id is one we could never re-resolve. Both are dropped rather than
+    // rendered as a blank line.
+    const results = parseResponse({
+      features: [
+        feature({ featureType: 'address', fullAddress: undefined, name: undefined }),
+        { properties: { feature_type: 'address', coordinates: { longitude: 2, latitude: 41 } } },
+      ],
+    });
+    expect(results).toEqual([]);
+  });
+
+  it('returns nothing for an empty result set rather than throwing', () => {
+    expect(parseResponse({ features: [] })).toEqual([]);
+    expect(parseResponse({})).toEqual([]);
+  });
+
+  it('refuses a payload whose coordinates are missing or malformed', () => {
+    // This is the guard that keeps a NaN out of a geography column.
+    expect(() => parseResponse({ features: [{ properties: { feature_type: 'address' } }] })).toThrow(
+      GeocodeError,
+    );
+    expect(() =>
+      parseResponse({
+        features: [{ properties: { coordinates: { longitude: 'two', latitude: 41 } } }],
+      }),
+    ).toThrow(GeocodeError);
+    expect(() => parseResponse('not json at all')).toThrow(GeocodeError);
+  });
+});