feat(engagement): localize limits and streaks

Use reported user timezones for daily response limits, expose couple streak state and reminders, and improve swipe and live-drawing synchronization with focused tests and documentation.

apps/api/drizzle/0013_daily_limit_local_reset.sql

@@ -0,0 +1,2 @@
+ALTER TABLE "profiles" ADD COLUMN IF NOT EXISTS "timezone" text;--> statement-breakpoint
+COMMENT ON COLUMN "profiles"."timezone" IS 'IANA zone reported by the client. NULL falls back to UTC when bucketing the daily response limit.';

apps/api/drizzle/0014_daily_limit_response_index.sql

@@ -0,0 +1,2 @@
+-- The daily response limit counts a user's responses within their current local day.
+CREATE INDEX IF NOT EXISTS "responses_user_created_idx" ON "responses" ("user_id", "created_at" DESC);

apps/api/drizzle/0015_couple_streak_locality.sql

@@ -0,0 +1,15 @@
+-- Streaks are counted in the couple's shared local day, not the server's calendar day.
+-- The zone is the first reported timezone in member id order (the same ordering that
+-- decides user1/user2), falling back to UTC when neither partner has reported one.
+COMMENT ON COLUMN "couple_streaks"."last_active_date" IS 'Couple-local date on which either partner last answered. The answered-today flags are read as false once this is not the couple-local today.';--> statement-breakpoint
+COMMENT ON COLUMN "couple_streaks"."last_completed_date" IS 'Couple-local date on which both partners last answered. The streak is alive while this is the couple-local today or yesterday.';--> statement-breakpoint
+
+-- Prunes the evening at-risk scan to couples that actually have a streak to lose.
+CREATE INDEX IF NOT EXISTS "couple_streaks_live_idx" ON "couple_streaks" ("last_completed_date") WHERE "current_streak" > 0;--> statement-breakpoint
+
+-- The legacy data plane maintained streaks from a trigger that read auth.uid(). The API
+-- owns that write now and runs it in the same transaction as the response, so drop the
+-- trigger defensively in case a cutover ever carries these objects across.
+DROP TRIGGER IF EXISTS "on_response_update_streak" ON "responses";--> statement-breakpoint
+DROP FUNCTION IF EXISTS "update_couple_streak"();--> statement-breakpoint
+DROP FUNCTION IF EXISTS "reset_daily_streak_flags"();

apps/api/drizzle/0016_streak_reminder_preference.sql

@@ -0,0 +1,3 @@
+-- A shared streak only changes behaviour if somebody is told it is still open, so the
+-- evening at-risk nudge gets its own opt-out rather than riding on milestone celebrations.
+ALTER TABLE "notification_preferences" ADD COLUMN IF NOT EXISTS "streak_reminders_enabled" boolean NOT NULL DEFAULT true;

apps/api/drizzle/meta/_journal.json

@@ -92,6 +92,34 @@
       "when": 1787908500000,
       "tag": "0012_catalogue_field_parity",
       "breakpoints": true
+    },
+    {
+      "idx": 13,
+      "version": "7",
+      "when": 1787994900000,
+      "tag": "0013_daily_limit_local_reset",
+      "breakpoints": true
+    },
+    {
+      "idx": 14,
+      "version": "7",
+      "when": 1787994960000,
+      "tag": "0014_daily_limit_response_index",
+      "breakpoints": true
+    },
+    {
+      "idx": 15,
+      "version": "7",
+      "when": 1788081360000,
+      "tag": "0015_couple_streak_locality",
+      "breakpoints": true
+    },
+    {
+      "idx": 16,
+      "version": "7",
+      "when": 1788081420000,
+      "tag": "0016_streak_reminder_preference",
+      "breakpoints": true
     }
   ]
 }

apps/api/src/db/schema.ts

@@ -6,6 +6,7 @@ export const profiles = pgTable('profiles', {
   email: text('email'),
   avatarUrl: text('avatar_url'),
   pushToken: text('push_token'),
+  timezone: text('timezone'),
   isPremium: boolean('is_premium').notNull().default(false),
   coupleId: uuid('couple_id'),
   gender: text('gender').$type<'male' | 'female' | 'non-binary' | 'prefer-not-to-say' | null>(),

apps/api/src/domains/answers/repository.ts

@@ -5,6 +5,33 @@ interface ContextRow { couple_id: string | null; gender: string | null; max_inte
 interface QuestionRow { id: string; pack_id: string; text: string; partner_text: string | null; intensity: number; allowed_couple_genders: string[] | null; target_user_genders: string[] | null; question_type: QuestionType; config: Record<string, unknown>; created_at: string }
 interface ResponseRow { id: string; user_id: string; question_id: string; couple_id: string; answer: Answer; response_data: ResponseData; created_at: string }
 interface MatchRow { id: string; couple_id: string; question_id: string; match_type: MatchType; is_new: boolean; response_summary: Record<string, unknown> | null; created_at: string }
+interface StreakRow { couple_id: string; current_streak: number; longest_streak: number; last_active_date: string | null; last_completed_date: string | null; user1_answered_today: boolean; user2_answered_today: boolean; streak_celebrated_at: number; created_at: Date; updated_at: Date }
+
+/**
+ * A streak resolved from one partner's point of view. The stored row is positional
+ * (user1/user2 by member id order) because the writer has to be deterministic, but a
+ * client cannot act on "user2 has not answered" without re-deriving that ordering, so
+ * the API answers in terms of you and your partner instead.
+ */
+export interface CoupleStreakView {
+  couple_id: string;
+  current_streak: number;
+  longest_streak: number;
+  last_active_date: string | null;
+  last_completed_date: string | null;
+  you_answered_today: boolean;
+  partner_answered_today: boolean;
+  partner_name: string | null;
+  timezone: string;
+  streak_celebrated_at: number;
+  created_at: string;
+  updated_at: string;
+}
+
+// A response to a question the partner answered first is catching up, not new exploration.
+// Those neither consume nor are blocked by the daily limit, so the reciprocity loop the
+// answer-gap mechanic pushes can never be refused by the meter.
+const catchUpExemption = "select 1 from responses pr where pr.question_id=r.question_id and pr.couple_id=r.couple_id and pr.user_id<>r.user_id and pr.created_at<r.created_at";
 
 export interface SubmitInput { questionId: string; answer: Answer; responseData?: ResponseData }
 export interface UpdateInput extends SubmitInput { confirmDeleteMatch: boolean }
@@ -20,12 +47,13 @@ export interface AnswersRepository {
   matches(userId: string, page: number, limit: number, archived: boolean): Promise<{ matches: unknown[]; totalCount: number }>;
   markSeen(userId: string, ids: string[]): Promise<void>;
   archive(userId: string, matchId: string, archived: boolean): Promise<void>;
-  streak(userId: string): Promise<Record<string, unknown> | null>;
+  streak(userId: string): Promise<CoupleStreakView | null>;
   close(): Promise<void>;
 }
 
 export class PostgresAnswersRepository implements AnswersRepository {
   private readonly pool: Pool;
+  private zones: Promise<Set<string>> | null = null;
   constructor(databaseUrl: string) { this.pool = new Pool({ connectionString: databaseUrl }); }
 
   private async context(client: Pool | PoolClient, userId: string): Promise<ContextRow> {
@@ -41,7 +69,7 @@ export class PostgresAnswersRepository implements AnswersRepository {
     const p = partner.rows[0];
     const config = await this.config();
     if (!packId && p && (await this.answerGap(userId)).is_blocked) return [];
-    if (!packId && !ctx.is_premium && !p?.is_premium && (await this.dailyLimit(userId)).is_blocked) return [];
+    if (!ctx.is_premium && !p?.is_premium && (await this.dailyLimit(userId)).is_blocked) return [];
     const genders = ctx.gender && p?.gender ? [ctx.gender, p.gender].sort().join('+') : null;
     const maxIntensity = config.couple_intensity_gate_enabled && p ? Math.min(ctx.max_intensity, p.max_intensity) : ctx.max_intensity;
     const result = await this.pool.query<QuestionRow>(`
@@ -117,7 +145,10 @@ export class PostgresAnswersRepository implements AnswersRepository {
       await this.assertEligible(client,userId,ctx,q);
       const existing = await client.query('select id from responses where user_id=$1 and question_id=$2 for update', [userId,input.questionId]);
       if (!existing.rowCount) {
-        const limit = await this.dailyLimitWith(client,userId); if (limit.is_blocked) throw new AnswersError('daily_limit',429,'Daily response limit reached',{ daily_limit: limit.limit_value, reset_at: limit.reset_at });
+        const catchingUp = await client.query('select 1 from responses where couple_id=$1 and question_id=$2 and user_id<>$3 limit 1',[ctx.couple_id,input.questionId,userId]);
+        if (!catchingUp.rowCount) {
+          const limit = await this.dailyLimitWith(client,userId); if (limit.is_blocked) throw new AnswersError('daily_limit',429,'Daily response limit reached',{ daily_limit: limit.limit_value, responses_today: limit.responses_today, remaining: 0, reset_at: limit.reset_at });
+        }
       }
       const response = await client.query<ResponseRow>(`insert into responses(id,user_id,question_id,couple_id,answer,response_data) values(gen_random_uuid(),$1,$2,$3,$4,$5)
         on conflict(user_id,question_id) do update set answer=excluded.answer,response_data=excluded.response_data returning *`,[userId,input.questionId,ctx.couple_id,input.answer,input.responseData ?? null]);
@@ -157,12 +188,30 @@ export class PostgresAnswersRepository implements AnswersRepository {
     return result.rows[0];
   }
 
+  /**
+   * The streak day is the couple's shared local day, not the server's. Both partners have
+   * to land inside the same calendar date for the day to count, so the zone belongs to the
+   * couple rather than to whoever happens to be answering: the first reported zone in member
+   * id order, which is the same ordering that decides user1/user2, falling back to UTC when
+   * neither partner has reported one. Without this a couple in a western zone loses the
+   * streak at UTC midnight while it is still the same evening for them.
+   */
+  private async coupleZone(client:Pool|PoolClient,reported:(string|null)[]):Promise<string>{
+    const zone=reported.find(value=>value);
+    return zone&&(await this.timezoneNames(client)).has(zone)?zone:'UTC';
+  }
+
+  private async streakDay(client:Pool|PoolClient,zone:string){
+    const r=await client.query<{today:string;yesterday:string}>("select (now() at time zone $1::text)::date::text today,((now() at time zone $1::text)::date-1)::text yesterday",[zone]);
+    return r.rows[0];
+  }
+
   private async touchStreak(client:PoolClient,userId:string,coupleId:string){
-    const users=await client.query<{id:string}>('select id from profiles where couple_id=$1 order by id',[coupleId]); if(users.rows.length<2)return;
+    const users=await client.query<{id:string;timezone:string|null}>('select id,timezone from profiles where couple_id=$1 order by id',[coupleId]); if(users.rows.length<2)return;
     const user1=users.rows[0].id===userId;
     await client.query('insert into couple_streaks(couple_id) values($1) on conflict do nothing',[coupleId]);
     const locked=await client.query<{current_streak:number;longest_streak:number;last_active_date:string|null;last_completed_date:string|null;user1_answered_today:boolean;user2_answered_today:boolean}>(`select current_streak,longest_streak,last_active_date::text,last_completed_date::text,user1_answered_today,user2_answered_today from couple_streaks where couple_id=$1 for update`,[coupleId]);
-    const row=locked.rows[0]; const todayResult=await client.query<{today:string;yesterday:string}>('select current_date::text today,(current_date-1)::text yesterday'); const {today,yesterday}=todayResult.rows[0];
+    const row=locked.rows[0]; const {today,yesterday}=await this.streakDay(client,await this.coupleZone(client,users.rows.map(member=>member.timezone)));
     let first=row.last_active_date===today?row.user1_answered_today:false; let second=row.last_active_date===today?row.user2_answered_today:false;
     if(user1)first=true;else second=true;
     let current=row.last_completed_date && row.last_completed_date!==yesterday && row.last_completed_date!==today?0:row.current_streak; let completed=row.last_completed_date;
@@ -190,13 +239,61 @@ export class PostgresAnswersRepository implements AnswersRepository {
   }
   async markSeen(userId:string,ids:string[]){const ctx=await this.context(this.pool,userId);await this.pool.query('update matches set is_new=false where couple_id=$1 and id=any($2::uuid[])',[ctx.couple_id,ids]);}
   async archive(userId:string,matchId:string,archived:boolean){const ctx=await this.context(this.pool,userId);const found=await this.pool.query('select 1 from matches where id=$1 and couple_id=$2',[matchId,ctx.couple_id]);if(!found.rowCount)throw new AnswersError('match_not_found',404,'Match was not found');if(archived)await this.pool.query('insert into match_archives(match_id,user_id) values($1,$2) on conflict do nothing',[matchId,userId]);else await this.pool.query('delete from match_archives where match_id=$1 and user_id=$2',[matchId,userId]);}
-  async streak(userId:string){const ctx=await this.context(this.pool,userId);const r=await this.pool.query('select * from couple_streaks where couple_id=$1',[ctx.couple_id]);return r.rows[0]?this.dates(r.rows[0]):null;}
+  async streak(userId:string):Promise<CoupleStreakView|null>{
+    const ctx=await this.context(this.pool,userId);
+    const r=await this.pool.query<StreakRow>(`select couple_id,current_streak,longest_streak,last_active_date::text last_active_date,last_completed_date::text last_completed_date,
+      user1_answered_today,user2_answered_today,streak_celebrated_at,created_at,updated_at from couple_streaks where couple_id=$1`,[ctx.couple_id]);
+    const row=r.rows[0]; if(!row)return null;
+    const members=await this.pool.query<{id:string;name:string|null;timezone:string|null}>('select id,name,timezone from profiles where couple_id=$1 order by id',[ctx.couple_id]);
+    if(members.rows.length<2)return null;
+    const zone=await this.coupleZone(this.pool,members.rows.map(member=>member.timezone));
+    const {today,yesterday}=await this.streakDay(this.pool,zone);
+    // The row is only rewritten when somebody answers, so a lapsed streak keeps its stored
+    // number until the next response arrives. Reading applies the same day rules the writer
+    // does rather than showing a count that the next answer will silently reset to 1.
+    const active=row.last_active_date===today;
+    const first=active&&row.user1_answered_today; const second=active&&row.user2_answered_today;
+    const alive=row.last_completed_date===today||row.last_completed_date===yesterday;
+    const isUser1=members.rows[0].id===userId; const partner=members.rows[isUser1?1:0];
+    return {
+      couple_id:row.couple_id,
+      current_streak:alive?row.current_streak:0,
+      longest_streak:row.longest_streak,
+      last_active_date:row.last_active_date,
+      last_completed_date:row.last_completed_date,
+      you_answered_today:isUser1?first:second,
+      partner_answered_today:isUser1?second:first,
+      partner_name:partner?.name??null,
+      timezone:zone,
+      streak_celebrated_at:row.streak_celebrated_at,
+      created_at:row.created_at.toISOString(),
+      updated_at:row.updated_at.toISOString(),
+    };
+  }
   private async question(client:PoolClient,id:string,lock=false){const r=await client.query<QuestionRow>(`select * from questions where id=$1 and deleted_at is null${lock?' for update':''}`,[id]);if(!r.rows[0])throw new AnswersError('question_not_found',404,'Question was not found');return r.rows[0];}
+  private timezoneNames(client:Pool|PoolClient){
+    // pg_timezone_names is a ~600-row function scan costing ~12ms. The list is static for the
+    // life of the process, so load it once instead of on every daily-limit check.
+    this.zones??=client.query<{name:string}>('select name from pg_timezone_names')
+      .then(r=>new Set(r.rows.map(row=>row.name)))
+      .catch(cause=>{this.zones=null;throw cause;});
+    return this.zones;
+  }
   private async lockedContext(client:PoolClient,userId:string){await client.query('select id from profiles where id=$1 for update',[userId]);return this.context(client,userId);}
   private async dailyLimitWith(client:Pool|PoolClient,userId:string){
-    const cfg=await this.config(client);if(cfg.daily_response_limit===0)return {responses_today:0,limit_value:0,remaining:0,reset_at:null,is_blocked:false};
-    const premium=await client.query<{premium:boolean}>('select (p.is_premium or coalesce(bool_or(o.is_premium),false)) premium from profiles p left join profiles o on o.couple_id=p.couple_id and o.id<>p.id where p.id=$1 group by p.is_premium',[userId]);if(premium.rows[0]?.premium)return {responses_today:0,limit_value:0,remaining:0,reset_at:null,is_blocked:false};
-    const r=await client.query<{count:number;reset_at:string}>("select count(*)::int count,((date_trunc('day',now() at time zone 'UTC') at time zone 'UTC')+interval '1 day') reset_at from responses where user_id=$1 and created_at>=(date_trunc('day',now() at time zone 'UTC') at time zone 'UTC')",[userId]);const count=r.rows[0]?.count??0;return {responses_today:count,limit_value:cfg.daily_response_limit,remaining:Math.max(0,cfg.daily_response_limit-count),reset_at:new Date(r.rows[0].reset_at).toISOString(),is_blocked:count>=cfg.daily_response_limit};
+    const cfg=await this.config(client);const unlimited={responses_today:0,limit_value:0,remaining:0,reset_at:null,is_blocked:false};
+    if(cfg.daily_response_limit===0)return unlimited;
+    // Premium is shared across a couple: either partner's subscription lifts the cap for both.
+    const profile=await client.query<{premium:boolean;zone:string|null}>('select (p.is_premium or coalesce(bool_or(o.is_premium),false)) premium,p.timezone zone from profiles p left join profiles o on o.couple_id=p.couple_id and o.id<>p.id where p.id=$1 group by p.is_premium,p.timezone',[userId]);
+    if(profile.rows[0]?.premium)return unlimited;
+    // The window is the user's local calendar day; an unreported or unrecognised zone falls
+    // back to UTC. Validating in JS keeps an unknown zone from erroring the query without
+    // paying for a pg_timezone_names scan inside submit()'s locked transaction.
+    const reported=profile.rows[0]?.zone;
+    const zone=reported&&(await this.timezoneNames(client)).has(reported)?reported:'UTC';
+    const r=await client.query<{count:number;reset_at:string}>(`select count(*)::int count,((date_trunc('day',now() at time zone $2::text)+interval '1 day') at time zone $2::text) reset_at from responses r where r.user_id=$1 and r.created_at>=(date_trunc('day',now() at time zone $2::text) at time zone $2::text) and not exists(${catchUpExemption})`,[userId,zone]);
+    const count=r.rows[0]?.count??0;
+    return {responses_today:count,limit_value:cfg.daily_response_limit,remaining:Math.max(0,cfg.daily_response_limit-count),reset_at:r.rows[0]?new Date(r.rows[0].reset_at).toISOString():null,is_blocked:count>=cfg.daily_response_limit};
   }
   private async assertEligible(client:PoolClient,userId:string,ctx:ContextRow,q:QuestionRow){
     const partner=await client.query<ContextRow&{id:string}>('select id,couple_id,gender,max_intensity,is_premium from profiles where couple_id=$1 and id<>$2 order by id limit 1',[ctx.couple_id,userId]);const p=partner.rows[0];

apps/api/src/domains/operations/repository.ts

@@ -36,7 +36,7 @@ export class PostgresOperationsRepository implements OperationsRepository {
   async produce(now: Date, limit=100): Promise<ProducerSummary> {
     return transaction(this.pool, async (client) => {
       const lock=await client.query<{locked:boolean}>("select pg_try_advisory_xact_lock(hashtext('sauci-operations-producers')) locked");
-      const empty={releasedPacks:0,streakMilestones:0,digests:0,packChanges:0,weeklySummaries:0,unpairedReminders:0,catchupReminders:0};
+      const empty={releasedPacks:0,streakMilestones:0,digests:0,packChanges:0,weeklySummaries:0,unpairedReminders:0,catchupReminders:0,streakReminders:0};
       if (!lock.rows[0]?.locked) return empty;
 
       const released=await client.query<{id:string;name:string}>(
@@ -139,11 +139,66 @@ export class PostgresOperationsRepository implements OperationsRepository {
          ) update profiles p set last_unpaired_reminder_at=$1 from queued q where p.id=q.recipient_id returning p.id`, [now,limit]);
 
       const catchup=await this.produceCatchups(client,now,limit);
+      const streakReminders=await this.produceStreakReminders(client,now);
       return {releasedPacks:released.rowCount??0,streakMilestones:milestones.rowCount??0,digests:digests.rowCount??0,
-        packChanges:packChanges.rowCount??0,weeklySummaries:weekly.rowCount??0,unpairedReminders:unpaired.rowCount??0,catchupReminders:catchup};
+        packChanges:packChanges.rowCount??0,weeklySummaries:weekly.rowCount??0,unpairedReminders:unpaired.rowCount??0,
+        catchupReminders:catchup,streakReminders};
     });
   }
 
+  /**
+   * A shared streak only changes behaviour if somebody hears that it is open before the day
+   * closes, so this fires in the couple's own late evening rather than on a server clock.
+   * Only the partner who still owes an answer is notified, and the copy names the other
+   * partner as an invitation rather than as a debt: guilt between partners is the failure
+   * mode for this mechanic, not the goal.
+   */
+  private async produceStreakReminders(client: PoolClient, now: Date): Promise<number> {
+    const result=await client.query(
+      `with zones as (select name from pg_timezone_names),
+       couple_zone as (
+         select r.couple_id,coalesce(z.name,'UTC') zone from (
+           select p.couple_id,(array_agg(p.timezone order by p.id) filter (where p.timezone is not null))[1] reported
+           from profiles p join couple_streaks cs on cs.couple_id=p.couple_id and cs.current_streak>0
+           group by p.couple_id
+         ) r left join zones z on z.name=r.reported
+       ),
+       at_risk as (
+         select cs.couple_id,cs.current_streak,cs.last_active_date,cs.user1_answered_today,cs.user2_answered_today,
+           ($1::timestamptz at time zone cz.zone)::date local_date
+         from couple_streaks cs join couple_zone cz on cz.couple_id=cs.couple_id
+         where cs.current_streak>0
+           and cs.last_completed_date=($1::timestamptz at time zone cz.zone)::date-1
+           and extract(hour from ($1::timestamptz at time zone cz.zone))>=20
+       ),
+       sides as (
+         select ar.couple_id,ar.current_streak,to_char(ar.local_date,'YYYY-MM-DD') local_date,
+           me.id me_id,me.push_token,nullif(btrim(partner.name),'') partner_name,
+           case when ar.last_active_date is distinct from ar.local_date then false
+                when me.id<partner.id then ar.user1_answered_today else ar.user2_answered_today end me_answered,
+           case when ar.last_active_date is distinct from ar.local_date then false
+                when me.id<partner.id then ar.user2_answered_today else ar.user1_answered_today end partner_answered
+         from at_risk ar
+         join profiles me on me.couple_id=ar.couple_id
+         join profiles partner on partner.couple_id=ar.couple_id and partner.id<>me.id
+       )
+       insert into operations_outbox(kind,dedupe_key,recipient_id,payload)
+       select 'expo','streak_risk:'||s.couple_id||':'||s.local_date||':'||s.me_id,s.me_id,
+         jsonb_build_object(
+           'title',case when s.partner_answered then coalesce(s.partner_name,'Your partner')||' answered today'
+                        else 'Your '||s.current_streak||'-day streak' end,
+           'body',case when s.partner_answered
+                       then 'You two are '||s.current_streak||' days in together. One question keeps it going.'
+                       else 'You and '||coalesce(s.partner_name,'your partner')||' are '||s.current_streak||' days in. One question each keeps it going.' end,
+           'data',jsonb_build_object('type','streak_reminder','streak',s.current_streak))
+       from sides s left join notification_preferences np on np.user_id=s.me_id
+       where not s.me_answered and s.push_token is not null and coalesce(np.streak_reminders_enabled,true)
+         and not exists(select 1 from operations_outbox o
+           where o.dedupe_key='streak_risk:'||s.couple_id||':'||s.local_date||':'||s.me_id)
+       on conflict(dedupe_key) do nothing`,[now]);
+    return result.rowCount??0;
+  }
+
   private async produceCatchups(client: PoolClient, now: Date, limit: number): Promise<number> {
     await client.query(
       `with behind as (
@@ -202,6 +257,7 @@ export class PostgresOperationsRepository implements OperationsRepository {
                when 'pack_change' then case when coalesce(np.pack_changes_enabled,true) then p.push_token end
                when 'new_pack' then case when coalesce(np.new_packs_enabled,true) then p.push_token end
                when 'streak_milestone' then case when coalesce(np.streak_milestones_enabled,true) then p.push_token end
+               when 'streak_reminder' then case when coalesce(np.streak_reminders_enabled,true) then p.push_token end
                when 'weekly_summary' then case when coalesce(np.weekly_summary_enabled,true) then p.push_token end
                when 'unpaired_reminder' then case when coalesce(np.unpaired_reminders_enabled,true) then p.push_token end
                when 'catchup_reminder' then case when coalesce(np.catchup_reminders_enabled,true) then p.push_token end

apps/api/src/domains/operations/types.ts

@@ -48,4 +48,5 @@ export interface ProducerSummary {
   weeklySummaries: number;
   unpairedReminders: number;
   catchupReminders: number;
+  streakReminders: number;
 }

apps/api/src/domains/profile-settings/repository.ts

@@ -16,6 +16,7 @@ interface PreferencesRow extends QueryResultRow {
   pack_changes_enabled: boolean;
   new_packs_enabled: boolean;
   streak_milestones_enabled: boolean;
+  streak_reminders_enabled: boolean;
   weekly_summary_enabled: boolean;
   unpaired_reminders_enabled: boolean;
   catchup_reminders_enabled: boolean;
@@ -49,6 +50,7 @@ const profileColumns: Record<keyof ProfileUpdate, string> = {
   onboarding_version: 'onboarding_version',
   public_key_jwk: 'public_key_jwk',
   push_token: 'push_token',
+  timezone: 'timezone',
 };
 
 function toPreferences(row: PreferencesRow): NotificationPreferences {
@@ -61,6 +63,7 @@ function toPreferences(row: PreferencesRow): NotificationPreferences {
     pack_changes_enabled: row.pack_changes_enabled,
     new_packs_enabled: row.new_packs_enabled,
     streak_milestones_enabled: row.streak_milestones_enabled,
+    streak_reminders_enabled: row.streak_reminders_enabled,
     weekly_summary_enabled: row.weekly_summary_enabled,
     unpaired_reminders_enabled: row.unpaired_reminders_enabled,
     catchup_reminders_enabled: row.catchup_reminders_enabled,

apps/api/src/domains/profile-settings/routes.ts

@@ -18,6 +18,8 @@ const profileUpdateSchema = z.object({
   onboarding_version: z.number().int().min(0).optional(),
   public_key_jwk: z.record(z.unknown()).nullable().optional(),
   push_token: z.string().trim().min(1).max(512).nullable().optional(),
+  // IANA zone from the client; the daily response limit buckets on the user's local day.
+  timezone: z.string().trim().min(1).max(64).nullable().optional(),
 }).strict().refine((body) => Object.keys(body).length > 0, 'At least one profile field is required');
 
 const preferenceSchema = z.object({

apps/api/src/domains/profile-settings/types.ts

@@ -6,6 +6,7 @@ export const notificationPreferenceKeys = [
   'pack_changes_enabled',
   'new_packs_enabled',
   'streak_milestones_enabled',
+  'streak_reminders_enabled',
   'weekly_summary_enabled',
   'unpaired_reminders_enabled',
   'catchup_reminders_enabled',
@@ -30,6 +31,7 @@ export interface ProfileUpdate {
   onboarding_version?: number;
   public_key_jwk?: Record<string, unknown> | null;
   push_token?: string | null;
+  timezone?: string | null;
 }
 
 export interface FeedbackSubmission {

apps/api/test/answers.integration.test.ts

@@ -5,13 +5,43 @@ import { afterAll,beforeAll,describe,expect,it } from 'vitest';
 import { PostgresAnswersRepository } from '../src/domains/answers/repository.js';
 const url=process.env.DATABASE_URL;const local=url?['127.0.0.1','localhost','::1'].includes(new URL(url).hostname):false;if(url&&!local)throw new Error('Answer integration tests only permit localhost');
 describe.skipIf(!url||!local)('answers + PostgreSQL',()=>{const admin=new Pool({connectionString:url});const schema=`answers_${randomUUID().replaceAll('-','')}`;let pool:Pool;let repo:PostgresAnswersRepository;
-const u1='11111111-1111-4111-8111-111111111111',u2='22222222-2222-4222-8222-222222222222',outsider='33333333-3333-4333-8333-333333333333',couple='44444444-4444-4444-8444-444444444444',other='55555555-5555-4555-8555-555555555555',pack='66666666-6666-4666-8666-666666666666',q='77777777-7777-4777-8777-777777777777',concurrentQ='88888888-8888-4888-8888-888888888888',femaleOnlyQ='99999999-9999-4999-8999-999999999999';
-beforeAll(async()=>{await admin.query(`create schema "${schema}"`);const isolated=new URL(url!);isolated.searchParams.set('options',`-c search_path=${schema}`);pool=new Pool({connectionString:isolated.toString()});repo=new PostgresAnswersRepository(isolated.toString());for(const name of ['0000_identity_and_feature_interests.sql','0001_couples.sql','0002_packs_catalog_progress.sql','0003_answers_matches.sql']){const sql=await readFile(new URL(`../drizzle/${name}`,import.meta.url),'utf8');for(const s of sql.split('--> statement-breakpoint'))if(s.trim())await pool.query(s);}await pool.query('insert into couples(id,invite_code) values($1,$2),($3,$4)',[couple,'ANSWERS1',other,'ANSWERS2']);await pool.query("insert into profiles(id,couple_id,gender,max_intensity) values($1,$4,'female',5),($2,$4,'male',3),($3,$5,'male',5)",[u1,u2,outsider,couple,other]);await pool.query("insert into question_packs(id,name) values($1,'Core')",[pack]);await pool.query("insert into questions(id,pack_id,text,intensity,target_user_genders) values($1,$2,'Question',3,array['female']),($3,$2,'Concurrent',2,null),($4,$2,'Female first',2,array['female'])",[q,pack,concurrentQ,femaleOnlyQ]);await pool.query('insert into couple_packs(couple_id,pack_id,enabled) values($1,$2,true)',[couple,pack]);});afterAll(async()=>{await repo.close();await pool.end();await admin.query(`drop schema "${schema}" cascade`);await admin.end();});
+const u1='11111111-1111-4111-8111-111111111111',u2='22222222-2222-4222-8222-222222222222',outsider='33333333-3333-4333-8333-333333333333',couple='44444444-4444-4444-8444-444444444444',other='55555555-5555-4555-8555-555555555555',pack='66666666-6666-4666-8666-666666666666',q='77777777-7777-4777-8777-777777777777',concurrentQ='88888888-8888-4888-8888-888888888888',femaleOnlyQ='99999999-9999-4999-8999-999999999999',limitQ1='aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa',limitQ2='bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb',catchUpQ='cccccccc-cccc-4ccc-8ccc-cccccccccccc';
+beforeAll(async()=>{await admin.query(`create schema "${schema}"`);const isolated=new URL(url!);isolated.searchParams.set('options',`-c search_path=${schema}`);pool=new Pool({connectionString:isolated.toString()});repo=new PostgresAnswersRepository(isolated.toString());for(const name of ['0000_identity_and_feature_interests.sql','0001_couples.sql','0002_packs_catalog_progress.sql','0003_answers_matches.sql','0013_daily_limit_local_reset.sql','0014_daily_limit_response_index.sql','0015_couple_streak_locality.sql']){const sql=await readFile(new URL(`../drizzle/${name}`,import.meta.url),'utf8');for(const s of sql.split('--> statement-breakpoint'))if(s.trim())await pool.query(s);}await pool.query('insert into couples(id,invite_code) values($1,$2),($3,$4)',[couple,'ANSWERS1',other,'ANSWERS2']);await pool.query("insert into profiles(id,couple_id,gender,max_intensity) values($1,$4,'female',5),($2,$4,'male',3),($3,$5,'male',5)",[u1,u2,outsider,couple,other]);await pool.query("insert into question_packs(id,name) values($1,'Core')",[pack]);await pool.query("insert into questions(id,pack_id,text,intensity,target_user_genders) values($1,$2,'Question',3,array['female']),($3,$2,'Concurrent',2,null),($4,$2,'Female first',2,array['female']),($5,$2,'Limit one',2,null),($6,$2,'Limit two',2,null),($7,$2,'Catch up',2,null)",[q,pack,concurrentQ,femaleOnlyQ,limitQ1,limitQ2,catchUpQ]);await pool.query('insert into couple_packs(couple_id,pack_id,enabled) values($1,$2,true)',[couple,pack]);});afterAll(async()=>{await repo.close();await pool.end();await admin.query(`drop schema "${schema}" cascade`);await admin.end();});
 it('targets recommendation by gender and excludes completed responses',async()=>{expect((await repo.recommended(u1)).map(x=>x.id)).toContain(q);expect((await repo.recommended(u2)).map(x=>x.id)).not.toContain(q);await repo.submit(u1,{questionId:q,answer:'yes'});expect((await repo.recommended(u1)).map(x=>x.id)).not.toContain(q);});
 it('rejects direct answers that bypass target-gender eligibility',async()=>{await expect(repo.submit(u2,{questionId:femaleOnlyQ,answer:'yes'})).rejects.toMatchObject({code:'question_not_eligible'});});
 it('serializes concurrent partner submissions and still creates one match',async()=>{await Promise.all([repo.submit(u1,{questionId:concurrentQ,answer:'yes'}),repo.submit(u2,{questionId:concurrentQ,answer:'yes'})]);const counts=await pool.query('select count(*)::int count from matches where question_id=$1',[concurrentQ]);expect(counts.rows[0].count).toBe(1);});
 it('is idempotent and creates one match only after both partners answer',async()=>{await repo.submit(u1,{questionId:q,answer:'yes'});expect((await repo.submit(u1,{questionId:q,answer:'maybe'})).match).toBeNull();const second=await repo.submit(u2,{questionId:q,answer:'yes'});expect(second.match?.match_type).toBe('yes_maybe');await repo.submit(u2,{questionId:q,answer:'yes'});const counts=await pool.query('select (select count(*) from responses where question_id=$1) responses,(select count(*) from matches where question_id=$1) matches',[q]);expect(counts.rows[0]).toMatchObject({responses:'2',matches:'1'});});
 it('requires confirmation before destroying a match and isolates outsiders',async()=>{const pending=await repo.update(u1,{questionId:q,answer:'no',confirmDeleteMatch:false});expect(pending).toMatchObject({success:false,requires_confirmation:true,message_count:0});expect(await repo.update(u1,{questionId:q,answer:'no',confirmDeleteMatch:true})).toMatchObject({success:true,match_deleted:true});await expect(repo.archive(outsider,'88888888-8888-4888-8888-888888888888',true)).rejects.toMatchObject({code:'match_not_found'});});
-it('records both partners once per day and increments on a consecutive day',async()=>{await repo.submit(u1,{questionId:q,answer:'yes'});await repo.submit(u2,{questionId:q,answer:'yes'});expect(await repo.streak(u1)).toMatchObject({current_streak:1,longest_streak:1,user1_answered_today:true,user2_answered_today:true});await pool.query("update couple_streaks set current_streak=1,longest_streak=1,last_active_date=current_date-1,last_completed_date=current_date-1,user1_answered_today=false,user2_answered_today=false where couple_id=$1",[couple]);await repo.submit(u1,{questionId:q,answer:'yes'});await repo.submit(u2,{questionId:q,answer:'yes'});expect(await repo.streak(u1)).toMatchObject({current_streak:2,longest_streak:2});});
-it('serializes the daily limit across different questions',async()=>{await pool.query('delete from responses where user_id=$1',[u1]);await pool.query('update app_config set daily_response_limit=1');const results=await Promise.allSettled([repo.submit(u1,{questionId:q,answer:'yes'}),repo.submit(u1,{questionId:femaleOnlyQ,answer:'yes'})]);expect(results.filter(r=>r.status==='fulfilled')).toHaveLength(1);expect(results.filter(r=>r.status==='rejected')).toHaveLength(1);expect(await repo.dailyLimit(u1)).toMatchObject({responses_today:1,is_blocked:true});});
+it('records both partners once per day and increments on a consecutive day',async()=>{await repo.submit(u1,{questionId:q,answer:'yes'});await repo.submit(u2,{questionId:q,answer:'yes'});expect(await repo.streak(u1)).toMatchObject({current_streak:1,longest_streak:1,you_answered_today:true,partner_answered_today:true});await pool.query("update couple_streaks set current_streak=1,longest_streak=1,last_active_date=current_date-1,last_completed_date=current_date-1,user1_answered_today=false,user2_answered_today=false where couple_id=$1",[couple]);await repo.submit(u1,{questionId:q,answer:'yes'});await repo.submit(u2,{questionId:q,answer:'yes'});expect(await repo.streak(u1)).toMatchObject({current_streak:2,longest_streak:2});});
+it('answers the streak from the caller side rather than by stored position',async()=>{await pool.query("update profiles set name='Alex' where id=$1",[u2]);await pool.query("update profiles set name='Sam' where id=$1",[u1]);await pool.query('delete from responses where couple_id=$1',[couple]);await pool.query('delete from matches where couple_id=$1',[couple]);await pool.query("update couple_streaks set current_streak=0,last_active_date=null,last_completed_date=null,user1_answered_today=false,user2_answered_today=false where couple_id=$1",[couple]);
+  await repo.submit(u1,{questionId:q,answer:'yes'});
+  expect(await repo.streak(u1)).toMatchObject({you_answered_today:true,partner_answered_today:false,partner_name:'Alex',current_streak:0});
+  expect(await repo.streak(u2)).toMatchObject({you_answered_today:false,partner_answered_today:true,partner_name:'Sam',current_streak:0});});
+
+it('counts the day in the couple shared zone and prefers the first reported member zone',async()=>{await pool.query('update profiles set timezone=$2 where id=$1',[u1,'Pacific/Auckland']);await pool.query('update profiles set timezone=$2 where id=$1',[u2,'America/Los_Angeles']);
+  await pool.query('delete from responses where couple_id=$1',[couple]);await pool.query('delete from matches where couple_id=$1',[couple]);
+  await repo.submit(u1,{questionId:q,answer:'yes'});
+  const expected=await pool.query<{day:string}>("select (now() at time zone 'Pacific/Auckland')::date::text as day");
+  expect(await repo.streak(u1)).toMatchObject({timezone:'Pacific/Auckland',last_active_date:expected.rows[0].day});
+  // The lower member id decides the zone, so an unreported zone there falls through to the partner.
+  await pool.query('update profiles set timezone=null where id=$1',[u1]);
+  expect((await repo.streak(u1))?.timezone).toBe('America/Los_Angeles');
+  await pool.query("update profiles set timezone='Not/AZone' where id=$1",[u1]);
+  expect((await repo.streak(u1))?.timezone).toBe('UTC');
+  await pool.query('update profiles set timezone=null where couple_id=$1',[couple]);});
+
+it('reports a lapsed streak as broken before the next answer rewrites it',async()=>{await pool.query('update profiles set timezone=null where couple_id=$1',[couple]);await pool.query("update couple_streaks set current_streak=5,longest_streak=9,last_active_date=current_date-3,last_completed_date=current_date-3,user1_answered_today=true,user2_answered_today=true where couple_id=$1",[couple]);
+  expect(await repo.streak(u1)).toMatchObject({current_streak:0,longest_streak:9,you_answered_today:false,partner_answered_today:false});
+  // A streak completed yesterday is still alive and still shows its count.
+  await pool.query('update couple_streaks set last_completed_date=current_date-1,last_active_date=current_date-1 where couple_id=$1',[couple]);
+  expect(await repo.streak(u1)).toMatchObject({current_streak:5,you_answered_today:false});});
+
+const resetLimit=async(limit:number,timezone:string|null=null)=>{await pool.query('delete from responses where couple_id=$1',[couple]);await pool.query('delete from matches where couple_id=$1',[couple]);await pool.query('update app_config set daily_response_limit=$1',[limit]);await pool.query('update profiles set timezone=$2 where id=$1',[u1,timezone]);};
+it('serializes the daily limit across different questions',async()=>{await resetLimit(1);const results=await Promise.allSettled([repo.submit(u1,{questionId:limitQ1,answer:'yes'}),repo.submit(u1,{questionId:limitQ2,answer:'yes'})]);expect(results.filter(r=>r.status==='fulfilled')).toHaveLength(1);expect(results.filter(r=>r.status==='rejected')).toHaveLength(1);expect(await repo.dailyLimit(u1)).toMatchObject({responses_today:1,remaining:0,is_blocked:true});});
+it('exempts catching up on a question the partner answered first',async()=>{await resetLimit(1);await repo.submit(u2,{questionId:catchUpQ,answer:'yes'});await repo.submit(u1,{questionId:limitQ1,answer:'yes'});expect(await repo.dailyLimit(u1)).toMatchObject({responses_today:1,is_blocked:true});await expect(repo.submit(u1,{questionId:catchUpQ,answer:'yes'})).resolves.toBeTruthy();expect(await repo.dailyLimit(u1)).toMatchObject({responses_today:1,is_blocked:true});await expect(repo.submit(u1,{questionId:limitQ2,answer:'yes'})).rejects.toMatchObject({code:'daily_limit'});});
+it('reports the daily limit error with the shape the client renders',async()=>{await resetLimit(1);await repo.submit(u1,{questionId:limitQ1,answer:'yes'});await expect(repo.submit(u1,{questionId:limitQ2,answer:'yes'})).rejects.toMatchObject({code:'daily_limit',status:429,details:{daily_limit:1,responses_today:1,remaining:0}});});
+it('buckets the window on the user local day and falls back to UTC',async()=>{await resetLimit(5,'Pacific/Auckland');const nz=await repo.dailyLimit(u1);const nzBoundary=await pool.query<{expected:string}>("select ((date_trunc('day',now() at time zone 'Pacific/Auckland')+interval '1 day') at time zone 'Pacific/Auckland') expected");expect(nz.reset_at).toBe(new Date(nzBoundary.rows[0].expected).toISOString());
+  const utcBoundary=await pool.query<{expected:string}>("select ((date_trunc('day',now() at time zone 'UTC')+interval '1 day') at time zone 'UTC') expected");
+  for(const zone of [null,'Not/AZone']){await pool.query('update profiles set timezone=$2 where id=$1',[u1,zone]);expect((await repo.dailyLimit(u1)).reset_at).toBe(new Date(utcBoundary.rows[0].expected).toISOString());}});
+it('blocks pack browsing once the limit is reached',async()=>{await resetLimit(1);expect((await repo.recommended(u1,pack)).length).toBeGreaterThan(0);await repo.submit(u1,{questionId:limitQ1,answer:'yes'});expect(await repo.recommended(u1,pack)).toEqual([]);expect(await repo.recommended(u1)).toEqual([]);await resetLimit(0);});
 });

apps/api/test/answers.routes.test.ts

@@ -15,7 +15,9 @@ function app(r:AnswersRepository){const app=new Hono<{Variables:{identity:AuthId
 
 describe('answer routes',()=>{
   it('takes ownership only from the bearer identity',async()=>{const r=repo();const a=app(r);await a.request('/v1/responses',{method:'POST',headers:{'content-type':'application/json'},body:JSON.stringify({question_id:questionId,answer:'yes',user_id:'attacker'})});expect(r.submit).not.toHaveBeenCalled();const ok=await a.request('/v1/responses',{method:'POST',headers:{'content-type':'application/json'},body:JSON.stringify({question_id:questionId,answer:'yes'})});expect(ok.status).toBe(200);expect(r.submit).toHaveBeenCalledWith(identity.id,{questionId,answer:'yes',responseData:undefined});});
-  it('maps confirmation and domain failures',async()=>{const r=repo();vi.mocked(r.update).mockResolvedValueOnce({success:false,requires_confirmation:true,message_count:2});const a=app(r);expect(await (await a.request(`/v1/responses/${questionId}`,{method:'PATCH',headers:{'content-type':'application/json'},body:'{"new_answer":"no"}'})).json()).toMatchObject({requires_confirmation:true,message_count:2});vi.mocked(r.submit).mockRejectedValueOnce(new AnswersError('daily_limit',429,'Daily response limit reached'));expect((await a.request('/v1/responses',{method:'POST',headers:{'content-type':'application/json'},body:JSON.stringify({question_id:questionId,answer:'yes'})})).status).toBe(429);});
+  it('maps confirmation and domain failures',async()=>{const r=repo();vi.mocked(r.update).mockResolvedValueOnce({success:false,requires_confirmation:true,message_count:2});const a=app(r);expect(await (await a.request(`/v1/responses/${questionId}`,{method:'PATCH',headers:{'content-type':'application/json'},body:'{"new_answer":"no"}'})).json()).toMatchObject({requires_confirmation:true,message_count:2});vi.mocked(r.submit).mockRejectedValueOnce(new AnswersError('daily_limit',429,'Daily response limit reached',{daily_limit:10,responses_today:10,remaining:0,reset_at:'2026-08-29T00:00:00.000Z'}));const blocked=await a.request('/v1/responses',{method:'POST',headers:{'content-type':'application/json'},body:JSON.stringify({question_id:questionId,answer:'yes'})});expect(blocked.status).toBe(429);
+    // The client renders the limit screen straight from this body, so its shape is a contract.
+    expect(await blocked.json()).toMatchObject({error:{code:'daily_limit'},details:{daily_limit:10,responses_today:10,remaining:0,reset_at:'2026-08-29T00:00:00.000Z'}});});
   it('scopes match mutations to identity',async()=>{const r=repo();const a=app(r);await a.request('/v1/matches/seen',{method:'PATCH',headers:{'content-type':'application/json'},body:JSON.stringify({ids:[questionId]})});expect(r.markSeen).toHaveBeenCalledWith(identity.id,[questionId]);await a.request(`/v1/matches/${questionId}/archive`,{method:'PUT',headers:{'content-type':'application/json'},body:'{"archived":true}'});expect(r.archive).toHaveBeenCalledWith(identity.id,questionId,true);});
 });
 

apps/api/test/api.integration.test.ts

@@ -28,7 +28,8 @@ describe.skipIf(!databaseUrl || !localDatabase)('API + PostgreSQL integration',
     isolatedUrl.searchParams.set('options', `-c search_path=${schema}`);
     pool = new Pool({ connectionString: isolatedUrl.toString() });
     repository = new PostgresRepository(isolatedUrl.toString());
-    const migration = await readFile(new URL('../drizzle/0000_identity_and_feature_interests.sql', import.meta.url), 'utf8');
+    const migration = (await Promise.all(['0000_identity_and_feature_interests.sql','0013_daily_limit_local_reset.sql']
+      .map((name) => readFile(new URL(`../drizzle/${name}`, import.meta.url), 'utf8')))).join('\n--> statement-breakpoint\n');
     for (const statement of migration.split('--> statement-breakpoint')) {
       if (statement.trim()) await pool.query(statement);
     }

apps/api/test/operations.integration.test.ts

@@ -12,7 +12,7 @@ describe.skipIf(!databaseUrl||!local)('PostgresOperationsRepository',()=>{
   const pack='44444444-4444-4444-8444-444444444444',question='55555555-5555-4555-8555-555555555555';let pool:Pool;let repo:PostgresOperationsRepository;let repo2:PostgresOperationsRepository;
   beforeAll(async()=>{
     await admin.query(`create schema "${schema}"`);const url=new URL(databaseUrl!);url.searchParams.set('options',`-c search_path=${schema}`);pool=new Pool({connectionString:url.toString()});repo=new PostgresOperationsRepository(url.toString());repo2=new PostgresOperationsRepository(url.toString());
-    for(const name of ['0000_identity_and_feature_interests.sql','0001_couples.sql','0002_packs_catalog_progress.sql','0003_answers_matches.sql','0004_chat.sql','0005_profile_settings.sql','0006_media_storage.sql','0009_operations_workers.sql','0010_admin.sql']){
+    for(const name of ['0000_identity_and_feature_interests.sql','0001_couples.sql','0002_packs_catalog_progress.sql','0003_answers_matches.sql','0004_chat.sql','0005_profile_settings.sql','0006_media_storage.sql','0009_operations_workers.sql','0010_admin.sql','0013_daily_limit_local_reset.sql','0015_couple_streak_locality.sql','0016_streak_reminder_preference.sql']){
       const sql=await readFile(new URL(`../drizzle/${name}`,import.meta.url),'utf8');for(const statement of sql.split('--> statement-breakpoint'))if(statement.trim())await pool.query(statement);
     }
     await pool.query('insert into couples(id,invite_code) values($1,$2)',[couple,'ABCD2345']);
@@ -68,6 +68,44 @@ describe.skipIf(!databaseUrl||!local)('PostgresOperationsRepository',()=>{
     await repo.produce(new Date(Date.now()+10*60*1000),100);expect((await pool.query('select count(*)::int count from operations_outbox')).rows[0].count).toBe(before);
   });
 
+  it('nudges only the partner who still owes an answer, in the couple evening',async()=>{
+    // Alice sorts below Bob, so Alice is user1. She has answered today; Bob has not.
+    await pool.query("update profiles set timezone='UTC' where couple_id=$1",[couple]);
+    const evening=new Date('2026-08-27T21:00:00Z');
+    await pool.query(`insert into couple_streaks(couple_id,current_streak,longest_streak,last_active_date,last_completed_date,user1_answered_today,user2_answered_today,streak_celebrated_at)
+      values($1,6,6,'2026-08-27','2026-08-26',true,false,6) on conflict(couple_id) do update set current_streak=6,longest_streak=6,
+      last_active_date='2026-08-27',last_completed_date='2026-08-26',user1_answered_today=true,user2_answered_today=false,streak_celebrated_at=6`,[couple]);
+
+    expect((await repo.produce(evening,100)).streakReminders).toBe(1);
+    const queued=await pool.query<{recipient_id:string;title:string;body:string}>(
+      `select recipient_id,payload->>'title' title,payload->>'body' body from operations_outbox where dedupe_key like 'streak_risk:%'`);
+    expect(queued.rows).toHaveLength(1);
+    expect(queued.rows[0]).toMatchObject({recipient_id:bob,title:'Alice answered today'});
+    expect(queued.rows[0].body).toContain('6 days in');
+    expect((await pool.query('select 1 from operations_outbox where dedupe_key=$1',[`streak_risk:${couple}:2026-08-27:${bob}`])).rowCount).toBe(1);
+
+    // A second tick inside the same couple-local evening must not queue a second nudge.
+    expect((await repo.produce(evening,100)).streakReminders).toBe(0);
+  });
+
+  it('addresses both partners when neither has answered and honours the preference',async()=>{
+    const next=new Date('2026-08-28T21:00:00Z');
+    await pool.query(`update couple_streaks set last_active_date='2026-08-27',last_completed_date='2026-08-27',
+      user1_answered_today=true,user2_answered_today=true where couple_id=$1`,[couple]);
+    expect((await repo.produce(next,100)).streakReminders).toBe(2);
+    const both=await pool.query<{title:string;body:string}>(
+      `select payload->>'title' title,payload->>'body' body from operations_outbox where dedupe_key like $1 order by recipient_id`,
+      [`streak_risk:${couple}:2026-08-28:%`]);
+    expect(both.rows.map(r=>r.title)).toEqual(['Your 6-day streak','Your 6-day streak']);
+    expect(both.rows[0].body).toContain('One question each');
+
+    await pool.query(`insert into notification_preferences(user_id,streak_reminders_enabled) values($1,false),($2,false)
+      on conflict(user_id) do update set streak_reminders_enabled=false`,[alice,bob]);
+    await pool.query(`update couple_streaks set last_active_date='2026-08-28',last_completed_date='2026-08-28' where couple_id=$1`,[couple]);
+    expect((await repo.produce(new Date('2026-08-29T21:00:00Z'),100)).streakReminders).toBe(0);
+    await pool.query('update notification_preferences set streak_reminders_enabled=true where user_id in ($1,$2)',[alice,bob]);
+  });
+
   it('uses skip-locked claims so concurrent workers never receive the same item',async()=>{
     await pool.query('insert into notification_preferences(user_id,messages_enabled) values($1,false) on conflict(user_id) do update set messages_enabled=false',[bob]);
     const [a,b]=await Promise.all([repo.claim(100),repo2.claim(100)]);const ids=[...a,...b].map(item=>item.id);expect(new Set(ids).size).toBe(ids.length);expect(ids.length).toBeGreaterThan(0);

apps/api/test/operations.runner.test.ts

@@ -5,7 +5,7 @@ import { OperationsRunner } from '../src/domains/operations/runner.js';
 import type { OperationItem } from '../src/domains/operations/types.js';
 import { loadWorkerConfig } from '../src/workers/config.js';
 
-const summary={releasedPacks:0,streakMilestones:0,digests:0,packChanges:0,weeklySummaries:0,unpairedReminders:0,catchupReminders:0};
+const summary={releasedPacks:0,streakMilestones:0,digests:0,packChanges:0,weeklySummaries:0,unpairedReminders:0,catchupReminders:0,streakReminders:0};
 function repository(items:OperationItem[]):OperationsRepository {
   return {produce:vi.fn(async()=>summary),claim:vi.fn(async()=>items),complete:vi.fn(async()=>undefined),fail:vi.fn(async()=>undefined),
     message:vi.fn(async()=>null),classifierConfig:vi.fn(async()=>null),classify:vi.fn(async()=>undefined),close:vi.fn(async()=>undefined)};

apps/api/test/profile-settings.routes.test.ts

@@ -20,6 +20,7 @@ const preferences = {
   pack_changes_enabled: true,
   new_packs_enabled: true,
   streak_milestones_enabled: true,
+  streak_reminders_enabled: true,
   weekly_summary_enabled: true,
   unpaired_reminders_enabled: true,
   catchup_reminders_enabled: true,