fix(referrals): preserve historical Kilo Pass affiliate sales

Author: jeanduplessis

apps/web/src/lib/impact/kilo-pass-referrals.test.ts

@@ -45,6 +45,7 @@ import {
   impact_referral_rewards,
   kilo_pass_issuances,
   kilo_pass_subscriptions,
+  user_affiliate_attributions,
 } from '@kilocode/db/schema';
 import {
   ImpactAdvocateProgramKey,
@@ -394,7 +395,28 @@ describe('Kilo Pass Impact referral conversions', () => {
     );
   });
 
-  test('missing or expired attribution suppresses affiliate SALE reporting', async () => {
+  test('historical affiliate attribution without product-scoped touch preserves affiliate SALE', async () => {
+    const referee = await insertTestUser({ created_at: '2026-01-02T00:00:00.000Z' });
+    await db.insert(user_affiliate_attributions).values({
+      user_id: referee.id,
+      provider: 'impact',
+      tracking_id: '',
+    });
+    const subscriptionId = await insertKiloPassSubscription({ userId: referee.id });
+
+    const disposition = await processInvoice({ refereeId: referee.id, subscriptionId });
+
+    expect(disposition).toEqual(
+      expect.objectContaining({
+        shouldEnqueueAffiliateSale: true,
+        winningTouchType: ImpactReferralWinningTouchType.Affiliate,
+        disqualificationReason: 'referral_affiliate_won',
+      })
+    );
+    expect(await db.select().from(impact_referral_rewards)).toHaveLength(0);
+  });
+
+  test('missing attribution and expired product-scoped touches suppress affiliate SALE reporting', async () => {
     const noTouchReferee = await insertTestUser({ created_at: '2026-01-02T00:00:00.000Z' });
     const noTouchSubscriptionId = await insertKiloPassSubscription({
       userId: noTouchReferee.id,
@@ -414,22 +436,60 @@ describe('Kilo Pass Impact referral conversions', () => {
     );
 
     await cleanupDbForTest();
-    const expiredTouchReferee = await insertTestUser({ created_at: '2026-01-02T00:00:00.000Z' });
+    const expiredAffiliateReferee = await insertTestUser({
+      created_at: '2026-01-02T00:00:00.000Z',
+    });
+    await db.insert(user_affiliate_attributions).values({
+      user_id: expiredAffiliateReferee.id,
+      provider: 'impact',
+      tracking_id: 'historical-affiliate-click',
+    });
     await insertTouch({
-      userId: expiredTouchReferee.id,
+      userId: expiredAffiliateReferee.id,
       type: 'affiliate',
       touchedAt: '2025-12-01T00:00:00.000Z',
     });
-    const expiredTouchSubscriptionId = await insertKiloPassSubscription({
-      userId: expiredTouchReferee.id,
+    const expiredAffiliateSubscriptionId = await insertKiloPassSubscription({
+      userId: expiredAffiliateReferee.id,
+    });
+
+    const expiredAffiliateDisposition = await processInvoice({
+      refereeId: expiredAffiliateReferee.id,
+      subscriptionId: expiredAffiliateSubscriptionId,
+    });
+
+    expect(expiredAffiliateDisposition).toEqual(
+      expect.objectContaining({
+        shouldEnqueueAffiliateSale: false,
+        winningTouchType: ImpactReferralWinningTouchType.None,
+        disqualificationReason: 'referral_no_valid_attribution',
+      })
+    );
+
+    await cleanupDbForTest();
+    const expiredReferralReferee = await insertTestUser({
+      created_at: '2026-01-02T00:00:00.000Z',
+    });
+    await db.insert(user_affiliate_attributions).values({
+      user_id: expiredReferralReferee.id,
+      provider: 'impact',
+      tracking_id: 'historical-affiliate-click',
+    });
+    await insertTouch({
+      userId: expiredReferralReferee.id,
+      type: 'referral',
+      touchedAt: '2025-12-01T00:00:00.000Z',
+    });
+    const expiredReferralSubscriptionId = await insertKiloPassSubscription({
+      userId: expiredReferralReferee.id,
     });
 
-    const expiredTouchDisposition = await processInvoice({
-      refereeId: expiredTouchReferee.id,
-      subscriptionId: expiredTouchSubscriptionId,
+    const expiredReferralDisposition = await processInvoice({
+      refereeId: expiredReferralReferee.id,
+      subscriptionId: expiredReferralSubscriptionId,
     });
 
-    expect(expiredTouchDisposition).toEqual(
+    expect(expiredReferralDisposition).toEqual(
       expect.objectContaining({
         shouldEnqueueAffiliateSale: false,
         winningTouchType: ImpactReferralWinningTouchType.None,

apps/web/src/lib/impact/kilo-pass-referrals.ts

@@ -31,6 +31,7 @@ import {
   kilo_pass_issuances,
   kilo_pass_subscriptions,
   kilocode_users,
+  user_affiliate_attributions,
   type ImpactAttributionTouch,
 } from '@kilocode/db/schema';
 import {
@@ -130,6 +131,24 @@ async function findAcceptedUserTouches(params: {
     );
 }
 
+async function hasHistoricalImpactAffiliateAttribution(params: {
+  userId: string;
+  database: DatabaseClient;
+}): Promise<boolean> {
+  const [attribution] = await params.database
+    .select({ id: user_affiliate_attributions.id })
+    .from(user_affiliate_attributions)
+    .where(
+      and(
+        eq(user_affiliate_attributions.user_id, params.userId),
+        eq(user_affiliate_attributions.provider, 'impact')
+      )
+    )
+    .limit(1);
+
+  return Boolean(attribution);
+}
+
 async function markAffiliateTouchSaleAttributed(params: {
   database: DatabaseClient;
   affiliateTouchId: string;
@@ -523,6 +542,37 @@ export async function processPersonalKiloPassStripePaidConversion(params: {
       referralTouchId: resolution.referralTouch?.id ?? null,
     });
 
+    // Preserve pre-touch-model affiliate attribution without allowing an expired scoped touch
+    // to bypass the referral attribution window.
+    if (
+      resolution.winner === 'none' &&
+      touches.length === 0 &&
+      (await hasHistoricalImpactAffiliateAttribution({ userId: params.userId, database: tx }))
+    ) {
+      const [conversion] = await tx
+        .insert(impact_referral_conversions)
+        .values({
+          product: ImpactReferralProduct.KiloPass,
+          referee_user_id: params.userId,
+          referrer_user_id: null,
+          source_touch_id: null,
+          winning_touch_type: ImpactReferralWinningTouchType.Affiliate,
+          source_payment_id: params.sourcePaymentId,
+          payment_provider: paymentProvider,
+          qualified: false,
+          disqualification_reason: referralDisqualificationReason('affiliate_won'),
+          converted_at: params.convertedAt.toISOString(),
+        })
+        .returning({ id: impact_referral_conversions.id });
+
+      return {
+        shouldEnqueueAffiliateSale: true,
+        winningTouchType: ImpactReferralWinningTouchType.Affiliate,
+        conversionId: conversion?.id ?? null,
+        disqualificationReason: referralDisqualificationReason('affiliate_won'),
+      } satisfies KiloPassPaidConversionDisposition;
+    }
+
     if (resolution.winner === 'none') {
       const [conversion] = await tx
         .insert(impact_referral_conversions)