@volter/twin-calcom 0.1.0

package/dist/src/calcom-capabilities.js

@@ -0,0 +1,521 @@
+// Cal.com capability manifest — the EXPECTED REAL-PRODUCT SURFACE (the target), authored
+// top-down from what Cal.com v2 actually does — NOT from what this twin has built. This is the
+// honest denominator: most entries start as `todo` and coverage reads LOW until the twin truly
+// reaches 100% of Cal.com. `verify()` (required to count as done) is ground truth; every
+// `expected:'done'` is genuinely claimed, so a broken one shows as a regression. Grow this
+// toward Cal.com's *full* v2 surface every cycle.
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { createElement } from 'react';
+import { renderToStaticMarkup } from 'react-dom/server';
+import { checkCapabilities, uiDataCoupled, verifyBoundary, isInfrastructureError, harnessError } from '@volter/world-tooling';
+import { BookingDetail, BookingsList, EventTypesList } from "../client/calcom-mirror.js";
+import { bookingTone, buildCalcomMirrorClient, createCalcomMirrorServer } from "./calcom-mirror-ui.js";
+import { handleCalcomTwinRequest } from "./calcom-twin.js";
+import { pullCalcomAll } from "./calcom-connector.js";
+import { performPending } from "./calcom-perform-harness.js";
+// ── UI verify: the built mirror bundle backs `calcom.ui.booking_detail`'s bundle+render
+// hybrid below (NOT a marker-grep capability of its own — TWIN-14/B4 killed those). ──
+let bundle = null;
+const mirrorBundle = () => (bundle ??= buildCalcomMirrorClient());
+const AT = '2026-07-01T00:00:00.000Z';
+async function withRoot(steps) {
+    const root = mkdtempSync(join(tmpdir(), 'calcom-cap-'));
+    const h = (s) => handleCalcomTwinRequest({ method: s.m, path: s.p, body: s.b === undefined ? undefined : JSON.stringify(s.b), root, occurredAt: AT });
+    try {
+        return await verifyBoundary('calcom.withRoot', () => steps(h));
+    }
+    finally {
+        rmSync(root, { recursive: true, force: true });
+    }
+}
+const ok = (r) => r.status >= 200 && r.status < 300;
+const env = (r) => r.body.status;
+const data = (r) => r.body.data;
+// ── shorthands ──
+const done = (id, area, title, dimension, tier, verify) => ({ id, area, title, dimension, tier, expected: 'done', verify });
+const todo = (id, area, title, dimension, tier) => ({ id, area, title, dimension, tier, expected: 'todo' });
+// A fake connector executor for the connector verify (offline, no network).
+const fakeExecute = async (method, path) => {
+    if (path === '/bookings')
+        return { status: 'success', data: [{ uid: 'pulled1', id: 1, title: 'Pulled', status: 'accepted', start: AT, end: AT, duration: 30, eventTypeId: 7001, attendees: [], hosts: [] }] };
+    if (path === '/event-types')
+        return { status: 'success', data: [{ id: 9, title: 'Demo', slug: 'demo', lengthInMinutes: 45, ownerId: 5000 }] };
+    return { status: 'success', data: {} };
+};
+export const CALCOM_CAPABILITIES = [
+    // ── Me / profile (core) ──
+    done('calcom.me.get', 'me', 'GET /v2/me — the API-key owner profile', 'api', 'core', () => withRoot(async (h) => { const r = await h({ m: 'GET', p: '/v2/me' }); return ok(r) && env(r) === 'success' && data(r).id === 5000 && data(r).organization.isPlatform === true; })),
+    done('calcom.me.update', 'me', 'PATCH /v2/me — update profile (folds, then GET reflects it)', 'api', 'niche', () => withRoot(async (h) => {
+        const p = await h({ m: 'PATCH', p: '/v2/me', b: { name: 'New Name', timeZone: 'Europe/London' } });
+        if (!ok(p) || data(p).name !== 'New Name' || data(p).timeZone !== 'Europe/London' || data(p).id !== 5000)
+            return false;
+        const g = await h({ m: 'GET', p: '/v2/me' });
+        if (data(g).name !== 'New Name' || data(g).timeZone !== 'Europe/London')
+            return false;
+        const bad = await h({ m: 'PATCH', p: '/v2/me', b: {} });
+        return bad.status === 400 && env(bad) === 'error';
+    })),
+    // ── Slots / availability (core) ──
+    done('calcom.slots.list', 'slots', 'GET /v2/slots — availability keyed by date', 'api', 'core', () => withRoot(async (h) => { const r = await h({ m: 'GET', p: '/v2/slots?eventTypeId=7001&start=2026-07-01' }); const d = data(r); return ok(r) && Array.isArray(d['2026-07-01']) && d['2026-07-01'][0].start.includes('T16:00'); })),
+    done('calcom.slots.reserve', 'slots', 'POST /v2/slots/reservations — reserve a slot', 'api', 'common', () => withRoot(async (h) => { const r = await h({ m: 'POST', p: '/v2/slots/reservations', b: { eventTypeId: 7001, slotStart: '2026-07-01T16:00:00.000Z' } }); return ok(r) && env(r) === 'success' && typeof data(r).reservationUid === 'string'; })),
+    done('calcom.slots.reserve.requires_input', 'slots', 'POST /v2/slots/reservations rejects missing eventTypeId (400)', 'api', 'common', () => withRoot(async (h) => { const r = await h({ m: 'POST', p: '/v2/slots/reservations', b: { slotStart: 'x' } }); return r.status === 400 && env(r) === 'error'; })),
+    done('calcom.slots.reserve.get', 'slots', 'GET /v2/slots/reservations/{uid} — read a reservation', 'api', 'niche', () => withRoot(async (h) => { const c = await h({ m: 'POST', p: '/v2/slots/reservations', b: { eventTypeId: 7001, slotStart: '2026-07-01T16:00:00.000Z' } }); const uid = data(c).reservationUid; const g = await h({ m: 'GET', p: `/v2/slots/reservations/${uid}` }); return ok(g) && data(g).reservationUid === uid; })),
+    done('calcom.slots.reserve.delete', 'slots', 'DELETE /v2/slots/reservations/{uid} — release a reservation (then GET → 404)', 'api', 'niche', () => withRoot(async (h) => {
+        const c = await h({ m: 'POST', p: '/v2/slots/reservations', b: { eventTypeId: 7001, slotStart: '2026-07-01T16:00:00.000Z' } });
+        const uid = data(c).reservationUid;
+        const d = await h({ m: 'DELETE', p: `/v2/slots/reservations/${uid}` });
+        const g = await h({ m: 'GET', p: `/v2/slots/reservations/${uid}` });
+        const miss = await h({ m: 'DELETE', p: '/v2/slots/reservations/slot_zzz' });
+        return ok(d) && g.status === 404 && miss.status === 404;
+    })),
+    // ── Bookings (core) ──
+    done('calcom.bookings.create', 'bookings', 'POST /v2/bookings — create a booking (accepted)', 'api', 'core', () => withRoot(async (h) => { const r = await h({ m: 'POST', p: '/v2/bookings', b: { start: '2026-07-01T16:00:00.000Z', eventTypeId: 7001, attendee: { name: 'Jo', email: 'jo@x.test', timeZone: 'UTC' } } }); const d = data(r); return r.status === 201 && d.status === 'accepted' && d.attendees[0].email === 'jo@x.test' && d.hosts[0].mandatory === true && d.end === '2026-07-01T16:30:00.000Z'; })),
+    done('calcom.bookings.create.requires_start', 'bookings', 'POST /v2/bookings rejects a missing/invalid start (400)', 'api', 'core', () => withRoot(async (h) => { const r = await h({ m: 'POST', p: '/v2/bookings', b: { attendee: { name: 'a', email: 'a@b.test' } } }); return r.status === 400 && env(r) === 'error'; })),
+    done('calcom.bookings.create.requires_attendee', 'bookings', 'POST /v2/bookings rejects a missing attendee (400)', 'api', 'core', () => withRoot(async (h) => { const r = await h({ m: 'POST', p: '/v2/bookings', b: { start: '2026-07-01T16:00:00.000Z' } }); return r.status === 400; })),
+    done('calcom.bookings.get', 'bookings', 'GET /v2/bookings/{uid} — read a created booking', 'api', 'core', () => withRoot(async (h) => { const c = await h({ m: 'POST', p: '/v2/bookings', b: { start: '2026-07-01T16:00:00.000Z', attendee: { name: 'a', email: 'a@b.test' } } }); const uid = data(c).uid; const g = await h({ m: 'GET', p: `/v2/bookings/${uid}` }); return ok(g) && data(g).uid === uid; })),
+    done('calcom.bookings.get.unknown_404', 'bookings', 'GET /v2/bookings/{uid} unknown uid → 404', 'api', 'core', () => withRoot(async (h) => { const r = await h({ m: 'GET', p: '/v2/bookings/booking_nope' }); return r.status === 404 && env(r) === 'error'; })),
+    done('calcom.bookings.list', 'bookings', 'GET /v2/bookings — list bookings', 'api', 'core', () => withRoot(async (h) => { await h({ m: 'POST', p: '/v2/bookings', b: { start: '2026-07-01T16:00:00.000Z', attendee: { name: 'a', email: 'a@b.test' } } }); const r = await h({ m: 'GET', p: '/v2/bookings' }); return ok(r) && Array.isArray(data(r)) && data(r).length === 1; })),
+    done('calcom.bookings.list.filter_status', 'bookings', 'GET /v2/bookings?status= — filter by status', 'api', 'common', () => withRoot(async (h) => { await h({ m: 'POST', p: '/v2/bookings', b: { start: '2026-07-01T16:00:00.000Z', attendee: { name: 'a', email: 'a@b.test' } } }); const acc = await h({ m: 'GET', p: '/v2/bookings?status=accepted' }); const can = await h({ m: 'GET', p: '/v2/bookings?status=cancelled' }); return data(acc).length === 1 && data(can).length === 0; })),
+    done('calcom.bookings.cancel', 'bookings', 'POST /v2/bookings/{uid}/cancel — transitions to cancelled', 'api', 'core', () => withRoot(async (h) => { const c = await h({ m: 'POST', p: '/v2/bookings', b: { start: '2026-07-01T16:00:00.000Z', attendee: { name: 'a', email: 'a@b.test' } } }); const uid = data(c).uid; const x = await h({ m: 'POST', p: `/v2/bookings/${uid}/cancel`, b: {} }); const g = await h({ m: 'GET', p: `/v2/bookings/${uid}` }); return ok(x) && data(x).status === 'cancelled' && data(g).status === 'cancelled'; })),
+    done('calcom.bookings.cancel.double_400', 'bookings', 'POST /v2/bookings/{uid}/cancel twice → 400 (already cancelled)', 'api', 'common', () => withRoot(async (h) => { const c = await h({ m: 'POST', p: '/v2/bookings', b: { start: '2026-07-01T16:00:00.000Z', attendee: { name: 'a', email: 'a@b.test' } } }); const uid = data(c).uid; await h({ m: 'POST', p: `/v2/bookings/${uid}/cancel`, b: {} }); const x2 = await h({ m: 'POST', p: `/v2/bookings/${uid}/cancel`, b: {} }); return x2.status === 400 && env(x2) === 'error'; })),
+    done('calcom.bookings.cancel.unknown_404', 'bookings', 'POST cancel on unknown uid → 404', 'api', 'common', () => withRoot(async (h) => { const r = await h({ m: 'POST', p: '/v2/bookings/booking_nope/cancel', b: {} }); return r.status === 404; })),
+    done('calcom.bookings.reschedule', 'bookings', 'POST /v2/bookings/{uid}/reschedule — new booking, old cancelled', 'api', 'common', () => withRoot(async (h) => { const c = await h({ m: 'POST', p: '/v2/bookings', b: { start: '2026-07-01T16:00:00.000Z', attendee: { name: 'a', email: 'a@b.test' } } }); const uid = data(c).uid; const r = await h({ m: 'POST', p: `/v2/bookings/${uid}/reschedule`, b: { start: '2026-07-02T16:00:00.000Z' } }); const old = await h({ m: 'GET', p: `/v2/bookings/${uid}` }); return r.status === 201 && data(r).start === '2026-07-02T16:00:00.000Z' && data(r).status === 'accepted' && data(old).status === 'cancelled'; })),
+    done('calcom.bookings.confirm', 'bookings', 'POST /v2/bookings/{uid}/confirm — pending → accepted (and 400 on a non-pending)', 'api', 'common', () => withRoot(async (h) => {
+        // a requiresConfirmation event type produces a PENDING booking (the real positive path)
+        const evt = await h({ m: 'POST', p: '/v2/event-types', b: { title: 'Gated', slug: 'gated', lengthInMinutes: 30, requiresConfirmation: true } });
+        const c = await h({ m: 'POST', p: '/v2/bookings', b: { start: '2026-07-01T16:00:00.000Z', eventTypeId: data(evt).id, attendee: { name: 'a', email: 'a@b.test' } } });
+        if (data(c).status !== 'pending')
+            return false;
+        const uid = data(c).uid;
+        const r = await h({ m: 'POST', p: `/v2/bookings/${uid}/confirm`, b: {} });
+        if (!ok(r) || data(r).status !== 'accepted')
+            return false;
+        const g = await h({ m: 'GET', p: `/v2/bookings/${uid}` });
+        if (data(g).status !== 'accepted')
+            return false;
+        // negative: confirming an already-accepted booking → 400
+        const again = await h({ m: 'POST', p: `/v2/bookings/${uid}/confirm`, b: {} });
+        return again.status === 400;
+    })),
+    done('calcom.bookings.decline', 'bookings', 'POST /v2/bookings/{uid}/decline — pending → rejected (and 400 on a non-pending)', 'api', 'common', () => withRoot(async (h) => {
+        const evt = await h({ m: 'POST', p: '/v2/event-types', b: { title: 'Gated', slug: 'gated', lengthInMinutes: 30, requiresConfirmation: true } });
+        const c = await h({ m: 'POST', p: '/v2/bookings', b: { start: '2026-07-01T16:00:00.000Z', eventTypeId: data(evt).id, attendee: { name: 'a', email: 'a@b.test' } } });
+        if (data(c).status !== 'pending')
+            return false;
+        const uid = data(c).uid;
+        const r = await h({ m: 'POST', p: `/v2/bookings/${uid}/decline`, b: {} });
+        if (!ok(r) || data(r).status !== 'rejected')
+            return false;
+        const g = await h({ m: 'GET', p: `/v2/bookings/${uid}` });
+        if (data(g).status !== 'rejected')
+            return false;
+        const again = await h({ m: 'POST', p: `/v2/bookings/${uid}/decline`, b: {} });
+        return again.status === 400;
+    })),
+    done('calcom.bookings.requires_confirmation_pending', 'bookings', 'A booking on a requiresConfirmation event type starts pending', 'api', 'common', () => withRoot(async (h) => { const evt = await h({ m: 'POST', p: '/v2/event-types', b: { title: 'G', slug: 'g', lengthInMinutes: 30, requiresConfirmation: true } }); const c = await h({ m: 'POST', p: '/v2/bookings', b: { start: '2026-07-01T16:00:00.000Z', eventTypeId: data(evt).id, attendee: { name: 'a', email: 'a@b.test' } } }); return c.status === 201 && data(c).status === 'pending'; })),
+    done('calcom.bookings.create.unknown_event_type_404', 'bookings', 'POST /v2/bookings with an unknown eventTypeId → 404', 'api', 'common', () => withRoot(async (h) => { const r = await h({ m: 'POST', p: '/v2/bookings', b: { start: '2026-07-01T16:00:00.000Z', eventTypeId: 424242, attendee: { name: 'a', email: 'a@b.test' } } }); return r.status === 404 && env(r) === 'error'; })),
+    todo('calcom.bookings.create_instant', 'bookings', 'POST /v2/bookings instant team meeting', 'api', 'niche'),
+    todo('calcom.bookings.create_recurring', 'bookings', 'POST /v2/bookings recurring series', 'api', 'niche'),
+    todo('calcom.bookings.seated', 'bookings', 'Seated bookings (seatUid, per-seat attendees)', 'api', 'niche'),
+    done('calcom.bookings.mark_absent', 'bookings', 'POST /v2/bookings/{uid}/mark-absent — flags attendee no-show + noShowHost', 'api', 'niche', () => withRoot(async (h) => {
+        const c = await h({ m: 'POST', p: '/v2/bookings', b: { start: '2026-07-01T16:00:00.000Z', attendee: { name: 'a', email: 'a@b.test' } } });
+        const uid = data(c).uid;
+        const m = await h({ m: 'POST', p: `/v2/bookings/${uid}/mark-absent`, b: { noShowHost: true, attendees: [{ email: 'a@b.test', absent: true }] } });
+        if (!ok(m) || data(m).noShowHost !== true || data(m).attendees[0].absent !== true)
+            return false;
+        const g = await h({ m: 'GET', p: `/v2/bookings/${uid}` });
+        if (data(g).noShowHost !== true || data(g).attendees[0].absent !== true)
+            return false;
+        const miss = await h({ m: 'POST', p: '/v2/bookings/booking_nope/mark-absent', b: {} });
+        return miss.status === 404;
+    })),
+    done('calcom.bookings.recordings', 'bookings', 'GET /v2/bookings/{uid}/recordings — empty array on a fresh local booking; 404 on unknown', 'api', 'niche', () => withRoot(async (h) => {
+        const c = await h({ m: 'POST', p: '/v2/bookings', b: { start: '2026-07-01T16:00:00.000Z', attendee: { name: 'a', email: 'a@b.test' } } });
+        const r = await h({ m: 'GET', p: `/v2/bookings/${data(c).uid}/recordings` });
+        const miss = await h({ m: 'GET', p: '/v2/bookings/booking_nope/recordings' });
+        return ok(r) && env(r) === 'success' && Array.isArray(data(r)) && data(r).length === 0 && miss.status === 404;
+    })),
+    done('calcom.bookings.references', 'bookings', 'GET /v2/bookings/{uid}/references — empty array on a fresh local booking; 404 on unknown', 'api', 'niche', () => withRoot(async (h) => {
+        const c = await h({ m: 'POST', p: '/v2/bookings', b: { start: '2026-07-01T16:00:00.000Z', attendee: { name: 'a', email: 'a@b.test' } } });
+        const r = await h({ m: 'GET', p: `/v2/bookings/${data(c).uid}/references` });
+        const miss = await h({ m: 'GET', p: '/v2/bookings/booking_nope/references' });
+        return ok(r) && env(r) === 'success' && Array.isArray(data(r)) && data(r).length === 0 && miss.status === 404;
+    })),
+    todo('calcom.bookings.reassign', 'bookings', 'POST /v2/bookings/{uid}/reassign (round-robin)', 'api', 'niche'),
+    // ── Event types (core) ──
+    done('calcom.event_types.create', 'event-types', 'POST /v2/event-types — create', 'api', 'core', () => withRoot(async (h) => { const r = await h({ m: 'POST', p: '/v2/event-types', b: { title: 'Intro', slug: 'intro', lengthInMinutes: 15 } }); const d = data(r); return r.status === 201 && d.lengthInMinutes === 15 && d.slug === 'intro' && String(d.bookingUrl).includes('intro'); })),
+    done('calcom.event_types.create.requires_fields', 'event-types', 'POST /v2/event-types rejects missing required fields (400)', 'api', 'core', () => withRoot(async (h) => { const r = await h({ m: 'POST', p: '/v2/event-types', b: { title: 'x' } }); return r.status === 400 && env(r) === 'error'; })),
+    done('calcom.event_types.get', 'event-types', 'GET /v2/event-types/{id} — read', 'api', 'core', () => withRoot(async (h) => { const c = await h({ m: 'POST', p: '/v2/event-types', b: { title: 'Intro', slug: 'intro', lengthInMinutes: 15 } }); const id = data(c).id; const g = await h({ m: 'GET', p: `/v2/event-types/${id}` }); return ok(g) && data(g).id === id; })),
+    done('calcom.event_types.get.unknown_404', 'event-types', 'GET /v2/event-types/{id} unknown → 404', 'api', 'common', () => withRoot(async (h) => { const r = await h({ m: 'GET', p: '/v2/event-types/999999' }); return r.status === 404; })),
+    done('calcom.event_types.list', 'event-types', 'GET /v2/event-types — list', 'api', 'core', () => withRoot(async (h) => { await h({ m: 'POST', p: '/v2/event-types', b: { title: 'a', slug: 'a', lengthInMinutes: 15 } }); const r = await h({ m: 'GET', p: '/v2/event-types' }); return ok(r) && data(r).length === 1; })),
+    done('calcom.event_types.update', 'event-types', 'PATCH /v2/event-types/{id} — update', 'api', 'common', () => withRoot(async (h) => { const c = await h({ m: 'POST', p: '/v2/event-types', b: { title: 'a', slug: 'a', lengthInMinutes: 15 } }); const id = data(c).id; const p = await h({ m: 'PATCH', p: `/v2/event-types/${id}`, b: { title: 'b' } }); return ok(p) && data(p).title === 'b'; })),
+    done('calcom.event_types.delete', 'event-types', 'DELETE /v2/event-types/{id} — delete (then 404)', 'api', 'common', () => withRoot(async (h) => { const c = await h({ m: 'POST', p: '/v2/event-types', b: { title: 'a', slug: 'a', lengthInMinutes: 15 } }); const id = data(c).id; const d = await h({ m: 'DELETE', p: `/v2/event-types/${id}` }); const g = await h({ m: 'GET', p: `/v2/event-types/${id}` }); return ok(d) && g.status === 404; })),
+    done('calcom.event_types.bulk', 'event-types', 'GET /v2/event-types?username=&eventSlug= — public lookup (eventSlug needs username → 400)', 'api', 'common', () => withRoot(async (h) => {
+        await h({ m: 'POST', p: '/v2/event-types', b: { title: 'Intro', slug: 'intro', lengthInMinutes: 15 } });
+        // by username: the seeded admin's event types incl. the implicit default
+        const byUser = await h({ m: 'GET', p: '/v2/event-types?username=twin-calcom-admin' });
+        if (!ok(byUser) || !data(byUser).some((e) => e.slug === 'intro') || !data(byUser).some((e) => e.slug === 'consultation'))
+            return false;
+        // by username + eventSlug: exactly the one
+        const one = await h({ m: 'GET', p: '/v2/event-types?username=twin-calcom-admin&eventSlug=intro' });
+        if (!ok(one) || data(one).length !== 1 || data(one)[0].slug !== 'intro')
+            return false;
+        // unknown username → empty
+        const none = await h({ m: 'GET', p: '/v2/event-types?username=ghost' });
+        if (!ok(none) || data(none).length !== 0)
+            return false;
+        // eventSlug without username → 400
+        const bad = await h({ m: 'GET', p: '/v2/event-types?eventSlug=intro' });
+        return bad.status === 400 && env(bad) === 'error';
+    })),
+    done('calcom.event_types.team', 'event-types', 'POST/GET /v2/teams/{id}/event-types — team event types carry teamId+schedulingType', 'api', 'common', () => withRoot(async (h) => {
+        const t = await h({ m: 'POST', p: '/v2/teams', b: { name: 'Sales' } });
+        const tid = data(t).id;
+        const c = await h({ m: 'POST', p: `/v2/teams/${tid}/event-types`, b: { title: 'Team Demo', slug: 'team-demo', lengthInMinutes: 45, schedulingType: 'roundRobin' } });
+        if (c.status !== 201 || data(c).teamId !== tid || data(c).schedulingType !== 'roundRobin' || data(c).lengthInMinutes !== 45)
+            return false;
+        const lst = await h({ m: 'GET', p: `/v2/teams/${tid}/event-types` });
+        if (!ok(lst) || data(lst).length !== 1 || data(lst)[0].slug !== 'team-demo')
+            return false;
+        // the personal list does NOT include the team event type
+        const personal = await h({ m: 'GET', p: '/v2/event-types' });
+        if (data(personal).length !== 0)
+            return false;
+        const bad = await h({ m: 'POST', p: '/v2/teams/team_999/event-types', b: { title: 'x', slug: 'x', lengthInMinutes: 30 } });
+        return bad.status === 404;
+    })),
+    done('calcom.event_types.locations', 'event-types', 'Event-type locations round-trip (integration/phone/link)', 'api', 'niche', () => withRoot(async (h) => {
+        const locs = [{ type: 'integration', integration: 'cal-video' }, { type: 'phone', phone: '+15551234' }];
+        const c = await h({ m: 'POST', p: '/v2/event-types', b: { title: 'L', slug: 'l', lengthInMinutes: 30, locations: locs } });
+        if (c.status !== 201 || !Array.isArray(data(c).locations) || data(c).locations.length !== 2 || data(c).locations[1].phone !== '+15551234')
+            return false;
+        const g = await h({ m: 'GET', p: `/v2/event-types/${data(c).id}` });
+        return data(g).locations[0].integration === 'cal-video';
+    })),
+    done('calcom.event_types.booking_fields', 'event-types', 'Custom booking fields round-trip on an event type', 'api', 'niche', () => withRoot(async (h) => {
+        const fields = [{ type: 'text', slug: 'company', label: 'Company', required: true }];
+        const c = await h({ m: 'POST', p: '/v2/event-types', b: { title: 'B', slug: 'b', lengthInMinutes: 30, bookingFields: fields } });
+        if (c.status !== 201 || data(c).bookingFields.length !== 1 || data(c).bookingFields[0].slug !== 'company')
+            return false;
+        const g = await h({ m: 'GET', p: `/v2/event-types/${data(c).id}` });
+        return data(g).bookingFields[0].required === true;
+    })),
+    done('calcom.event_types.seats_config', 'event-types', 'Seats config (seatsPerTimeSlot + show flags) round-trips', 'api', 'niche', () => withRoot(async (h) => {
+        const c = await h({ m: 'POST', p: '/v2/event-types', b: { title: 'S', slug: 's', lengthInMinutes: 30, seatsPerTimeSlot: 5, seatsShowAttendees: true } });
+        if (c.status !== 201 || data(c).seatsPerTimeSlot !== 5 || data(c).seatsShowAttendees !== true)
+            return false;
+        // default event types are not seated
+        const d = await h({ m: 'POST', p: '/v2/event-types', b: { title: 'P', slug: 'p', lengthInMinutes: 30 } });
+        return data(d).seatsPerTimeSlot === null;
+    })),
+    done('calcom.event_types.buffers', 'event-types', 'before/after buffers + minimumBookingNotice round-trip', 'api', 'niche', () => withRoot(async (h) => {
+        const c = await h({ m: 'POST', p: '/v2/event-types', b: { title: 'Bf', slug: 'bf', lengthInMinutes: 30, beforeEventBuffer: 10, afterEventBuffer: 15, minimumBookingNotice: 120 } });
+        if (c.status !== 201 || data(c).beforeEventBuffer !== 10 || data(c).afterEventBuffer !== 15 || data(c).minimumBookingNotice !== 120)
+            return false;
+        const d = await h({ m: 'POST', p: '/v2/event-types', b: { title: 'Nd', slug: 'nd', lengthInMinutes: 30 } });
+        return data(d).beforeEventBuffer === 0 && data(d).minimumBookingNotice === 0;
+    })),
+    todo('calcom.event_types.webhooks', 'event-types', 'Per-event-type webhooks', 'api', 'niche'),
+    // ── Schedules / availability (common) ──
+    done('calcom.schedules.create', 'schedules', 'POST /v2/schedules — create a schedule', 'api', 'core', () => withRoot(async (h) => { const r = await h({ m: 'POST', p: '/v2/schedules', b: { name: 'Working', timeZone: 'UTC', isDefault: true } }); const d = data(r); return r.status === 201 && d.timeZone === 'UTC' && Array.isArray(d.availability) && d.isDefault === true; })),
+    done('calcom.schedules.create.requires_fields', 'schedules', 'POST /v2/schedules rejects missing required fields (400)', 'api', 'common', () => withRoot(async (h) => { const r = await h({ m: 'POST', p: '/v2/schedules', b: { name: 'x' } }); return r.status === 400; })),
+    done('calcom.schedules.get', 'schedules', 'GET /v2/schedules/{id} — read', 'api', 'common', () => withRoot(async (h) => { const c = await h({ m: 'POST', p: '/v2/schedules', b: { name: 'W', timeZone: 'UTC', isDefault: true } }); const id = data(c).id; const g = await h({ m: 'GET', p: `/v2/schedules/${id}` }); return ok(g) && data(g).id === id; })),
+    done('calcom.schedules.list', 'schedules', 'GET /v2/schedules — list', 'api', 'common', () => withRoot(async (h) => { await h({ m: 'POST', p: '/v2/schedules', b: { name: 'W', timeZone: 'UTC', isDefault: true } }); const r = await h({ m: 'GET', p: '/v2/schedules' }); return ok(r) && data(r).length === 1; })),
+    done('calcom.schedules.update', 'schedules', 'PATCH /v2/schedules/{id} — update', 'api', 'common', () => withRoot(async (h) => { const c = await h({ m: 'POST', p: '/v2/schedules', b: { name: 'W', timeZone: 'UTC', isDefault: true } }); const id = data(c).id; const p = await h({ m: 'PATCH', p: `/v2/schedules/${id}`, b: { name: 'Renamed' } }); return ok(p) && data(p).name === 'Renamed'; })),
+    done('calcom.schedules.delete', 'schedules', 'DELETE /v2/schedules/{id} — delete (then 404)', 'api', 'niche', () => withRoot(async (h) => { const c = await h({ m: 'POST', p: '/v2/schedules', b: { name: 'W', timeZone: 'UTC', isDefault: true } }); const id = data(c).id; const d = await h({ m: 'DELETE', p: `/v2/schedules/${id}` }); const g = await h({ m: 'GET', p: `/v2/schedules/${id}` }); return ok(d) && g.status === 404; })),
+    done('calcom.schedules.overrides', 'schedules', 'Date-specific availability overrides round-trip (create + PATCH)', 'api', 'niche', () => withRoot(async (h) => {
+        const ov = [{ date: '2026-12-25', startTime: '00:00', endTime: '00:00' }]; // a closed day
+        const c = await h({ m: 'POST', p: '/v2/schedules', b: { name: 'W', timeZone: 'UTC', isDefault: true, overrides: ov } });
+        if (c.status !== 201 || !Array.isArray(data(c).overrides) || data(c).overrides[0].date !== '2026-12-25')
+            return false;
+        const id = data(c).id;
+        const newOv = [{ date: '2027-01-01', startTime: '10:00', endTime: '14:00' }];
+        const p = await h({ m: 'PATCH', p: `/v2/schedules/${id}`, b: { overrides: newOv } });
+        const g = await h({ m: 'GET', p: `/v2/schedules/${id}` });
+        return ok(p) && data(g).overrides.length === 1 && data(g).overrides[0].date === '2027-01-01';
+    })),
+    todo('calcom.availability.default', 'schedules', 'GET default availability for the user', 'api', 'niche'),
+    // ── Teams + memberships (common) ──
+    done('calcom.teams.create', 'teams', 'POST /v2/teams — create a team', 'api', 'common', () => withRoot(async (h) => { const r = await h({ m: 'POST', p: '/v2/teams', b: { name: 'Sales' } }); return r.status === 201 && data(r).name === 'Sales' && typeof data(r).slug === 'string'; })),
+    done('calcom.teams.create.requires_name', 'teams', 'POST /v2/teams rejects a missing name (400)', 'api', 'common', () => withRoot(async (h) => { const r = await h({ m: 'POST', p: '/v2/teams', b: {} }); return r.status === 400; })),
+    done('calcom.teams.get', 'teams', 'GET /v2/teams/{id} — read', 'api', 'common', () => withRoot(async (h) => { const c = await h({ m: 'POST', p: '/v2/teams', b: { name: 'Sales' } }); const id = data(c).id; const g = await h({ m: 'GET', p: `/v2/teams/${id}` }); return ok(g) && data(g).id === id; })),
+    done('calcom.teams.list', 'teams', 'GET /v2/teams — list', 'api', 'common', () => withRoot(async (h) => { await h({ m: 'POST', p: '/v2/teams', b: { name: 'Sales' } }); const r = await h({ m: 'GET', p: '/v2/teams' }); return ok(r) && data(r).length === 1; })),
+    done('calcom.memberships.create', 'teams', 'POST /v2/teams/{id}/memberships — add a member', 'api', 'common', () => withRoot(async (h) => { const t = await h({ m: 'POST', p: '/v2/teams', b: { name: 'Sales' } }); const tid = data(t).id; const m = await h({ m: 'POST', p: `/v2/teams/${tid}/memberships`, b: { userId: 99, role: 'ADMIN' } }); return m.status === 201 && data(m).role === 'ADMIN' && data(m).userId === 99; })),
+    done('calcom.memberships.create.requires_user', 'teams', 'POST membership rejects a missing userId (400)', 'api', 'niche', () => withRoot(async (h) => { const t = await h({ m: 'POST', p: '/v2/teams', b: { name: 'Sales' } }); const tid = data(t).id; const m = await h({ m: 'POST', p: `/v2/teams/${tid}/memberships`, b: {} }); return m.status === 400; })),
+    done('calcom.memberships.list', 'teams', 'GET /v2/teams/{id}/memberships — list members', 'api', 'common', () => withRoot(async (h) => { const t = await h({ m: 'POST', p: '/v2/teams', b: { name: 'Sales' } }); const tid = data(t).id; await h({ m: 'POST', p: `/v2/teams/${tid}/memberships`, b: { userId: 99 } }); const r = await h({ m: 'GET', p: `/v2/teams/${tid}/memberships` }); return ok(r) && data(r).length === 1; })),
+    done('calcom.teams.get.unknown_404', 'teams', 'GET /v2/teams/{id} unknown → 404', 'api', 'niche', () => withRoot(async (h) => { const r = await h({ m: 'GET', p: '/v2/teams/999999' }); return r.status === 404; })),
+    done('calcom.memberships.update', 'teams', 'PATCH a membership role/acceptance — folds, then list reflects it', 'api', 'niche', () => withRoot(async (h) => {
+        const t = await h({ m: 'POST', p: '/v2/teams', b: { name: 'Sales' } });
+        const tid = data(t).id;
+        const m = await h({ m: 'POST', p: `/v2/teams/${tid}/memberships`, b: { userId: 99, role: 'MEMBER' } });
+        const mid = data(m).id;
+        const p = await h({ m: 'PATCH', p: `/v2/teams/${tid}/memberships/${mid}`, b: { role: 'ADMIN', accepted: false } });
+        if (!ok(p) || data(p).role !== 'ADMIN' || data(p).accepted !== false)
+            return false;
+        const g = await h({ m: 'GET', p: `/v2/teams/${tid}/memberships/${mid}` });
+        if (data(g).role !== 'ADMIN')
+            return false;
+        // the list endpoint reflects the patch too (not just the single-GET projection)
+        const lst = await h({ m: 'GET', p: `/v2/teams/${tid}/memberships` });
+        const inList = data(lst).find((m) => m.id === mid);
+        if (!inList || inList.role !== 'ADMIN' || inList.accepted !== false)
+            return false;
+        const miss = await h({ m: 'PATCH', p: `/v2/teams/${tid}/memberships/mem_999`, b: { role: 'ADMIN' } });
+        return miss.status === 404;
+    })),
+    done('calcom.memberships.delete', 'teams', 'DELETE a membership — gone from the list (and 404 on re-fetch)', 'api', 'niche', () => withRoot(async (h) => {
+        const t = await h({ m: 'POST', p: '/v2/teams', b: { name: 'Sales' } });
+        const tid = data(t).id;
+        const m = await h({ m: 'POST', p: `/v2/teams/${tid}/memberships`, b: { userId: 99 } });
+        const mid = data(m).id;
+        const d = await h({ m: 'DELETE', p: `/v2/teams/${tid}/memberships/${mid}` });
+        const lst = await h({ m: 'GET', p: `/v2/teams/${tid}/memberships` });
+        const g = await h({ m: 'GET', p: `/v2/teams/${tid}/memberships/${mid}` });
+        return ok(d) && data(lst).length === 0 && g.status === 404;
+    })),
+    done('calcom.teams.update', 'teams', 'PATCH /v2/teams/{id} — rename folds, then GET reflects it', 'api', 'niche', () => withRoot(async (h) => {
+        const t = await h({ m: 'POST', p: '/v2/teams', b: { name: 'Sales' } });
+        const id = data(t).id;
+        const p = await h({ m: 'PATCH', p: `/v2/teams/${id}`, b: { name: 'Revenue' } });
+        if (!ok(p) || data(p).name !== 'Revenue')
+            return false;
+        const g = await h({ m: 'GET', p: `/v2/teams/${id}` });
+        const bad = await h({ m: 'PATCH', p: `/v2/teams/${id}`, b: {} });
+        return data(g).name === 'Revenue' && bad.status === 400;
+    })),
+    done('calcom.teams.delete', 'teams', 'DELETE /v2/teams/{id} — delete (then GET → 404)', 'api', 'niche', () => withRoot(async (h) => {
+        const t = await h({ m: 'POST', p: '/v2/teams', b: { name: 'Sales' } });
+        const id = data(t).id;
+        const d = await h({ m: 'DELETE', p: `/v2/teams/${id}` });
+        const g = await h({ m: 'GET', p: `/v2/teams/${id}` });
+        const lst = await h({ m: 'GET', p: '/v2/teams' });
+        return ok(d) && g.status === 404 && data(lst).length === 0;
+    })),
+    // ── Webhooks (registration CRUD — NOT signing) (common) ──
+    done('calcom.webhooks.create', 'webhooks', 'POST /v2/webhooks — register a webhook', 'api', 'common', () => withRoot(async (h) => { const r = await h({ m: 'POST', p: '/v2/webhooks', b: { subscriberUrl: 'https://x.test/h', triggers: ['BOOKING_CREATED'] } }); return r.status === 201 && data(r).subscriberUrl === 'https://x.test/h' && data(r).active === true; })),
+    done('calcom.webhooks.create.requires_fields', 'webhooks', 'POST /v2/webhooks rejects missing url/triggers (400)', 'api', 'common', () => withRoot(async (h) => { const r = await h({ m: 'POST', p: '/v2/webhooks', b: { subscriberUrl: 'x' } }); return r.status === 400; })),
+    done('calcom.webhooks.list', 'webhooks', 'GET /v2/webhooks — list registered webhooks', 'api', 'common', () => withRoot(async (h) => { await h({ m: 'POST', p: '/v2/webhooks', b: { subscriberUrl: 'https://x.test/h', triggers: ['BOOKING_CREATED'] } }); const r = await h({ m: 'GET', p: '/v2/webhooks' }); return ok(r) && data(r).length === 1; })),
+    done('calcom.webhooks.update', 'webhooks', 'PATCH /v2/webhooks/{id} — update', 'api', 'niche', () => withRoot(async (h) => { const c = await h({ m: 'POST', p: '/v2/webhooks', b: { subscriberUrl: 'https://x.test/h', triggers: ['BOOKING_CREATED'] } }); const id = data(c).id; const p = await h({ m: 'PATCH', p: `/v2/webhooks/${id}`, b: { active: false } }); return ok(p) && data(p).active === false; })),
+    done('calcom.webhooks.delete', 'webhooks', 'DELETE /v2/webhooks/{id} — delete (then 404)', 'api', 'niche', () => withRoot(async (h) => { const c = await h({ m: 'POST', p: '/v2/webhooks', b: { subscriberUrl: 'https://x.test/h', triggers: ['BOOKING_CREATED'] } }); const id = data(c).id; const d = await h({ m: 'DELETE', p: `/v2/webhooks/${id}` }); const g = await h({ m: 'GET', p: `/v2/webhooks/${id}` }); return ok(d) && g.status === 404; })),
+    done('calcom.webhooks.get', 'webhooks', 'GET /v2/webhooks/{id} — read one (and 404 on unknown)', 'api', 'niche', () => withRoot(async (h) => {
+        const c = await h({ m: 'POST', p: '/v2/webhooks', b: { subscriberUrl: 'https://x.test/h', triggers: ['BOOKING_CREATED'] } });
+        const id = data(c).id;
+        const g = await h({ m: 'GET', p: `/v2/webhooks/${id}` });
+        const miss = await h({ m: 'GET', p: '/v2/webhooks/wh_999' });
+        return ok(g) && data(g).id === id && data(g).subscriberUrl === 'https://x.test/h' && miss.status === 404;
+    })),
+    // ── Envelope / protocol fidelity (core) ──
+    done('calcom.protocol.success_envelope', 'protocol', 'Responses wrap data in { status:"success", data }', 'api', 'core', () => withRoot(async (h) => { const r = await h({ m: 'GET', p: '/v2/me' }); const b = r.body; return b.status === 'success' && b.data !== undefined; })),
+    done('calcom.protocol.error_envelope', 'protocol', 'Errors return { status:"error", error:{ code, message } }', 'api', 'core', () => withRoot(async (h) => { const r = await h({ m: 'GET', p: '/v2/bookings/booking_nope' }); const b = r.body; return r.status === 404 && b.status === 'error' && typeof b.error.code === 'string' && typeof b.error.message === 'string'; })),
+    done('calcom.protocol.unmodeled_404', 'protocol', 'Unmodeled op fails like the vendor (404), never a fake success', 'api', 'core', () => withRoot(async (h) => { const r = await h({ m: 'GET', p: '/v2/nonsense' }); return r.status === 404 && env(r) === 'error'; })),
+    done('calcom.protocol.read_only', 'protocol', 'read-only twin rejects writes (405)', 'api', 'common', () => {
+        const root = mkdtempSync(join(tmpdir(), 'calcom-ro-'));
+        try {
+            return handleCalcomTwinRequest({ method: 'POST', path: '/v2/bookings', body: '{}', root, readOnly: true }).then((r) => r.status === 405);
+        }
+        finally {
+            rmSync(root, { recursive: true, force: true });
+        }
+    }),
+    todo('calcom.protocol.api_version', 'protocol', 'cal-api-version header pins per-endpoint behavior', 'api', 'niche'),
+    done('calcom.protocol.pagination', 'protocol', 'take/skip pagination on list endpoints (+ sibling pagination meta)', 'api', 'common', () => withRoot(async (h) => {
+        for (let i = 0; i < 3; i++)
+            await h({ m: 'POST', p: '/v2/bookings', b: { start: `2026-07-0${i + 1}T16:00:00.000Z`, attendee: { name: `a${i}`, email: `a${i}@b.test` } } });
+        // no take/skip → full array, no pagination meta (back-compat)
+        const all = await h({ m: 'GET', p: '/v2/bookings' });
+        if (data(all).length !== 3 || all.body.pagination !== undefined)
+            return false;
+        // take=2 → first page of 2 + meta
+        const p1 = await h({ m: 'GET', p: '/v2/bookings?take=2' });
+        const meta1 = p1.body.pagination;
+        if (data(p1).length !== 2 || meta1.totalCount !== 3 || meta1.take !== 2 || meta1.skip !== 0 || meta1.hasMore !== true)
+            return false;
+        // take=2&skip=2 → the remaining 1, hasMore=false
+        const p2 = await h({ m: 'GET', p: '/v2/bookings?take=2&skip=2' });
+        const meta2 = p2.body.pagination;
+        return data(p2).length === 1 && meta2.hasMore === false && meta2.skip === 2;
+    })),
+    todo('calcom.protocol.rate_limit', 'protocol', '429 rate-limit responses + headers', 'api', 'niche'),
+    // ── Connector (lifecycle) ──
+    done('calcom.connector.pull', 'connector', 'PULL real bookings + event types into the observed log (idempotent)', 'connector', 'common', async () => {
+        const root = mkdtempSync(join(tmpdir(), 'calcom-cap-conn-'));
+        try {
+            const { twinResources } = await import('@volter/world-core');
+            const r1 = await pullCalcomAll(fakeExecute, root);
+            if (r1.bookings !== 1 || r1.eventTypes !== 1)
+                return false;
+            const before = twinResources('calcom', root).length;
+            await pullCalcomAll(fakeExecute, root);
+            const booking = twinResources('calcom', root).find((x) => x.id === 'pulled1');
+            return !!booking && twinResources('calcom', root).length === before;
+        }
+        catch (err) {
+            if (isInfrastructureError(err))
+                throw harnessError('calcom.connector.pull', err);
+            return false;
+        }
+        finally {
+            rmSync(root, { recursive: true, force: true });
+        }
+    }),
+    done('calcom.connector.push', 'connector', 'PUSH a pending local create on success; an error response does NOT confirm', 'connector', 'common', async () => {
+        const { deployableEntries } = await import('@volter/world-core');
+        // (a) an ERROR response must leave the action pending (no false confirm)
+        const r1 = mkdtempSync(join(tmpdir(), 'calcom-cap-push-err-'));
+        try {
+            await handleCalcomTwinRequest({ method: 'POST', path: '/v2/event-types', body: JSON.stringify({ title: 'L', slug: 'l', lengthInMinutes: 30 }), root: r1, occurredAt: AT });
+            const errExec = async () => ({ status: 'error', error: { code: 'BadRequestException', message: 'nope' } });
+            const pushedErr = await performPending(errExec, { root: r1 });
+            if (pushedErr !== 0)
+                return false; // must NOT confirm on error
+            if (deployableEntries('calcom', r1).length === 0)
+                return false; // still pending
+        }
+        catch (err) {
+            if (isInfrastructureError(err))
+                throw harnessError('calcom.connector.push', err);
+            return false;
+        }
+        finally {
+            rmSync(r1, { recursive: true, force: true });
+        }
+        // (b) a SUCCESS response confirms the action and hits the right endpoint
+        const r2 = mkdtempSync(join(tmpdir(), 'calcom-cap-push-ok-'));
+        try {
+            await handleCalcomTwinRequest({ method: 'POST', path: '/v2/event-types', body: JSON.stringify({ title: 'L', slug: 'l', lengthInMinutes: 30 }), root: r2, occurredAt: AT });
+            const calls = [];
+            const okExec = async (m, p) => { calls.push(`${m} ${p}`); return { status: 'success', data: { id: 1 } }; };
+            const pushed = await performPending(okExec, { root: r2 });
+            return pushed > 0 && calls.includes('POST /event-types') && deployableEntries('calcom', r2).length === 0;
+        }
+        catch (err) {
+            if (isInfrastructureError(err))
+                throw harnessError('calcom.connector.push', err);
+            return false;
+        }
+        finally {
+            rmSync(r2, { recursive: true, force: true });
+        }
+    }),
+    todo('calcom.connector.pull_schedules', 'connector', 'PULL schedules + teams from the real account', 'connector', 'niche'),
+    // ── UI mirror (Cal.com has a real dashboard) ──
+    // TWIN-14 (B4) convergence — was a LOCAL uiDataCoupled(markers, seed, fetchPath, component,
+    // expectRows, idKey) helper (spinning up a real mirror HTTP server); now converged onto the
+    // SHARED @volter/world-tooling factory (seed/fetch/render/assert over the twin handler
+    // directly — the same data-coupling every other pack's migration uses). Semantics kept
+    // verbatim: seed 2 distinct bookings → fetch the SAME /v2/bookings the dashboard reads →
+    // render the dashboard's OWN BookingsList over the fetched rows → assert one `list-row` per
+    // seeded booking carrying its uid. Failable: an unseeded root's list is empty → 0 rows.
+    done('calcom.ui.bookings', 'ui', 'Bookings dashboard renders real twin bookings (data-coupled)', 'ui', 'core', uiDataCoupled({
+        withRoot,
+        seed: async (h) => {
+            await h({ m: 'POST', p: '/v2/bookings', b: { start: '2026-07-01T16:00:00.000Z', attendee: { name: 'A', email: 'a@x.test' } } });
+            await h({ m: 'POST', p: '/v2/bookings', b: { start: '2026-07-02T16:00:00.000Z', attendee: { name: 'B', email: 'b@x.test' } } });
+        },
+        fetch: async (h) => data(await h({ m: 'GET', p: '/v2/bookings' })),
+        render: (rows) => renderToStaticMarkup(createElement(BookingsList, { rows })),
+        assert: (rows, markup) => rows.length === 2 && !!markup && (markup.match(/list-row/g) ?? []).length === 2
+            && rows.every((r) => markup.includes(String(r.uid))),
+    })),
+    // Same convergence for the Event Types screen: seed 1 distinct event type → fetch
+    // /v2/event-types → render the dashboard's OWN EventTypesList → assert its list-row + id.
+    done('calcom.ui.event_types', 'ui', 'Event Types screen renders real twin event types (data-coupled)', 'ui', 'common', uiDataCoupled({
+        withRoot,
+        seed: (h) => h({ m: 'POST', p: '/v2/event-types', b: { title: 'Intro', slug: 'intro', lengthInMinutes: 15 } }),
+        fetch: async (h) => data(await h({ m: 'GET', p: '/v2/event-types' })),
+        render: (rows) => renderToStaticMarkup(createElement(EventTypesList, { rows })),
+        assert: (rows, markup) => rows.length === 1 && !!markup && markup.includes('list-row') && markup.includes(String(rows[0].id)),
+    })),
+    // TWIN-14 (B4) migration — was a marker-grep over 'pill-ok'/'pill-bad'/'pill-warn' (bundle
+    // literals that happen to exist even in a dead twin); now uiDataCoupled: seed a booking in
+    // each of the three distinct statuses the mirror's PILL_CLASS maps (accepted/pending via a
+    // requiresConfirmation event type/cancelled) → fetch /v2/bookings → run each seeded status
+    // through the mirror's OWN `bookingTone` (exactly the function the pill component calls) →
+    // assert accepted→ok, pending→warn, cancelled→bad. Failable: an unseeded root finds no row
+    // for a status ⇒ `bookingTone(undefined)` → '' ⇒ none of the three tones match.
+    done('calcom.ui.status_pill', 'ui', 'Booking status pills map accepted/pending/cancelled to ok/warn/bad tones (data-coupled)', 'ui', 'niche', uiDataCoupled({
+        withRoot,
+        seed: async (h) => {
+            await h({ m: 'POST', p: '/v2/bookings', b: { start: '2026-07-01T16:00:00.000Z', attendee: { name: 'a', email: 'a@x.test' } } });
+            const evt = await h({ m: 'POST', p: '/v2/event-types', b: { title: 'Gated', slug: 'gated', lengthInMinutes: 30, requiresConfirmation: true } });
+            await h({ m: 'POST', p: '/v2/bookings', b: { start: '2026-07-02T16:00:00.000Z', eventTypeId: data(evt).id, attendee: { name: 'b', email: 'b@x.test' } } });
+            const c = await h({ m: 'POST', p: '/v2/bookings', b: { start: '2026-07-03T16:00:00.000Z', attendee: { name: 'c', email: 'c@x.test' } } });
+            await h({ m: 'POST', p: `/v2/bookings/${data(c).uid}/cancel`, b: {} });
+        },
+        fetch: async (h) => {
+            const rows = data(await h({ m: 'GET', p: '/v2/bookings' }));
+            return {
+                accepted: bookingTone(rows.find((r) => r.status === 'accepted')?.status),
+                pending: bookingTone(rows.find((r) => r.status === 'pending')?.status),
+                cancelled: bookingTone(rows.find((r) => r.status === 'cancelled')?.status),
+            };
+        },
+        assert: (tones) => tones.accepted === 'ok' && tones.pending === 'warn' && tones.cancelled === 'bad',
+    })),
+    // TWIN-14 (B4) migration — was a marker-grep over 'nav-item'/'Cal.com twin'; now
+    // uiDataCoupled following the sentry/supabase `ui.nav` reframe: the nav shell itself has no
+    // seedable data, so the honest proof is that BOTH nav-backed screens (Bookings / Event
+    // Types) read live seeded data — seed one distinct booking + one distinct event type →
+    // fetch each nav destination's own API → assert both seeded markers survive. Failable: an
+    // unseeded root has neither.
+    done('calcom.ui.nav', 'ui', 'Dashboard nav (Bookings / Event Types sections) — every nav destination reads live data (data-coupled)', 'ui', 'niche', uiDataCoupled({
+        withRoot,
+        seed: async (h) => {
+            await h({ m: 'POST', p: '/v2/bookings', b: { start: '2026-07-01T16:00:00.000Z', attendee: { name: 'Nav Check', email: 'nav-check@x.test' } } });
+            await h({ m: 'POST', p: '/v2/event-types', b: { title: 'Nav Check Event', slug: 'nav-check', lengthInMinutes: 20 } });
+        },
+        fetch: async (h) => {
+            const bookings = data(await h({ m: 'GET', p: '/v2/bookings' }));
+            const eventTypes = data(await h({ m: 'GET', p: '/v2/event-types' }));
+            return {
+                bookings: bookings.some((b) => (b.attendees?.[0]?.email) === 'nav-check@x.test'),
+                eventTypes: eventTypes.some((e) => e.slug === 'nav-check'),
+            };
+        },
+        assert: (hits) => hits.bookings && hits.eventTypes,
+    })),
+    done('calcom.ui.booking_detail', 'ui', 'Booking detail renders the real booking host+attendees (data-coupled)', 'ui', 'common', async () => {
+        const js = await mirrorBundle();
+        if (!['booking-detail', 'people-table', 'list-row'].every((m) => js.includes(m)))
+            return false;
+        const root = mkdtempSync(join(tmpdir(), 'calcom-uibd-'));
+        const server = await createCalcomMirrorServer({ root, port: 0 });
+        try {
+            const h = (s) => handleCalcomTwinRequest({ method: s.m, path: s.p, body: s.b === undefined ? undefined : JSON.stringify(s.b), root, occurredAt: AT });
+            await h({ m: 'POST', p: '/v2/bookings', b: { start: '2026-07-01T16:00:00.000Z', attendee: { name: 'Jo', email: 'jo@x.test' } } });
+            const res = await fetch(`http://127.0.0.1:${server.port}/v2/bookings`);
+            const body = (await res.json());
+            const rows = Array.isArray(body.data) ? body.data : [];
+            if (rows.length !== 1)
+                return false;
+            const markup = renderToStaticMarkup(createElement(BookingDetail, { rows }));
+            // one list-row per person: 1 host + 1 attendee = 2; both the host's name and the attendee's
+            // email (real seeded data) plus the host/attendee role labels and booking uid must render.
+            const rowCount = (markup.match(/list-row/g) ?? []).length;
+            return rowCount === 2 && markup.includes('jo@x.test') && markup.includes('Cal.com Twin Admin')
+                && markup.includes('host') && markup.includes('attendee') && markup.includes(String(rows[0].uid));
+        }
+        catch (err) {
+            if (isInfrastructureError(err))
+                throw harnessError('calcom.ui.booking_detail', err);
+            return false;
+        }
+        finally {
+            server.stop();
+            rmSync(root, { recursive: true, force: true });
+        }
+    }),
+    todo('calcom.ui.availability_editor', 'ui', 'Availability/schedule editor screen', 'ui', 'niche'),
+    todo('calcom.ui.teams', 'ui', 'Teams + members screen', 'ui', 'niche'),
+    // ── Out of scope (genuinely impossible for a local twin) ──
+    // ── Pull-surface coverage audit gaps (TWIN-46 / G2) — filed as manifest todos, which is
+    // what the demand-ordered build list is drawn from. See pull-audit.json (repo root) for the
+    // per-pack pull-vs-read-surface evidence.
+    todo('calcom.connector.pull_webhooks', 'connector', 'Connector: pull registered webhooks (GET /v2/webhooks) from the real account', 'connector', 'common'),
+    todo('calcom.connector.pull_me', 'connector', 'Connector: pull the API-key-owner profile (GET /v2/me) from the real account', 'connector', 'core'),
+];
+export async function calcomCapabilities() {
+    return checkCapabilities('calcom', CALCOM_CAPABILITIES);
+}

package/dist/src/calcom-conformance.d.ts

@@ -0,0 +1,15 @@
+export type CalcomViolation = {
+    type: string;
+    id: string;
+    field: string;
+    reason: string;
+};
+export type CalcomConformanceReport = {
+    ok: boolean;
+    resourcesChecked: number;
+    fieldsChecked: number;
+    violations: CalcomViolation[];
+};
+export declare function checkCalcomConformance(opts?: {
+    root?: string;
+}): CalcomConformanceReport;