@rachelallyson/planning-center-people-ts 2.7.0 → 2.9.0

package/dist/index.js

@@ -41,21 +41,21 @@ Object.defineProperty(exports, "attemptTokenRefresh", { enumerable: true, get: f
 Object.defineProperty(exports, "hasRefreshTokenCapability", { enumerable: true, get: function () { return auth_1.hasRefreshTokenCapability; } });
 Object.defineProperty(exports, "refreshAccessToken", { enumerable: true, get: function () { return auth_1.refreshAccessToken; } });
 Object.defineProperty(exports, "updateClientTokens", { enumerable: true, get: function () { return auth_1.updateClientTokens; } });
-// Export API error
-var api_error_1 = require("./api-error");
-Object.defineProperty(exports, "PcoApiError", { enumerable: true, get: function () { return api_error_1.PcoApiError; } });
-var rate_limiter_1 = require("./rate-limiter");
-Object.defineProperty(exports, "PcoRateLimiter", { enumerable: true, get: function () { return rate_limiter_1.PcoRateLimiter; } });
-var error_handling_1 = require("./error-handling");
-Object.defineProperty(exports, "ErrorCategory", { enumerable: true, get: function () { return error_handling_1.ErrorCategory; } });
-Object.defineProperty(exports, "ErrorSeverity", { enumerable: true, get: function () { return error_handling_1.ErrorSeverity; } });
-Object.defineProperty(exports, "handleNetworkError", { enumerable: true, get: function () { return error_handling_1.handleNetworkError; } });
-Object.defineProperty(exports, "handleTimeoutError", { enumerable: true, get: function () { return error_handling_1.handleTimeoutError; } });
-Object.defineProperty(exports, "handleValidationError", { enumerable: true, get: function () { return error_handling_1.handleValidationError; } });
-Object.defineProperty(exports, "PcoError", { enumerable: true, get: function () { return error_handling_1.PcoError; } });
-Object.defineProperty(exports, "retryWithBackoff", { enumerable: true, get: function () { return error_handling_1.retryWithBackoff; } });
-Object.defineProperty(exports, "shouldNotRetry", { enumerable: true, get: function () { return error_handling_1.shouldNotRetry; } });
-Object.defineProperty(exports, "withErrorBoundary", { enumerable: true, get: function () { return error_handling_1.withErrorBoundary; } });
+// Export API error (re-exported from base)
+var planning_center_base_ts_1 = require("@rachelallyson/planning-center-base-ts");
+Object.defineProperty(exports, "PcoApiError", { enumerable: true, get: function () { return planning_center_base_ts_1.PcoApiError; } });
+var planning_center_base_ts_2 = require("@rachelallyson/planning-center-base-ts");
+Object.defineProperty(exports, "PcoRateLimiter", { enumerable: true, get: function () { return planning_center_base_ts_2.PcoRateLimiter; } });
+var planning_center_base_ts_3 = require("@rachelallyson/planning-center-base-ts");
+Object.defineProperty(exports, "ErrorCategory", { enumerable: true, get: function () { return planning_center_base_ts_3.ErrorCategory; } });
+Object.defineProperty(exports, "ErrorSeverity", { enumerable: true, get: function () { return planning_center_base_ts_3.ErrorSeverity; } });
+Object.defineProperty(exports, "handleNetworkError", { enumerable: true, get: function () { return planning_center_base_ts_3.handleNetworkError; } });
+Object.defineProperty(exports, "handleTimeoutError", { enumerable: true, get: function () { return planning_center_base_ts_3.handleTimeoutError; } });
+Object.defineProperty(exports, "handleValidationError", { enumerable: true, get: function () { return planning_center_base_ts_3.handleValidationError; } });
+Object.defineProperty(exports, "PcoError", { enumerable: true, get: function () { return planning_center_base_ts_3.PcoError; } });
+Object.defineProperty(exports, "retryWithBackoff", { enumerable: true, get: function () { return planning_center_base_ts_3.retryWithBackoff; } });
+Object.defineProperty(exports, "shouldNotRetry", { enumerable: true, get: function () { return planning_center_base_ts_3.shouldNotRetry; } });
+Object.defineProperty(exports, "withErrorBoundary", { enumerable: true, get: function () { return planning_center_base_ts_3.withErrorBoundary; } });
 // Export People-specific functions (deprecated)
 var people_1 = require("./people");
 Object.defineProperty(exports, "createFieldDefinition", { enumerable: true, get: function () { return people_1.createFieldDefinition; } });

package/dist/matching/matcher.d.ts

@@ -8,6 +8,7 @@ export interface MatchResult {
     person: PersonResource;
     score: number;
     reason: string;
+    isVerifiedContactMatch?: boolean;
 }
 export declare class PersonMatcher {
     private peopleModule;
@@ -16,6 +17,14 @@ export declare class PersonMatcher {
     constructor(peopleModule: PeopleModule);
     /**
      * Find or create a person with smart matching
+     *
+     * Uses intelligent matching logic that:
+     * - Verifies email/phone matches by checking actual contact information
+     * - Only uses name matching when appropriate (multiple people share contact info, or no contact info provided)
+     * - Can automatically add missing contact information when a match is found (if addMissingContactInfo is true)
+     *
+     * @param options - Matching options
+     * @param options.addMissingContactInfo - If true, automatically adds missing email/phone to matched person's profile
      */
     findOrCreate(options: PersonMatchOptions): Promise<PersonResource>;
     /**
@@ -24,8 +33,21 @@ export declare class PersonMatcher {
     findMatch(options: PersonMatchOptions): Promise<MatchResult | null>;
     /**
      * Get potential matching candidates
+     * @deprecated Use findMatch which has improved logic for separating verified matches from name-only matches
      */
     private getCandidates;
+    /**
+     * Verify if a person's email actually matches the search email
+     */
+    private verifyEmailMatch;
+    /**
+     * Verify if a person's phone actually matches the search phone
+     */
+    private verifyPhoneMatch;
+    /**
+     * Add missing contact information to a person's profile
+     */
+    private addMissingContactInfo;
     /**
      * Filter candidates by age preferences
      */

package/dist/matching/matcher.js

@@ -11,17 +11,30 @@ class PersonMatcher {
     constructor(peopleModule) {
         this.peopleModule = peopleModule;
         this.strategies = new strategies_1.MatchStrategies();
-        this.scorer = new scoring_1.MatchScorer();
+        this.scorer = new scoring_1.MatchScorer(peopleModule);
     }
     /**
      * Find or create a person with smart matching
+     *
+     * Uses intelligent matching logic that:
+     * - Verifies email/phone matches by checking actual contact information
+     * - Only uses name matching when appropriate (multiple people share contact info, or no contact info provided)
+     * - Can automatically add missing contact information when a match is found (if addMissingContactInfo is true)
+     *
+     * @param options - Matching options
+     * @param options.addMissingContactInfo - If true, automatically adds missing email/phone to matched person's profile
      */
     async findOrCreate(options) {
-        const { createIfNotFound = true, matchStrategy = 'fuzzy', ...searchOptions } = options;
+        const { createIfNotFound = true, matchStrategy = 'fuzzy', addMissingContactInfo = false, ...searchOptions } = options;
         // Try to find existing person
         const match = await this.findMatch({ ...searchOptions, matchStrategy });
         if (match) {
-            return match.person;
+            const person = match.person;
+            // Add missing contact information if requested
+            if (addMissingContactInfo) {
+                await this.addMissingContactInfo(person, options);
+            }
+            return person;
         }
         // Create new person if not found and creation is enabled
         if (createIfNotFound) {
@@ -33,26 +46,103 @@ class PersonMatcher {
      * Find the best match for a person
      */
     async findMatch(options) {
-        const { matchStrategy = 'fuzzy' } = options;
-        // Get all potential matches
-        const candidates = await this.getCandidates(options);
-        if (candidates.length === 0) {
+        const { matchStrategy = 'fuzzy', email, phone, firstName, lastName } = options;
+        // Step 1: Try email/phone search first
+        const emailPhoneMatches = [];
+        const nameOnlyMatches = [];
+        // Search by email
+        if (email) {
+            try {
+                const emailResults = await this.peopleModule.search({ email });
+                emailPhoneMatches.push(...emailResults.data);
+            }
+            catch (error) {
+                console.warn('Email search failed:', error);
+            }
+        }
+        // Search by phone
+        if (phone) {
+            try {
+                const phoneResults = await this.peopleModule.search({ phone });
+                emailPhoneMatches.push(...phoneResults.data);
+            }
+            catch (error) {
+                console.warn('Phone search failed:', error);
+            }
+        }
+        // Remove duplicates
+        const uniqueEmailPhoneMatches = emailPhoneMatches.filter((person, index, self) => index === self.findIndex(p => p.id === person.id));
+        // Step 2: Verify email/phone actually match
+        const verifiedMatches = [];
+        for (const candidate of uniqueEmailPhoneMatches) {
+            let emailMatches = false;
+            let phoneMatches = false;
+            if (email) {
+                emailMatches = await this.verifyEmailMatch(candidate, email);
+            }
+            if (phone) {
+                phoneMatches = await this.verifyPhoneMatch(candidate, phone);
+            }
+            // Only include if email OR phone matches (at least one required)
+            if (emailMatches || phoneMatches) {
+                verifiedMatches.push(candidate);
+            }
+        }
+        // Step 3: Only search by name if:
+        //   - Email/phone search found multiple verified results (need name to distinguish), OR
+        //   - No email/phone was provided (name-only matching is OK)
+        //   NOTE: Do NOT search by name if email/phone were provided but don't match
+        if (verifiedMatches.length > 1 || (!email && !phone)) {
+            if (firstName && lastName) {
+                try {
+                    const nameResults = await this.peopleModule.search({
+                        name: `${firstName} ${lastName}`
+                    });
+                    nameOnlyMatches.push(...nameResults.data);
+                }
+                catch (error) {
+                    console.warn('Name search failed:', error);
+                }
+            }
+        }
+        // Step 4: Combine verified email/phone matches with name matches
+        // Prioritize email/phone matches over name-only matches
+        const allCandidates = [...verifiedMatches, ...nameOnlyMatches];
+        // Remove duplicates
+        const uniqueCandidates = allCandidates.filter((person, index, self) => index === self.findIndex(p => p.id === person.id));
+        // Filter by age preferences
+        const ageFilteredCandidates = this.filterByAgePreferences(uniqueCandidates, options);
+        if (ageFilteredCandidates.length === 0) {
             return null;
         }
         // Score and rank candidates
-        const scoredCandidates = candidates.map(candidate => ({
+        const scoredCandidates = await Promise.all(ageFilteredCandidates.map(async (candidate) => ({
             person: candidate,
-            score: this.scorer.scoreMatch(candidate, options),
-            reason: this.scorer.getMatchReason(candidate, options),
-        }));
-        // Sort by score (highest first)
-        scoredCandidates.sort((a, b) => b.score - a.score);
+            score: await this.scorer.scoreMatch(candidate, options),
+            reason: await this.scorer.getMatchReason(candidate, options),
+            // Mark if this is a verified email/phone match
+            isVerifiedContactMatch: verifiedMatches.some(v => v.id === candidate.id)
+        })));
+        // Sort by verified match first, then by score
+        scoredCandidates.sort((a, b) => {
+            if (a.isVerifiedContactMatch && !b.isVerifiedContactMatch)
+                return -1;
+            if (!a.isVerifiedContactMatch && b.isVerifiedContactMatch)
+                return 1;
+            return b.score - a.score;
+        });
+        // For "exact" strategy, only return verified email/phone matches
+        if (matchStrategy === 'exact') {
+            const exactMatches = scoredCandidates.filter(c => c.isVerifiedContactMatch && c.score >= 0.8);
+            return exactMatches.length > 0 ? exactMatches[0] : null;
+        }
         // Apply strategy-specific filtering
         const bestMatch = this.strategies.selectBestMatch(scoredCandidates, matchStrategy);
         return bestMatch;
     }
     /**
      * Get potential matching candidates
+     * @deprecated Use findMatch which has improved logic for separating verified matches from name-only matches
      */
     async getCandidates(options) {
         const candidates = [];
@@ -64,7 +154,7 @@ class PersonMatcher {
                 candidates.push(...emailMatches.data);
             }
             catch (error) {
-                // Email search failed, continue with other strategies
+                console.warn('Email search failed:', error);
             }
         }
         // Strategy 2: Exact phone match
@@ -74,7 +164,7 @@ class PersonMatcher {
                 candidates.push(...phoneMatches.data);
             }
             catch (error) {
-                // Phone search failed, continue with other strategies
+                console.warn('Phone search failed:', error);
             }
         }
         // Strategy 3: Name-based search
@@ -86,7 +176,7 @@ class PersonMatcher {
                 candidates.push(...nameMatches.data);
             }
             catch (error) {
-                // Name search failed, continue with other strategies
+                console.warn('Name search failed:', error);
             }
         }
         // Strategy 4: Broader search if no exact matches
@@ -98,7 +188,7 @@ class PersonMatcher {
                 candidates.push(...broadMatches.data);
             }
             catch (error) {
-                // Broad search failed
+                console.warn('Broad search failed:', error);
             }
         }
         // Remove duplicates based on person ID
@@ -107,6 +197,78 @@ class PersonMatcher {
         const ageFilteredCandidates = this.filterByAgePreferences(uniqueCandidates, options);
         return ageFilteredCandidates;
     }
+    /**
+     * Verify if a person's email actually matches the search email
+     */
+    async verifyEmailMatch(person, email) {
+        try {
+            const personEmails = await this.peopleModule.getEmails(person.id);
+            const normalizedSearchEmail = email.toLowerCase().trim();
+            const emails = personEmails.data?.map(e => e.attributes?.address?.toLowerCase().trim()).filter(Boolean) || [];
+            return emails.includes(normalizedSearchEmail);
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Verify if a person's phone actually matches the search phone
+     */
+    async verifyPhoneMatch(person, phone) {
+        try {
+            const personPhones = await this.peopleModule.getPhoneNumbers(person.id);
+            const normalizePhone = (num) => {
+                const digits = num.replace(/\D/g, '');
+                return digits.length === 10 ? `+1${digits}` :
+                    digits.length === 11 && digits.startsWith('1') ? `+${digits}` :
+                        `+${digits}`;
+            };
+            const normalizedSearchPhone = normalizePhone(phone);
+            const phones = personPhones.data?.map(p => normalizePhone(p.attributes?.number || '')).filter(Boolean) || [];
+            return phones.includes(normalizedSearchPhone);
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Add missing contact information to a person's profile
+     */
+    async addMissingContactInfo(person, options) {
+        const { email, phone } = options;
+        // Check and add email if provided and missing
+        if (email) {
+            try {
+                const hasEmail = await this.verifyEmailMatch(person, email);
+                if (!hasEmail) {
+                    await this.peopleModule.addEmail(person.id, {
+                        address: email,
+                        location: 'Home',
+                        primary: false // Don't override existing primary email
+                    });
+                }
+            }
+            catch (error) {
+                console.warn(`Failed to add email contact for person ${person.id}:`, error);
+            }
+        }
+        // Check and add phone if provided and missing
+        if (phone) {
+            try {
+                const hasPhone = await this.verifyPhoneMatch(person, phone);
+                if (!hasPhone) {
+                    await this.peopleModule.addPhoneNumber(person.id, {
+                        number: phone,
+                        location: 'Home',
+                        primary: false // Don't override existing primary phone
+                    });
+                }
+            }
+            catch (error) {
+                console.warn(`Failed to add phone contact for person ${person.id}:`, error);
+            }
+        }
+    }
     /**
      * Filter candidates by age preferences
      */
@@ -145,11 +307,12 @@ class PersonMatcher {
             try {
                 await this.peopleModule.addEmail(person.id, {
                     address: options.email,
+                    location: 'Home', // Required field
                     primary: true
                 });
             }
             catch (error) {
-                console.warn('Failed to create email contact:', error);
+                console.warn(`Failed to create email contact for person ${person.id}:`, error);
             }
         }
         // Add phone contact if provided
@@ -157,11 +320,12 @@ class PersonMatcher {
             try {
                 await this.peopleModule.addPhoneNumber(person.id, {
                     number: options.phone,
+                    location: 'Home', // Required field
                     primary: true
                 });
             }
             catch (error) {
-                console.warn('Failed to create phone contact:', error);
+                console.warn(`Failed to create phone contact for person ${person.id}:`, error);
             }
         }
         // Set campus if provided
@@ -170,7 +334,7 @@ class PersonMatcher {
                 await this.peopleModule.setPrimaryCampus(person.id, options.campusId);
             }
             catch (error) {
-                console.warn('Failed to set campus:', error);
+                console.warn(`Failed to set campus for person ${person.id}:`, error);
             }
         }
         return person;
@@ -179,24 +343,93 @@ class PersonMatcher {
      * Get all potential matches with detailed scoring
      */
     async getAllMatches(options) {
-        const candidates = await this.getCandidates(options);
-        return candidates.map(candidate => ({
+        // Use the improved matching logic from findMatch
+        const { matchStrategy = 'fuzzy', email, phone, firstName, lastName } = options;
+        const emailPhoneMatches = [];
+        const nameOnlyMatches = [];
+        if (email) {
+            try {
+                const emailResults = await this.peopleModule.search({ email });
+                emailPhoneMatches.push(...emailResults.data);
+            }
+            catch (error) {
+                console.warn('Email search failed:', error);
+            }
+        }
+        if (phone) {
+            try {
+                const phoneResults = await this.peopleModule.search({ phone });
+                emailPhoneMatches.push(...phoneResults.data);
+            }
+            catch (error) {
+                console.warn('Phone search failed:', error);
+            }
+        }
+        const uniqueEmailPhoneMatches = emailPhoneMatches.filter((person, index, self) => index === self.findIndex(p => p.id === person.id));
+        const verifiedMatches = [];
+        for (const candidate of uniqueEmailPhoneMatches) {
+            let emailMatches = false;
+            let phoneMatches = false;
+            if (email) {
+                emailMatches = await this.verifyEmailMatch(candidate, email);
+            }
+            if (phone) {
+                phoneMatches = await this.verifyPhoneMatch(candidate, phone);
+            }
+            if (emailMatches || phoneMatches) {
+                verifiedMatches.push(candidate);
+            }
+        }
+        if (verifiedMatches.length > 1 || (!email && !phone)) {
+            if (firstName && lastName) {
+                try {
+                    const nameResults = await this.peopleModule.search({
+                        name: `${firstName} ${lastName}`
+                    });
+                    nameOnlyMatches.push(...nameResults.data);
+                }
+                catch (error) {
+                    console.warn('Name search failed:', error);
+                }
+            }
+        }
+        const allCandidates = [...verifiedMatches, ...nameOnlyMatches];
+        const uniqueCandidates = allCandidates.filter((person, index, self) => index === self.findIndex(p => p.id === person.id));
+        const ageFilteredCandidates = this.filterByAgePreferences(uniqueCandidates, options);
+        const scoredCandidates = await Promise.all(ageFilteredCandidates.map(async (candidate) => ({
             person: candidate,
-            score: this.scorer.scoreMatch(candidate, options),
-            reason: this.scorer.getMatchReason(candidate, options),
-        })).sort((a, b) => b.score - a.score);
+            score: await this.scorer.scoreMatch(candidate, options),
+            reason: await this.scorer.getMatchReason(candidate, options),
+            isVerifiedContactMatch: verifiedMatches.some(v => v.id === candidate.id)
+        })));
+        return scoredCandidates.sort((a, b) => {
+            if (a.isVerifiedContactMatch && !b.isVerifiedContactMatch)
+                return -1;
+            if (!a.isVerifiedContactMatch && b.isVerifiedContactMatch)
+                return 1;
+            return b.score - a.score;
+        });
     }
     /**
      * Check if a person matches the given criteria
      */
     async isMatch(personId, options) {
         const person = await this.peopleModule.getById(personId);
-        const score = this.scorer.scoreMatch(person, options);
+        const score = await this.scorer.scoreMatch(person, options);
         if (score > 0.5) { // Threshold for considering it a match
+            // Check if this is a verified contact match
+            let isVerifiedContactMatch = false;
+            if (options.email) {
+                isVerifiedContactMatch = await this.verifyEmailMatch(person, options.email);
+            }
+            if (!isVerifiedContactMatch && options.phone) {
+                isVerifiedContactMatch = await this.verifyPhoneMatch(person, options.phone);
+            }
             return {
                 person,
                 score,
-                reason: this.scorer.getMatchReason(person, options),
+                reason: await this.scorer.getMatchReason(person, options),
+                isVerifiedContactMatch,
             };
         }
         return null;

package/dist/matching/scoring.d.ts

@@ -2,24 +2,26 @@
  * v2.0.0 Person Match Scoring
  */
 import type { PersonResource } from '../types';
-import type { PersonMatchOptions } from '../modules/people';
+import type { PersonMatchOptions, PeopleModule } from '../modules/people';
 export declare class MatchScorer {
+    private peopleModule;
+    constructor(peopleModule: PeopleModule);
     /**
      * Score a person match based on various criteria
      */
-    scoreMatch(person: PersonResource, options: PersonMatchOptions): number;
+    scoreMatch(person: PersonResource, options: PersonMatchOptions): Promise<number>;
     /**
      * Get a human-readable reason for the match
      */
-    getMatchReason(person: PersonResource, options: PersonMatchOptions): string;
+    getMatchReason(person: PersonResource, options: PersonMatchOptions): Promise<string>;
     /**
-     * Score email matching
+     * Score email matching - verifies actual email matches
      */
-    private scoreEmailMatch;
+    scoreEmailMatch(person: PersonResource, email: string): Promise<number>;
     /**
-     * Score phone matching
+     * Score phone matching - verifies actual phone matches
      */
-    private scorePhoneMatch;
+    scorePhoneMatch(person: PersonResource, phone: string): Promise<number>;
     /**
      * Score name matching - only exact matches
      */

package/dist/matching/scoring.js

@@ -6,29 +6,34 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MatchScorer = void 0;
 const helpers_1 = require("../helpers");
 class MatchScorer {
+    constructor(peopleModule) {
+        this.peopleModule = peopleModule;
+    }
     /**
      * Score a person match based on various criteria
      */
-    scoreMatch(person, options) {
+    async scoreMatch(person, options) {
         let totalScore = 0;
         let maxScore = 0;
         // Email matching (highest weight)
         if (options.email) {
-            const emailScore = this.scoreEmailMatch(person, options.email);
+            const emailScore = await this.scoreEmailMatch(person, options.email);
             totalScore += emailScore * 0.35;
             maxScore += 0.35;
         }
         // Phone matching (high weight)
         if (options.phone) {
-            const phoneScore = this.scorePhoneMatch(person, options.phone);
+            const phoneScore = await this.scorePhoneMatch(person, options.phone);
             totalScore += phoneScore * 0.25;
             maxScore += 0.25;
         }
-        // Name matching (medium weight)
+        // Name matching (increased weight for name-only matches)
         if (options.firstName || options.lastName) {
             const nameScore = this.scoreNameMatch(person, options);
-            totalScore += nameScore * 0.2;
-            maxScore += 0.2;
+            // Increase weight to 0.4 for name-only matches, 0.2 when combined with other criteria
+            const nameWeight = (!options.email && !options.phone) ? 0.4 : 0.2;
+            totalScore += nameScore * nameWeight;
+            maxScore += nameWeight;
         }
         // Age matching (medium weight)
         const ageScore = this.scoreAgeMatch(person, options);
@@ -43,13 +48,19 @@ class MatchScorer {
     /**
      * Get a human-readable reason for the match
      */
-    getMatchReason(person, options) {
+    async getMatchReason(person, options) {
         const reasons = [];
-        if (options.email && this.scoreEmailMatch(person, options.email) > 0.8) {
-            reasons.push('exact email match');
+        if (options.email) {
+            const emailScore = await this.scoreEmailMatch(person, options.email);
+            if (emailScore > 0.8) {
+                reasons.push('exact email match');
+            }
         }
-        if (options.phone && this.scorePhoneMatch(person, options.phone) > 0.8) {
-            reasons.push('exact phone match');
+        if (options.phone) {
+            const phoneScore = await this.scorePhoneMatch(person, options.phone);
+            if (phoneScore > 0.8) {
+                reasons.push('exact phone match');
+            }
         }
         if (options.firstName || options.lastName) {
             const nameScore = this.scoreNameMatch(person, options);
@@ -82,22 +93,42 @@ class MatchScorer {
         return reasons.join(', ');
     }
     /**
-     * Score email matching
+     * Score email matching - verifies actual email matches
      */
-    scoreEmailMatch(person, email) {
-        // This would need to check the person's emails
-        // For now, return a placeholder score
-        // In a real implementation, you'd fetch the person's emails and compare
-        return 0;
+    async scoreEmailMatch(person, email) {
+        try {
+            const personEmails = await this.peopleModule.getEmails(person.id);
+            const normalizedSearchEmail = email.toLowerCase().trim();
+            // Check if any of the person's emails match
+            const emails = personEmails.data?.map(e => e.attributes?.address?.toLowerCase().trim()).filter(Boolean) || [];
+            return emails.includes(normalizedSearchEmail) ? 1.0 : 0.0;
+        }
+        catch (error) {
+            console.warn(`Failed to verify email match for person ${person.id}:`, error);
+            return 0.0;
+        }
     }
     /**
-     * Score phone matching
+     * Score phone matching - verifies actual phone matches
      */
-    scorePhoneMatch(person, phone) {
-        // This would need to check the person's phone numbers
-        // For now, return a placeholder score
-        // In a real implementation, you'd fetch the person's phone numbers and compare
-        return 0;
+    async scorePhoneMatch(person, phone) {
+        try {
+            const personPhones = await this.peopleModule.getPhoneNumbers(person.id);
+            // Normalize phone numbers for comparison
+            const normalizePhone = (num) => {
+                const digits = num.replace(/\D/g, '');
+                return digits.length === 10 ? `+1${digits}` :
+                    digits.length === 11 && digits.startsWith('1') ? `+${digits}` :
+                        `+${digits}`;
+            };
+            const normalizedSearchPhone = normalizePhone(phone);
+            const phones = personPhones.data?.map(p => normalizePhone(p.attributes?.number || '')).filter(Boolean) || [];
+            return phones.includes(normalizedSearchPhone) ? 1.0 : 0.0;
+        }
+        catch (error) {
+            console.warn(`Failed to verify phone match for person ${person.id}:`, error);
+            return 0.0;
+        }
     }
     /**
      * Score name matching - only exact matches

package/dist/matching/strategies.d.ts

@@ -10,6 +10,7 @@ export declare class MatchStrategies {
     selectBestMatch(candidates: MatchResult[], strategy: MatchStrategy): MatchResult | null;
     /**
      * Exact matching strategy - only return matches with very high confidence
+     * Requires verified email/phone matches unless multiple people share the same contact info
      */
     private selectExactMatch;
     /**