productfoo 0.0.0-stage → 1.0.1

package/dist-public/src/discoveryProviders.js

@@ -0,0 +1,756 @@
+import { companyFromEmailDomain, contactHintsFromDisplayLabel, dedupeContactHints, isValidLinkedinUrl, sanitizeDiscoveryStableUrl, } from "./discoverySources.js";
+const GRANOLA_MEETING_UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+function granolaStableUrl(raw) {
+    if (raw.url)
+        return sanitizeDiscoveryStableUrl("granola", raw.url);
+    if (!GRANOLA_MEETING_UUID.test(raw.id))
+        return undefined;
+    return sanitizeDiscoveryStableUrl("granola", `https://notes.granola.ai/d/${raw.id}`);
+}
+// Contact capture at ingest (discovery-contact-capture-v0 R-003/R-004): the
+// provider's own attendee metadata seeds contact-card candidates instead of
+// being discarded. Display strings yield name (+company); the email DOMAIN
+// yields the company and the raw address is discarded right here — it never
+// enters the normalized session; title and LinkedIn ride only when the payload
+// actually carries them.
+function granolaContactHints(raw) {
+    const hints = [];
+    for (const attendee of raw.attendees ?? []) {
+        const name = attendee.name?.trim();
+        if (name)
+            hints.push(...contactHintsFromDisplayLabel(name, "granola:attendee"));
+        const email = attendee.email?.trim();
+        if (email) {
+            const company = companyFromEmailDomain(email);
+            if (company)
+                hints.push({ field: "company", value: company, source: "granola:attendee_email_domain" });
+        }
+        const company = attendee.company?.trim();
+        if (company)
+            hints.push({ field: "company", value: company, source: "granola:attendee" });
+        const title = attendee.title?.trim();
+        if (title)
+            hints.push({ field: "title", value: title, source: "granola:attendee" });
+        const linkedin = attendee.linkedin?.trim();
+        if (linkedin && isValidLinkedinUrl(linkedin))
+            hints.push({ field: "linkedin", value: linkedin, source: "granola:attendee" });
+    }
+    const deduped = dedupeContactHints(hints);
+    return deduped.length ? deduped : undefined;
+}
+export const granolaDiscoveryAdapter = {
+    provider: "granola",
+    normalizeSession(raw, connectionAlias) {
+        const contactHints = granolaContactHints(raw);
+        const stableUrl = granolaStableUrl(raw);
+        return {
+            schema_version: "0.1",
+            provider: "granola",
+            connection_alias: connectionAlias,
+            runtime_handle: raw.id,
+            completed_at: new Date(raw.datetime).toISOString(),
+            completion_state: raw.status === "completed" ? "completed" : "in_progress",
+            title: raw.title.trim(),
+            participants: (raw.attendees ?? []).map((attendee) => attendee.name?.trim() ?? "").filter(Boolean),
+            stable_url: stableUrl,
+            // open_transcript is observed, not assumed (R-004): a note without an
+            // observed transcript grant normalizes with open_transcript: false, and
+            // the readiness operation is where the needs_provider_access stop lives.
+            capabilities: { list_sessions: true, open_transcript: raw.transcript_access === "granted", stable_link: Boolean(stableUrl), timestamps: true },
+            access: "unknown",
+            ...(contactHints ? { contact_hints: contactHints } : {}),
+        };
+    },
+};
+const GONG_CALL_ID = /^[A-Za-z0-9_-]{4,64}$/;
+function gongStableUrl(raw) {
+    if (raw.url)
+        return sanitizeDiscoveryStableUrl("gong", raw.url);
+    if (!GONG_CALL_ID.test(raw.id))
+        return undefined;
+    return sanitizeDiscoveryStableUrl("gong", `https://app.gong.io/call?id=${raw.id}`);
+}
+function gongCompletedAt(raw) {
+    if (raw.ended)
+        return new Date(raw.ended).toISOString();
+    const started = new Date(raw.started).getTime();
+    const duration = Number.isFinite(raw.duration_seconds) ? Number(raw.duration_seconds) * 1000 : 0;
+    return new Date(started + duration).toISOString();
+}
+// Contact hints follow the Granola discipline (discovery-contact-capture-v0
+// R-003/R-004) with one Gong-specific rule: a party the provider marks as
+// internal is the company's own rep, not a customer contact candidate, so it
+// contributes no hint. Everyone still appears in `participants` for matching.
+function gongContactHints(raw) {
+    const hints = [];
+    for (const party of raw.parties ?? []) {
+        if (party.affiliation?.trim().toLowerCase() === "internal")
+            continue;
+        const name = party.name?.trim();
+        if (name)
+            hints.push(...contactHintsFromDisplayLabel(name, "gong:party"));
+        const email = party.email?.trim();
+        if (email) {
+            const company = companyFromEmailDomain(email);
+            if (company)
+                hints.push({ field: "company", value: company, source: "gong:party_email_domain" });
+        }
+        const title = party.title?.trim();
+        if (title)
+            hints.push({ field: "title", value: title, source: "gong:party" });
+    }
+    const deduped = dedupeContactHints(hints);
+    return deduped.length ? deduped : undefined;
+}
+// Participant labels are party display names plus, for each external party
+// with an address, a domain-only label ("@exampletonbros.example"). The domain label
+// is what an inbox scope's domain_allowlist selects on; the local part of the
+// address is discarded here and never leaves the adapter (R-004/R-005).
+function gongParticipantLabels(raw) {
+    const labels = [];
+    for (const party of raw.parties ?? []) {
+        const name = party.name?.trim();
+        if (name)
+            labels.push(name);
+        if (party.affiliation?.trim().toLowerCase() === "internal")
+            continue;
+        const email = party.email?.trim().toLowerCase();
+        const at = email ? email.lastIndexOf("@") : -1;
+        if (email && at > 0 && at < email.length - 1)
+            labels.push(`@${email.slice(at + 1)}`);
+    }
+    return [...new Set(labels)];
+}
+export const gongDiscoveryAdapter = {
+    provider: "gong",
+    normalizeSession(raw, connectionAlias) {
+        const contactHints = gongContactHints(raw);
+        const stableUrl = gongStableUrl(raw);
+        return {
+            schema_version: "0.1",
+            provider: "gong",
+            connection_alias: connectionAlias,
+            runtime_handle: raw.id,
+            completed_at: gongCompletedAt(raw),
+            completion_state: raw.state === "completed" ? "completed" : "in_progress",
+            title: raw.title.trim(),
+            participants: gongParticipantLabels(raw),
+            stable_url: stableUrl,
+            // timestamps: Gong transcript sentences carry millisecond offsets, so
+            // envelope locators can cite them. open_transcript is observed, not
+            // assumed (R-005).
+            capabilities: { list_sessions: true, open_transcript: raw.transcript_access === "granted", stable_link: Boolean(stableUrl), timestamps: true },
+            access: "unknown",
+            ...(contactHints ? { contact_hints: contactHints } : {}),
+        };
+    },
+};
+const FIREFLIES_TRANSCRIPT_ID = /^[A-Za-z0-9_-]{8,64}$/;
+function firefliesStableUrl(raw) {
+    if (raw.url)
+        return sanitizeDiscoveryStableUrl("fireflies", raw.url);
+    if (!FIREFLIES_TRANSCRIPT_ID.test(raw.id))
+        return undefined;
+    // Belief, owned by the packet's feasibility task (T-001): Fireflies links a
+    // transcript as a path under app.fireflies.ai.
+    return sanitizeDiscoveryStableUrl("fireflies", `https://app.fireflies.ai/transcript/${raw.id}`);
+}
+// The distinct email domains the transcript's own participant metadata
+// carries. OQ-002: Fireflies' role attribution (internal/external) is
+// unverified, so externality derives from email domains only.
+function firefliesParticipantDomains(raw) {
+    const domains = new Set();
+    for (const participant of raw.participants ?? []) {
+        const email = participant.email?.trim().toLowerCase();
+        const at = email ? email.lastIndexOf("@") : -1;
+        if (email && at > 0 && at < email.length - 1)
+            domains.add(email.slice(at + 1));
+    }
+    return [...domains];
+}
+// A transcript with every identified participant on ONE shared domain shows no
+// external party by domain — the only internal signal the email-domain rule
+// (OQ-002) can support — and is excluded by default. A transcript whose
+// participants carry no emails, or whose emails span domains, is not excluded
+// here; the scope's selectors still have to admit it. Domain-only labels and
+// the internal-only rule are re-derived by the worker from this helper.
+export function firefliesInternalOnly(raw) {
+    const domains = firefliesParticipantDomains(raw);
+    return domains.length === 1;
+}
+// Contact hints follow the Granola discipline (discovery-contact-capture-v0
+// R-003/R-004). Without provider-declared affiliation (OQ-002) a mixed-domain
+// transcript cannot attribute internality per participant, so every emailed
+// participant contributes a DOMAIN-ONLY company hint and every well-formed
+// display name a full_name hint — candidates for a person to confirm, never
+// confirmed identity. An internal-only transcript (everyone on one domain)
+// yields no hints: its only domain is the company's own.
+function firefliesContactHints(raw) {
+    if (firefliesInternalOnly(raw))
+        return undefined;
+    const hints = [];
+    for (const participant of raw.participants ?? []) {
+        const name = participant.display_name?.trim();
+        if (name)
+            hints.push(...contactHintsFromDisplayLabel(name, "fireflies:participant"));
+        const email = participant.email?.trim();
+        if (email) {
+            const company = companyFromEmailDomain(email);
+            if (company)
+                hints.push({ field: "company", value: company, source: "fireflies:participant_email_domain" });
+        }
+    }
+    const deduped = dedupeContactHints(hints);
+    return deduped.length ? deduped : undefined;
+}
+// Participant labels are speaker display names plus, for each participant with
+// an address, a domain-only label ("@exampletonbros.example") — the label an inbox
+// scope's domain_allowlist selects on. OQ-002: with no affiliation field, no
+// label is filtered; the raw email dies here and never leaves the adapter.
+function firefliesParticipantLabels(raw) {
+    const labels = [];
+    for (const participant of raw.participants ?? []) {
+        const name = participant.display_name?.trim();
+        if (name)
+            labels.push(name);
+        const email = participant.email?.trim().toLowerCase();
+        const at = email ? email.lastIndexOf("@") : -1;
+        if (email && at > 0 && at < email.length - 1)
+            labels.push(`@${email.slice(at + 1)}`);
+    }
+    return [...new Set(labels)];
+}
+export const firefliesDiscoveryAdapter = {
+    provider: "fireflies",
+    normalizeSession(raw, connectionAlias) {
+        const contactHints = firefliesContactHints(raw);
+        const stableUrl = firefliesStableUrl(raw);
+        return {
+            schema_version: "0.1",
+            provider: "fireflies",
+            connection_alias: connectionAlias,
+            runtime_handle: raw.id,
+            // The meeting's end time; the start is the honest fallback when the
+            // provider reports no end (R-005).
+            completed_at: new Date(raw.ended ?? raw.started_at).toISOString(),
+            // Belief (T-001): Fireflies marks a finished transcript "processed";
+            // "completed" is accepted as the generic terminal spelling. Anything
+            // else (including "processing") is honestly in_progress.
+            completion_state: (raw.status?.trim().toLowerCase() === "completed" || raw.status?.trim().toLowerCase() === "processed") ? "completed" : "in_progress",
+            title: raw.title.trim(),
+            participants: firefliesParticipantLabels(raw),
+            stable_url: stableUrl,
+            // timestamps: Fireflies transcript sentences carry millisecond offsets
+            // (belief, T-001), so envelope locators can cite them.
+            // open_transcript is observed, not assumed (R-005).
+            capabilities: { list_sessions: true, open_transcript: raw.transcript_access === "granted", stable_link: Boolean(stableUrl), timestamps: true },
+            access: "unknown",
+            ...(contactHints ? { contact_hints: contactHints } : {}),
+        };
+    },
+};
+// Zoom marks exactly one participant as the account's own: the recording host.
+// The host is the company's rep — no domain label, no contact hint — and every
+// other named participant is treated as external (Gong's internal-party
+// discipline with the only internal marker the recording contract provides).
+// A host name matching nobody leaves every participant external: nothing else
+// is assumed, because Zoom participant records carry no affiliation field.
+function zoomIsHost(raw, displayName) {
+    const host = raw.host_display_name?.trim().toLowerCase();
+    return Boolean(host) && displayName?.trim().toLowerCase() === host;
+}
+function zoomContactHints(raw) {
+    const hints = [];
+    for (const participant of raw.participants ?? []) {
+        const name = participant.display_name?.trim();
+        if (!name || zoomIsHost(raw, name))
+            continue;
+        hints.push(...contactHintsFromDisplayLabel(name, "zoom:participant"));
+        const email = participant.email?.trim();
+        if (email) {
+            const company = companyFromEmailDomain(email);
+            if (company)
+                hints.push({ field: "company", value: company, source: "zoom:participant_email_domain" });
+        }
+    }
+    const deduped = dedupeContactHints(hints);
+    return deduped.length ? deduped : undefined;
+}
+// Participant labels are display names plus, for each non-host participant
+// with an address, a domain-only label ("@exampletonbros.example") — what an inbox
+// scope's domain_allowlist selects on. The local part of the address is
+// discarded here and never leaves the adapter (R-004/R-005).
+function zoomParticipantLabels(raw) {
+    const labels = [];
+    for (const participant of raw.participants ?? []) {
+        const name = participant.display_name?.trim();
+        if (name)
+            labels.push(name);
+        const email = participant.email?.trim().toLowerCase();
+        if (email && name && !zoomIsHost(raw, name)) {
+            const at = email.lastIndexOf("@");
+            if (at > 0 && at < email.length - 1)
+                labels.push(`@${email.slice(at + 1)}`);
+        }
+    }
+    return [...new Set(labels)];
+}
+// Honest completion: the recording's end when observed, otherwise the meeting
+// start — never a fabricated end (R-005).
+function zoomCompletedAt(raw) {
+    return new Date(raw.end_time ?? raw.start_time).toISOString();
+}
+export const zoomDiscoveryAdapter = {
+    provider: "zoom",
+    normalizeSession(raw, connectionAlias) {
+        const contactHints = zoomContactHints(raw);
+        // A tokenized or credential-bearing link throws here: refused, never
+        // cleaned (R-006). No canonical URL is built from the bare UUID — the
+        // account subdomain is unknown to the adapter.
+        const stableUrl = raw.url ? sanitizeDiscoveryStableUrl("zoom", raw.url) : undefined;
+        return {
+            schema_version: "0.1",
+            provider: "zoom",
+            connection_alias: connectionAlias,
+            runtime_handle: raw.meeting_uuid,
+            completed_at: zoomCompletedAt(raw),
+            completion_state: raw.state === "completed" ? "completed" : "in_progress",
+            title: raw.topic.trim(),
+            participants: zoomParticipantLabels(raw),
+            stable_url: stableUrl,
+            // timestamps: VTT cue timing is a belief owned by the feasibility task
+            // (T-001); until a real transcript is observed it is not claimed.
+            capabilities: { list_sessions: true, open_transcript: raw.transcript_available === true, stable_link: Boolean(stableUrl), timestamps: false },
+            access: "unknown",
+            ...(contactHints ? { contact_hints: contactHints } : {}),
+        };
+    },
+};
+function teamsCompletedAt(raw) {
+    // Honest completion: an explicit provider end wins; without one the start
+    // stands in and the record is not yet completed (the state check below).
+    const end = raw.end_time?.trim() || raw.start_time;
+    if (!Number.isFinite(Date.parse(end)))
+        throw new Error("a Teams meeting needs a parseable start and end time");
+    return new Date(end).toISOString();
+}
+// Participants are attendee display names only (R-005): no addresses, no AAD
+// ids, no domain labels — the meeting identifier plus these names are all the
+// shared model carries.
+function teamsParticipants(raw) {
+    const names = (raw.attendees ?? []).map((attendee) => attendee.display_name?.trim() ?? "").filter(Boolean);
+    return [...new Set(names)];
+}
+// Contact hints are external-only (R-005): the tenant-owned meeting is
+// organized by the company's own staff, so the attendee whose display name
+// matches the organizer is the company's representative and contributes no
+// hint. Every other attendee yields a name hint plus, when the record carries
+// an address, a DOMAIN-only company hint — the address itself dies here
+// (R-004), and free-mail domains yield nothing.
+function teamsContactHints(raw) {
+    const organizer = raw.organizer_display_name?.trim().toLowerCase();
+    const hints = [];
+    for (const attendee of raw.attendees ?? []) {
+        const name = attendee.display_name?.trim();
+        if (!name)
+            continue;
+        if (organizer && name.toLowerCase() === organizer)
+            continue;
+        hints.push(...contactHintsFromDisplayLabel(name, "microsoft-teams:attendee"));
+        const email = attendee.email?.trim();
+        if (email) {
+            const company = companyFromEmailDomain(email);
+            if (company)
+                hints.push({ field: "company", value: company, source: "microsoft-teams:attendee_email_domain" });
+        }
+    }
+    const deduped = dedupeContactHints(hints);
+    return deduped.length ? deduped : undefined;
+}
+export const teamsDiscoveryAdapter = {
+    provider: "microsoft-teams",
+    normalizeSession(raw, connectionAlias) {
+        const contactHints = teamsContactHints(raw);
+        // A carried URL is sanitized or the record is refused loudly: with no
+        // declared Teams form, any URL (tokenized join links included) throws
+        // here — never partially cleaned (R-006).
+        const stableUrl = raw.url ? sanitizeDiscoveryStableUrl("microsoft-teams", raw.url) : undefined;
+        return {
+            schema_version: "0.1",
+            provider: "microsoft-teams",
+            connection_alias: connectionAlias,
+            runtime_handle: raw.meeting_id,
+            completed_at: teamsCompletedAt(raw),
+            completion_state: raw.state === "completed" ? "completed" : "in_progress",
+            title: raw.subject.trim(),
+            participants: teamsParticipants(raw),
+            stable_url: stableUrl,
+            // timestamps: the Graph transcript's locator capability is unverified
+            // (T-001 owns it), so the capability fails closed until observed.
+            // open_transcript is observed, never assumed (R-005).
+            capabilities: { list_sessions: true, open_transcript: raw.transcript_available === true, stable_link: Boolean(stableUrl), timestamps: false },
+            access: "unknown",
+            ...(contactHints ? { contact_hints: contactHints } : {}),
+        };
+    },
+};
+export const fakeDiscoveryAdapter = {
+    provider: "fakecalls",
+    normalizeSession(raw, connectionAlias) {
+        return {
+            schema_version: "0.1",
+            provider: "fakecalls",
+            connection_alias: connectionAlias,
+            runtime_handle: raw.key,
+            completed_at: new Date(raw.ended).toISOString(),
+            completion_state: raw.done ? "completed" : "in_progress",
+            title: raw.subject.trim(),
+            participants: raw.people.labels.map((label) => label.trim()).filter(Boolean),
+            stable_url: raw.review_link ? sanitizeDiscoveryStableUrl("fakecalls", raw.review_link) : undefined,
+            capabilities: { list_sessions: true, open_transcript: raw.transcript_available === true, stable_link: Boolean(raw.review_link), timestamps: false },
+            access: "unknown",
+        };
+    },
+};
+const ZENDESK_COMPLETED_STATUSES = new Set(["solved", "closed"]);
+// Participant labels are display names plus, for the external requester with
+// an address, a domain-only label ("@exampletonbros.example") — the label an inbox
+// scope's domain_allowlist selects on. The assignee is the company's own
+// agent and contributes no domain label. The local part of the requester
+// address is discarded here and never leaves the adapter (R-004/R-005).
+function zendeskParticipantLabels(raw) {
+    const labels = [];
+    const requesterName = raw.requester?.display_name?.trim();
+    if (requesterName)
+        labels.push(requesterName);
+    const email = raw.requester?.email?.trim().toLowerCase();
+    const at = email ? email.lastIndexOf("@") : -1;
+    if (email && at > 0 && at < email.length - 1)
+        labels.push(`@${email.slice(at + 1)}`);
+    const assigneeName = raw.assignee_display_name?.trim();
+    if (assigneeName)
+        labels.push(assigneeName);
+    return [...new Set(labels)];
+}
+// Contact hints follow the Granola discipline (discovery-contact-capture-v0
+// R-003/R-004) with the support-class rule: only the requester is a customer
+// contact candidate — the assignee is company staff, and the raw address dies
+// here, replaced by its domain.
+function zendeskContactHints(raw) {
+    const hints = [];
+    const name = raw.requester?.display_name?.trim();
+    if (name)
+        hints.push(...contactHintsFromDisplayLabel(name, "zendesk:requester"));
+    const email = raw.requester?.email?.trim();
+    if (email) {
+        const company = companyFromEmailDomain(email);
+        if (company)
+            hints.push({ field: "company", value: company, source: "zendesk:requester_email_domain" });
+    }
+    const deduped = dedupeContactHints(hints);
+    return deduped.length ? deduped : undefined;
+}
+// D-001's explicit done-label override (T-005): a thread carrying any of these
+// labels is completed evidence regardless of recency. Kept beside the email
+// class rather than the transport policy — it is class semantics every Gmail
+// runtime shares, versioned with the class, not a request ceiling.
+export const GMAIL_DONE_LABELS = ["done"];
+// D-001 (gmail-discovery-connector-v0 T-005, pinned per OQ-001's
+// recommendation): a thread is "completed" evidence when its last message
+// predates the approved scope's quiet-period boundary, or when it carries an
+// explicit done label. Without a stamped boundary and without a done label the
+// thread is not settled — in_progress, never guessed.
+export function gmailThreadAdmissibility(raw) {
+    const labels = new Set((raw.labels ?? []).map((label) => label.trim().toLowerCase()).filter(Boolean));
+    if (GMAIL_DONE_LABELS.some((label) => labels.has(label)))
+        return "completed";
+    const boundary = Date.parse(raw.quiet_period_ends_at ?? "");
+    const last = Date.parse(raw.last_message_at);
+    if (Number.isFinite(boundary) && Number.isFinite(last) && last < boundary)
+        return "completed";
+    return "in_progress";
+}
+function gmailDomainLabel(email) {
+    // Domain labels exist so an inbox scope's domain_allowlist can select on
+    // them (the raw address never leaves the adapter, R-005). Free-mail domains
+    // yield no label: "@gmail.com" is noise for a customer selector, and the
+    // shared rule already refuses to derive an employer from them.
+    if (!companyFromEmailDomain(email))
+        return undefined;
+    return `@${email.slice(email.lastIndexOf("@") + 1).trim().toLowerCase()}`;
+}
+function internalDomain(raw) {
+    const owner = raw.mailbox_owner_email?.trim().toLowerCase();
+    const at = owner ? owner.lastIndexOf("@") : -1;
+    return owner && at > 0 && at < owner.length - 1 ? owner.slice(at + 1) : undefined;
+}
+// R-004: a thread with no participant outside the mailbox owner's own domain
+// is the company talking to itself in one person's mailbox and is excluded by
+// default. A thread whose participants carry no addresses stays in — the
+// scope's own selectors still have to admit it.
+export function gmailInternalOnly(raw) {
+    const own = internalDomain(raw);
+    if (!own)
+        return false;
+    const addressed = (raw.participants ?? []).filter((participant) => participant.email?.trim());
+    if (addressed.length === 0)
+        return false;
+    return addressed.every((participant) => participant.email.trim().toLowerCase().endsWith(`@${own}`));
+}
+// Contact hints follow the shared discipline: display names become full_name
+// candidates, a non-free email DOMAIN becomes the company, and the address
+// itself dies here. The mailbox owner is the company's own rep — their
+// identity contributes no hint and no domain label (per-user ownership,
+// D-002).
+function gmailContactHints(raw) {
+    const own = internalDomain(raw);
+    const hints = [];
+    for (const participant of raw.participants ?? []) {
+        const name = participant.display_name?.trim();
+        const email = participant.email?.trim();
+        if (own && email?.toLowerCase().endsWith(`@${own}`))
+            continue;
+        if (name)
+            hints.push(...contactHintsFromDisplayLabel(name, "gmail:participant"));
+        if (email) {
+            const company = companyFromEmailDomain(email);
+            if (company)
+                hints.push({ field: "company", value: company, source: "gmail:participant_email_domain" });
+        }
+    }
+    const deduped = dedupeContactHints(hints);
+    return deduped.length ? deduped : undefined;
+}
+export const zendeskDiscoveryAdapter = {
+    provider: "zendesk",
+    normalizeSession(raw, connectionAlias) {
+        // A solved-class ticket with no observed solved time stays in_progress
+        // rather than inventing a completion instant (D-001).
+        const solvedAt = raw.solved_at?.trim();
+        const stableUrl = raw.url ? sanitizeDiscoveryStableUrl("zendesk", raw.url) : undefined;
+        const contactHints = zendeskContactHints(raw);
+        return {
+            schema_version: "0.1",
+            provider: "zendesk",
+            connection_alias: connectionAlias,
+            runtime_handle: raw.id,
+            completed_at: solvedAt ? new Date(solvedAt).toISOString() : "",
+            completion_state: ZENDESK_COMPLETED_STATUSES.has(raw.status.toLowerCase()) && solvedAt ? "completed" : "in_progress",
+            title: raw.subject.trim(),
+            participants: zendeskParticipantLabels(raw),
+            stable_url: stableUrl,
+            // Comment threads carry a created_at per comment, so the timestamps
+            // capability rides the same observed grant as open_transcript (R-005):
+            // neither is claimed without the connection-level observation.
+            capabilities: { list_sessions: true, open_transcript: raw.comment_access === "granted", stable_link: Boolean(stableUrl), timestamps: raw.comment_access === "granted" },
+            access: "unknown",
+            ...(contactHints ? { contact_hints: contactHints } : {}),
+        };
+    },
+};
+// Participant labels are display names plus, for each non-free-mail address,
+// a domain-only label ("@exampletonbros.example"). The local part of every address
+// is discarded here and never leaves the adapter (R-005).
+function gmailParticipantLabels(raw) {
+    const own = internalDomain(raw);
+    const labels = [];
+    for (const participant of raw.participants ?? []) {
+        const name = participant.display_name?.trim();
+        if (name)
+            labels.push(name);
+        const email = participant.email?.trim().toLowerCase();
+        if (!email || (own && email.endsWith(`@${own}`)))
+            continue;
+        const domain = gmailDomainLabel(email);
+        if (domain)
+            labels.push(domain);
+    }
+    return [...new Set(labels)];
+}
+export const gmailDiscoveryAdapter = {
+    provider: "gmail",
+    normalizeSession(raw, connectionAlias) {
+        const contactHints = gmailContactHints(raw);
+        // R-006: Gmail declares no ProviderLinkForm in V0 — the believed web
+        // thread URL carries the identifier in a fragment (or query) form that the
+        // global stable-link rule refuses, and the feasibility task owns verifying
+        // the real forms. Links stay unset with a coverage caveat; a tokenized or
+        // authenticated URL is never stored. The raw url field dies here.
+        void raw.url;
+        return {
+            schema_version: "0.1",
+            provider: "gmail",
+            connection_alias: connectionAlias,
+            runtime_handle: raw.thread_id,
+            completed_at: new Date(raw.last_message_at).toISOString(),
+            completion_state: gmailThreadAdmissibility(raw),
+            title: raw.snippet_subject.trim() || "(no subject)",
+            participants: gmailParticipantLabels(raw),
+            // No declared link form → no stable link, and sanitizeDiscoveryStableUrl
+            // keeps refusing every Gmail URL shape (query or fragment) unchanged.
+            stable_url: undefined,
+            // timestamps: email messages carry no per-locus timestamps an envelope
+            // locator could cite (the locator format is mm:ss of a recording), so
+            // this stays honestly false. open_transcript (body access) is observed,
+            // not assumed (R-005).
+            capabilities: { list_sessions: true, open_transcript: raw.body_access === "granted", stable_link: false, timestamps: false },
+            access: "unknown",
+            ...(contactHints ? { contact_hints: contactHints } : {}),
+        };
+    },
+};
+export const slackDiscoveryAdapter = {
+    provider: "slack",
+    normalizeSession(raw, connectionAlias) {
+        const stableUrl = raw.permalink ? sanitizeDiscoveryStableUrl("slack", raw.permalink) : undefined;
+        const lastMessageSeconds = raw.last_message_at ? Number(raw.last_message_at.split(".")[0]) : undefined;
+        const fallbackSeconds = Number(raw.thread_ts.split(".")[0]);
+        return {
+            schema_version: "0.1",
+            provider: "slack",
+            connection_alias: connectionAlias,
+            runtime_handle: `${raw.channel_id}:${raw.thread_ts}`,
+            // A thread is complete by selection: processing reads exactly the thread
+            // the scope named. Truncation inside a read is recorded on the envelope
+            // (transcript_complete), not by pretending the conversation is unfinished.
+            completed_at: raw.last_message_at && lastMessageSeconds
+                ? new Date(lastMessageSeconds * 1000).toISOString()
+                : new Date(fallbackSeconds * 1000).toISOString(),
+            completion_state: "completed",
+            // Channel-level label (D-001): the disclosure level for chat evidence is
+            // the channel, never a speaker, so participants stay empty and the title
+            // names the channel or the selector — not people.
+            title: raw.channel_name?.trim() ? `Slack thread in #${raw.channel_name.trim()}` : `Slack thread ${raw.channel_id} ${raw.thread_ts}`,
+            participants: [],
+            stable_url: stableUrl,
+            capabilities: { list_sessions: true, open_transcript: true, stable_link: Boolean(stableUrl), timestamps: true },
+            access: "unknown",
+        };
+    },
+};
+// The email class's explicit done override (T-005), adapted to conversation
+// groups: Outlook has no label store, so the override maps Gmail's done label
+// onto Graph message categories — the closest per-message marker a mailbox
+// owner sets by hand. Same value list as GMAIL_DONE_LABELS; same class
+// semantics (a category marker is intent, not transport policy).
+export const OUTLOOK_DONE_CATEGORIES = ["done"];
+// The email class's admissibility rule (outlook-discovery-connector-v0 T-005,
+// pinned as the Gmail packet's D-001 rule applied to conversation groups): a
+// conversation is "completed" evidence when its last message predates the
+// approved scope's quiet-period boundary, or when a message in the group
+// carries an explicit done category. Without a stamped boundary and without a
+// done category the conversation is not settled — in_progress, never guessed.
+export function outlookConversationAdmissibility(raw) {
+    const categories = new Set((raw.categories ?? []).map((category) => category.trim().toLowerCase()).filter(Boolean));
+    if (OUTLOOK_DONE_CATEGORIES.some((category) => categories.has(category)))
+        return "completed";
+    const boundary = Date.parse(raw.quiet_period_ends_at ?? "");
+    const last = Date.parse(raw.last_message_at);
+    if (Number.isFinite(boundary) && Number.isFinite(last) && last < boundary)
+        return "completed";
+    return "in_progress";
+}
+function outlookDomainLabel(smtp) {
+    // Same discipline as Gmail's: domain labels exist so an inbox scope's
+    // domain_allowlist can select on them (the raw address never leaves the
+    // adapter, R-005), and free-mail domains yield no label — "@outlook.com" is
+    // noise for a customer selector, and the shared rule already refuses to
+    // derive an employer from free-mail domains.
+    if (!companyFromEmailDomain(smtp))
+        return undefined;
+    return `@${smtp.slice(smtp.lastIndexOf("@") + 1).trim().toLowerCase()}`;
+}
+function outlookInternalDomain(raw) {
+    const owner = raw.mailbox_owner_email?.trim().toLowerCase();
+    const at = owner ? owner.lastIndexOf("@") : -1;
+    return owner && at > 0 && at < owner.length - 1 ? owner.slice(at + 1) : undefined;
+}
+// R-004: a conversation with no participant outside the mailbox owner's own
+// domain is the company talking to itself in one person's mailbox and is
+// excluded by default. A conversation whose participants carry no smtp
+// addresses stays in — the scope's own selectors still have to admit it.
+export function outlookInternalOnly(raw) {
+    const own = outlookInternalDomain(raw);
+    if (!own)
+        return false;
+    const addressed = (raw.participants ?? []).filter((participant) => participant.smtp?.trim());
+    if (addressed.length === 0)
+        return false;
+    return addressed.every((participant) => participant.smtp.trim().toLowerCase().endsWith(`@${own}`));
+}
+// Contact hints follow the shared discipline: display names become full_name
+// candidates, a non-free smtp DOMAIN becomes the company, and the address
+// itself dies here. The mailbox owner is the company's own rep — their
+// identity contributes no hint and no domain label (per-user ownership,
+// D-002).
+function outlookContactHints(raw) {
+    const own = outlookInternalDomain(raw);
+    const hints = [];
+    for (const participant of raw.participants ?? []) {
+        const name = participant.display_name?.trim();
+        const smtp = participant.smtp?.trim();
+        if (own && smtp?.toLowerCase().endsWith(`@${own}`))
+            continue;
+        if (name)
+            hints.push(...contactHintsFromDisplayLabel(name, "outlook:participant"));
+        if (smtp) {
+            const company = companyFromEmailDomain(smtp);
+            if (company)
+                hints.push({ field: "company", value: company, source: "outlook:participant_smtp_domain" });
+        }
+    }
+    const deduped = dedupeContactHints(hints);
+    return deduped.length ? deduped : undefined;
+}
+// Participant labels are display names plus, for each non-free-mail address,
+// a domain-only label ("@exampletonbros.example"). The local part of every address
+// is discarded here and never leaves the adapter (R-005).
+function outlookParticipantLabels(raw) {
+    const own = outlookInternalDomain(raw);
+    const labels = [];
+    for (const participant of raw.participants ?? []) {
+        const name = participant.display_name?.trim();
+        if (name)
+            labels.push(name);
+        const smtp = participant.smtp?.trim().toLowerCase();
+        if (!smtp || (own && smtp.endsWith(`@${own}`)))
+            continue;
+        const domain = outlookDomainLabel(smtp);
+        if (domain)
+            labels.push(domain);
+    }
+    return [...new Set(labels)];
+}
+export const outlookDiscoveryAdapter = {
+    provider: "outlook",
+    normalizeSession(raw, connectionAlias) {
+        const contactHints = outlookContactHints(raw);
+        // R-006: Outlook declares no ProviderLinkForm in V0 — Graph web links
+        // embed the item id as an opaque token in the path (or carry it in a
+        // query), a form the global stable-link rule refuses, and the feasibility
+        // task owns verifying the real forms. Links stay unset; a tokenized or
+        // authenticated URL is never stored. The raw url field dies here.
+        void raw.url;
+        return {
+            schema_version: "0.1",
+            provider: "outlook",
+            connection_alias: connectionAlias,
+            runtime_handle: raw.conversation_id,
+            completed_at: new Date(raw.last_message_at).toISOString(),
+            completion_state: outlookConversationAdmissibility(raw),
+            title: raw.subject.trim() || "(no subject)",
+            participants: outlookParticipantLabels(raw),
+            // No declared link form → no stable link, and
+            // sanitizeDiscoveryStableUrl keeps refusing every Outlook web-link
+            // shape (tokenized path or query) unchanged.
+            stable_url: undefined,
+            // timestamps: email messages carry no per-locus timestamps an envelope
+            // locator could cite (the locator format is mm:ss of a recording), so
+            // this stays honestly false. open_transcript (body access) is observed,
+            // not assumed (R-005).
+            capabilities: { list_sessions: true, open_transcript: raw.body_access === "granted", stable_link: false, timestamps: false },
+            access: "unknown",
+            ...(contactHints ? { contact_hints: contactHints } : {}),
+        };
+    },
+};