feat(pairing): solo sealed answers that unlock on pairing

Unpaired users could only reach a waiting-room dead end and could not answer
questions until a partner joined. Responses.couple_id is now nullable so a
solo user answers immediately and banks "sealed answers" (couple_id IS NULL).
Pairing claims both members' sealed answers and computes matches for every
question both have now answered. Invite copy and the unpaired push nudge
escalate with the sealed answer count.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

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

@@ -42,7 +42,7 @@ export interface AnswersRepository {
   pending(userId: string, direction: 'mine' | 'partner', startQuestionId?: string): Promise<Array<{ id: string; question: QuestionRow & { pack: { id: string; name: string; icon: string | null } }; partnerAnsweredAt: string }>>;
   answerGap(userId: string): Promise<{ unanswered_by_partner: number; threshold: number; is_blocked: boolean }>;
   dailyLimit(userId: string): Promise<{ responses_today: number; limit_value: number; remaining: number; reset_at: string | null; is_blocked: boolean }>;
-  submit(userId: string, input: SubmitInput): Promise<{ response: ResponseRow; match: (MatchRow & { question: QuestionRow }) | null }>;
+  submit(userId: string, input: SubmitInput): Promise<{ response: ResponseRow; match: (MatchRow & { question: QuestionRow }) | null; sealed_count?: number }>;
   update(userId: string, input: UpdateInput): Promise<Record<string, unknown>>;
   responses(userId: string, page: number, limit: number): Promise<{ responses: unknown[]; totalCount: number }>;
   matches(userId: string, page: number, limit: number, archived: boolean): Promise<{ matches: unknown[]; totalCount: number | null; hasMore: boolean }>;
@@ -58,10 +58,17 @@ export class PostgresAnswersRepository implements AnswersRepository {
   private zones: Promise<Set<string>> | null = null;
   constructor(connection: DatabaseConnection) { const resolved = resolvePool(connection); this.pool = resolved.pool; this.ownsPool = resolved.owned; }
 
+  /**
+   * couple_id is nullable here: an unpaired user still has a profile and can answer
+   * questions solo, banking them as sealed answers (couple_id IS NULL on responses)
+   * until a partner joins. Callers that need a couple for their own operation (e.g.
+   * matches, streaks) get an empty/no-op result naturally because every downstream
+   * query is scoped by couple_id, which stays null for a solo caller.
+   */
   private async context(client: Pool | PoolClient, userId: string): Promise<ContextRow> {
     const result = await client.query<ContextRow>('select couple_id, gender, max_intensity, is_premium from profiles where id=$1', [userId]);
     const row = result.rows[0];
-    if (!row?.couple_id) throw new AnswersError('no_couple', 409, 'Join a couple before answering questions');
+    if (!row) throw new AnswersError('no_couple', 409, 'Complete signup before answering questions');
     return row;
   }
 
@@ -147,15 +154,25 @@ 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 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]);
+        // A solo answerer has no partner, so the catch-up exemption never applies:
+        // every sealed answer counts against the daily limit like a fresh one.
+        const catchingUp = ctx.couple_id
+          ? 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])
+          : { rowCount: 0 };
         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]);
-      const match = await this.reconcileMatch(client,userId,ctx.couple_id!,q,input.answer,input.responseData ?? null,true);
-      await this.touchStreak(client,userId,ctx.couple_id!);
+      if (!ctx.couple_id) {
+        // No couple yet: bank the answer as sealed. It is claimed and reconciled
+        // into matches once a partner joins; see couples repository join().
+        const sealed = await client.query<{ count: number }>('select count(*)::int count from responses where user_id=$1 and couple_id is null',[userId]);
+        return { response: this.dates(response.rows[0]), match: null, sealed_count: sealed.rows[0]?.count ?? 0 };
+      }
+      const match = await this.reconcileMatch(client,userId,ctx.couple_id,q,input.answer,input.responseData ?? null,true);
+      await this.touchStreak(client,userId,ctx.couple_id);
       return { response: this.dates(response.rows[0]), match: match ? { ...this.dates(match), question: this.dates(q) } : null };
     });
   }
@@ -172,9 +189,9 @@ export class PostgresAnswersRepository implements AnswersRepository {
         return { success:false,requires_confirmation:true,match_id:existing.rows[0].id,message_count:count.rows[0]?.count ?? 0 };
       }
       const normalized=q.question_type!=='swipe' && input.answer!=='no' ? (typeof input.responseData==='undefined' ? current.rows[0].response_data : input.responseData) : null;
-      const before=existing.rows[0]; const match=await this.reconcileMatch(client,userId,ctx.couple_id!,q,input.answer,normalized,false);
+      const before=existing.rows[0]; const match=ctx.couple_id?await this.reconcileMatch(client,userId,ctx.couple_id,q,input.answer,normalized,false):null;
       await client.query('update responses set answer=$3,response_data=$4 where user_id=$1 and question_id=$2',[userId,input.questionId,input.answer,normalized]);
-      await this.touchStreak(client,userId,ctx.couple_id!);
+      if (ctx.couple_id) await this.touchStreak(client,userId,ctx.couple_id);
       return { success:true, ...(before&&!match?{match_deleted:true}:{ }), ...(!before&&match?{new_match:this.dates(match)}:{}), ...(before&&match?{match_type_updated:true}:{}) };
     });
   }

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

@@ -1,6 +1,7 @@
 import type { Couple, Profile } from '@sauci/shared';
 import { Pool, type PoolClient, type QueryResultRow } from 'pg';
 import { closeResolvedPool, resolvePool, type DatabaseConnection } from '../../db/pool.js';
+import { calculateMatchType, type Answer } from '../answers/types.js';
 import { CoupleError, type CoupleStateResponse } from './types.js';
 
 interface ProfileRecord extends QueryResultRow {
@@ -77,6 +78,60 @@ async function profileForUpdate(client: PoolClient, userId: string): Promise<{ c
   return profile;
 }
 
+/**
+ * A user answering solo banks each answer with couple_id NULL ("sealed"). Once
+ * pairing reaches two members, every sealed answer belonging to either member is
+ * claimed into the couple, and any question both members now have an answer for
+ * gets its match computed and upserted, reusing the same match-type rules the
+ * live answer flow uses. This only runs from join(), the one place membership can
+ * go from one to two, so it only ever fires once per couple.
+ */
+async function claimSealedAnswers(client: PoolClient, coupleId: string): Promise<void> {
+  await client.query(
+    `update responses set couple_id = $1
+       where couple_id is null and user_id in (select id from profiles where couple_id = $1)`,
+    [coupleId],
+  );
+
+  const pairs = await client.query<{
+    question_id: string;
+    question_type: string;
+    a_user: string;
+    a_answer: Answer;
+    a_data: Record<string, unknown> | null;
+    b_user: string;
+    b_answer: Answer;
+    b_data: Record<string, unknown> | null;
+  }>(
+    `select r1.question_id, q.question_type,
+            r1.user_id a_user, r1.answer a_answer, r1.response_data a_data,
+            r2.user_id b_user, r2.answer b_answer, r2.response_data b_data
+       from responses r1
+       join responses r2 on r2.question_id = r1.question_id and r2.couple_id = r1.couple_id and r2.user_id > r1.user_id
+       join questions q on q.id = r1.question_id
+      where r1.couple_id = $1`,
+    [coupleId],
+  );
+
+  for (const pair of pairs.rows) {
+    const matchType = calculateMatchType({ id: pair.question_id, question_type: pair.question_type as never }, pair.a_answer, pair.b_answer);
+    if (!matchType) {
+      await client.query('delete from matches where couple_id = $1 and question_id = $2', [coupleId, pair.question_id]);
+      continue;
+    }
+    const responseSummary = matchType === 'both_answered'
+      ? { [pair.a_user]: pair.a_data, [pair.b_user]: pair.b_data }
+      : null;
+    await client.query(
+      `insert into matches(couple_id, question_id, match_type, is_new, response_summary)
+       values($1, $2, $3, true, $4)
+       on conflict(couple_id, question_id) do update set
+         match_type = excluded.match_type, response_summary = excluded.response_summary, is_new = true`,
+      [coupleId, pair.question_id, matchType, responseSummary],
+    );
+  }
+}
+
 async function transaction<T>(pool: Pool, work: (client: PoolClient) => Promise<T>): Promise<T> {
   const client = await pool.connect();
   try {
@@ -111,7 +166,8 @@ export class PostgresCoupleRepository implements CoupleRepository {
     if (!profile) {
       throw new CoupleError('profile_not_found', 'Profile not found. Please complete signup first.', 404);
     }
-    if (!profile.couple_id) return { couple: null, partner: null };
+    const sealedCount = await this.sealedCount(userId);
+    if (!profile.couple_id) return { couple: null, partner: null, sealed_count: sealedCount };
 
     const [coupleResult, partnerResult] = await Promise.all([
       this.pool.query<CoupleRecord>(
@@ -129,13 +185,22 @@ export class PostgresCoupleRepository implements CoupleRepository {
       ),
     ]);
     const couple = coupleResult.rows[0];
-    if (!couple) return { couple: null, partner: null };
+    if (!couple) return { couple: null, partner: null, sealed_count: sealedCount };
     return {
       couple: toCouple(couple),
       partner: partnerResult.rows[0] ? toProfile(partnerResult.rows[0]) : null,
+      sealed_count: sealedCount,
     };
   }
 
+  private async sealedCount(userId: string): Promise<number> {
+    const result = await this.pool.query<{ count: number }>(
+      'select count(*)::int count from responses where user_id = $1 and couple_id is null',
+      [userId],
+    );
+    return result.rows[0]?.count ?? 0;
+  }
+
   async create(userId: string, coupleId: string, inviteCode: string): Promise<Couple> {
     return transaction(this.pool, async (client) => {
       const profile = await profileForUpdate(client, userId);
@@ -183,6 +248,7 @@ export class PostgresCoupleRepository implements CoupleRepository {
       }
 
       await client.query('update profiles set couple_id = $1, updated_at = now() where id = $2', [couple.id, userId]);
+      await claimSealedAnswers(client, couple.id);
       return toCouple(couple);
     });
   }

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

@@ -3,6 +3,8 @@ import type { Couple, Profile } from '@sauci/shared';
 export interface CoupleStateResponse {
   couple: Couple | null;
   partner: Profile | null;
+  /** Count of this user's banked answers with no couple yet (couple_id IS NULL). */
+  sealed_count: number;
 }
 
 export interface CoupleMutationResponse {

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

@@ -132,9 +132,14 @@ export class PostgresOperationsRepository implements OperationsRepository {
            and exists(select 1 from responses r where r.couple_id=p.couple_id and r.created_at>$1::timestamptz-interval '7 days')
          group by p.id on conflict(dedupe_key) do nothing`, [now]);
 
+      // Sealed answers are the earned-value hook for the nudge: a solo answerer who
+      // has already banked answers gets told what pairing unlocks for them, instead
+      // of the generic invite copy that applies before they have answered anything.
       const unpaired=await client.query(
         `with eligible as (
-           select p.id,p.couple_id is not null has_invite from profiles p left join notification_preferences np on np.user_id=p.id
+           select p.id,p.couple_id is not null has_invite,
+             (select count(*)::int from responses r where r.user_id=p.id and r.couple_id is null) sealed_count
+           from profiles p left join notification_preferences np on np.user_id=p.id
            where extract(hour from $1::timestamptz)>=18 and p.push_token is not null
              and (p.couple_id is null or (select count(*) from profiles member where member.couple_id=p.couple_id)<2)
              and coalesce(np.unpaired_reminders_enabled,true)
@@ -143,10 +148,11 @@ export class PostgresOperationsRepository implements OperationsRepository {
          ), queued as (
            insert into operations_outbox(kind,dedupe_key,recipient_id,payload)
            select 'expo','unpaired:'||to_char($1::timestamptz,'YYYY-MM-DD')||':'||e.id,e.id,
-             jsonb_build_object('title','Sauci','body',case when e.has_invite
-               then 'Your invite code is waiting! Share it with your partner to start discovering what you have in common.'
+             jsonb_build_object('title','Sauci','body',case
+               when e.sealed_count>0 then 'You have '||e.sealed_count||' sealed answer'||(case when e.sealed_count=1 then '' else 's' end)||' waiting. Invite your partner to unlock what you said about them.'
+               when e.has_invite then 'Your invite code is waiting! Share it with your partner to start discovering what you have in common.'
                else 'Ready to get started? Create an invite code and share it with your partner!' end,
-               'data',jsonb_build_object('type','unpaired_reminder'))
+               'data',jsonb_build_object('type','unpaired_reminder','sealed_count',e.sealed_count))
            from eligible e on conflict(dedupe_key) do nothing returning recipient_id
          ) update profiles p set last_unpaired_reminder_at=$1 from queued q where p.id=q.recipient_id returning p.id`, [now,limit]);
 

apps/api/src/domains/packs/schema.ts

@@ -61,7 +61,9 @@ export const responses = pgTable('responses', {
   id: uuid('id').primaryKey(),
   userId: uuid('user_id').notNull().references(() => profiles.id, { onDelete: 'cascade' }),
   questionId: uuid('question_id').notNull().references(() => questions.id, { onDelete: 'cascade' }),
-  coupleId: uuid('couple_id').notNull().references(() => couples.id, { onDelete: 'cascade' }),
+  // Nullable: an unpaired user's answer is banked as a sealed answer with no couple
+  // yet. It is claimed into the couple at pairing time; see the answers repository.
+  coupleId: uuid('couple_id').references(() => couples.id, { onDelete: 'cascade' }),
   answer: text('answer').notNull(),
   responseData: jsonb('response_data'),
   createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),