Sync public snapshot from freebuff-private

Source: CodebuffAI/freebuff-private@f7245a9477879db1065330cd04d013dc40170ae0

Author: github-actions[bot]

bun.lock

@@ -796,7 +796,7 @@ describe('FreebuffModelSelector plan line', () => {
     const frame = (await renderSelector()).captureCharFrame()
     expect(frame).toContain('STARTER PLAN')
     expect(frame).toContain('today 1.3 of 2')
-    expect(frame).toContain('5-day 3 of 6')
+    expect(frame).toContain('week 3 of 6')
     expect(frame).toContain('month 11 of 50')
   })
 

cli/src/components/__tests__/freebuff-model-selector.test.tsx

@@ -813,6 +813,14 @@ export const FreebuffLandingScreen: React.FC<FreebuffLandingScreenProps> = ({
                 </span>
                 . Press Ctrl+C to exit.
               </text>
+              {/* The paywall half (2026-09-01): the server's structured hint
+                  when it sent one, the plans page otherwise — a quota wall is
+                  never a dead end. */}
+              <text style={{ fg: theme.muted, wrapMode: 'word', marginTop: 1 }}>
+                {'upgrade' in session && session.upgrade
+                  ? `${session.upgrade.message} ${session.upgrade.url}`
+                  : 'Get more sessions with a plan: https://freebuff.com/plans'}
+              </text>
             </>
           )}
 
@@ -832,6 +840,11 @@ export const FreebuffLandingScreen: React.FC<FreebuffLandingScreenProps> = ({
                 {' — '}your free usage resets automatically at midnight Pacific.
                 Press Ctrl+C to exit.
               </text>
+              <text style={{ fg: theme.muted, wrapMode: 'word', marginTop: 1 }}>
+                {'upgrade' in session && session.upgrade
+                  ? `${session.upgrade.message} ${session.upgrade.url}`
+                  : 'Get more sessions with a plan: https://freebuff.com/plans'}
+              </text>
             </>
           )}
 

cli/src/components/freebuff-landing-screen.tsx

@@ -182,16 +182,18 @@ describe('elevated countries', () => {
     expect(result.usd).toBeLessThan(FREEBUFF_REGION_DAILY_SPEND_USD.full)
   })
 
-  it('does not cut a LIVE session — no hard cap, like the region ceilings', () => {
-    // The whole point of $5 rather than $0.50 is that it is a budget, not a
-    // suspicion. Applying the 2x hard cut here would interrupt an ordinary
-    // Singaporean developer mid-thought, which is the error this tier exists
-    // to stop making.
+  it('cuts a LIVE session only past the leeway multiplier', () => {
+    // Reversed 2026-08-31 when the elevated ceiling dropped $5 → $1: at one
+    // dollar, overshoot is no longer proportionally small, and the multiplier
+    // is what grants an open session leeway to finish before the hard cut.
     const ceiling = resolveFreebuffSpendCeiling({
       accessTier: 'full',
       countryCode: 'SG',
     })
-    expect(resolveFreebuffHardSpendCeiling(ceiling)).toBeNull()
+    expect(ceiling.usd).toBe(FREEBUFF_ELEVATED_DAILY_SPEND_USD)
+    expect(resolveFreebuffHardSpendCeiling(ceiling, 1.25)).toBeCloseTo(
+      FREEBUFF_ELEVATED_DAILY_SPEND_USD * 1.25,
+    )
   })
 
   it('still loses to a restricted cohort the account is also in', () => {
@@ -207,11 +209,13 @@ describe('elevated countries', () => {
   })
 
   it('resolves a tie with the region ceiling to `region`', () => {
-    // A limited-tier account in an elevated country sees $5 from both rules.
-    // The tie must land on the reason that implies nothing about the account.
+    // The defaults no longer tie ($1 elevated vs $5 limited region), so the
+    // tie is constructed with overrides — the RULE still has to hold: a tie
+    // lands on the reason that implies nothing about the account.
     const result = resolveFreebuffSpendCeiling({
       accessTier: 'limited',
       countryCode: 'SG',
+      overrides: { elevatedUsd: 5 },
     })
     expect(result.usd).toBe(5)
     expect(result.reason).toBe('region')
@@ -286,3 +290,84 @@ describe('refusal copy', () => {
     }
   })
 })
+
+describe('paid-plan daily floors (2026-08-31)', () => {
+  // The cohort ceilings were sized for free usage; 11 live subscribers were
+  // spend-refused in the 48h before this shipped, three of them at thirty
+  // cents a day against an $8/month plan. A floor, not an exemption: the
+  // plan's monthly spend cap remains the money bound.
+  it('floors a limited-region subscriber at $3 when the region ceiling dips below', () => {
+    // The code-default limited region ($5) already exceeds the $3 floor; the
+    // floor binds when env tuning takes the region lower — as prod does.
+    const result = resolveFreebuffSpendCeiling({
+      accessTier: 'limited',
+      hasPaidSubscription: true,
+      overrides: { regionUsd: { limited: 1 } },
+    })
+    expect(result.usd).toBe(3)
+    expect(result.reason).toBe('region')
+  })
+
+  it('floors a full-region subscriber at $7', () => {
+    const result = resolveFreebuffSpendCeiling({
+      accessTier: 'full',
+      hasPaidSubscription: true,
+      overrides: { regionUsd: { full: 5 } },
+    })
+    expect(result.usd).toBe(7)
+  })
+
+  it('floors the restricted cohorts too — a card is the realness signal', () => {
+    for (const input of [
+      { privacyEgress: true },
+      { countryCode: 'CN' },
+      { flaggedEmailDomain: true },
+      { unverifiedEgress: true },
+    ]) {
+      const result = resolveFreebuffSpendCeiling({
+        accessTier: 'limited',
+        hasPaidSubscription: true,
+        ...input,
+      })
+      expect(result.usd).toBe(3)
+    }
+  })
+
+  it('never LOWERS a ceiling that already exceeds the floor', () => {
+    const result = resolveFreebuffSpendCeiling({
+      accessTier: 'full',
+      hasPaidSubscription: true,
+    })
+    // Region default $15 > the $7 floor: the higher number survives.
+    expect(result.usd).toBe(FREEBUFF_REGION_DAILY_SPEND_USD.full)
+    expect(result.reason).toBe('region')
+  })
+
+  it('does NOT floor third_party_client — the reseller cohort', () => {
+    const result = resolveFreebuffSpendCeiling({
+      accessTier: 'full',
+      thirdPartyClient: true,
+      hasPaidSubscription: true,
+    })
+    expect(result.usd).toBe(FREEBUFF_RESTRICTED_DAILY_SPEND_USD)
+    expect(result.reason).toBe('third_party_client')
+  })
+
+  it('keeps naming the floored cohort as the reason', () => {
+    const result = resolveFreebuffSpendCeiling({
+      accessTier: 'limited',
+      countryCode: 'CN',
+      hasPaidSubscription: true,
+    })
+    expect(result.usd).toBe(3)
+    expect(result.reason).toBe('restricted_country')
+  })
+
+  it('a free account is untouched by the floor machinery', () => {
+    const result = resolveFreebuffSpendCeiling({
+      accessTier: 'limited',
+      countryCode: 'CN',
+    })
+    expect(result.usd).toBe(FREEBUFF_RESTRICTED_DAILY_SPEND_USD)
+  })
+})

common/src/__tests__/freebuff-spend-ceilings.test.ts

@@ -119,12 +119,14 @@ export const FREEBUFF_RESTRICTED_COUNTRIES: readonly string[] = ['CN']
  * `flaggedEmailDomain` instead. Catching it there is what makes this tier
  * affordable.
  *
- * $5 and not $15: SG remains a top VPN and datacenter exit, so the tail this
- * bounds is real even with the farm named. Five dollars is the same figure a
- * limited-region account gets — enough for a full day's ordinary work, still a
- * bound — and deliberately not a number that has to be defended per-country.
+ * $1 as of 2026-08-31 (operator decision; was $5 from 2026-08-15): the tail
+ * kept growing and the farm-domain pricing did not shrink it enough. One
+ * dollar still buys a normal day of ordinary sessions, and unlike the
+ * restricted tier it now carries the live-session leeway multiplier below —
+ * at this size, letting an open session run to 1.25x and then cutting is the
+ * bound that matters, exactly the reasoning the restricted ceilings use.
  */
-export const FREEBUFF_ELEVATED_DAILY_SPEND_USD = 5
+export const FREEBUFF_ELEVATED_DAILY_SPEND_USD = 1
 
 /**
  * Countries held at the elevated ceiling.
@@ -308,18 +310,63 @@ export function freebuffSessionSpendNotice(verdict: {
  */
 export const FREEBUFF_SPEND_CEILING_HARD_MULTIPLIER = 2
 
+/**
+ * Daily-spend FLOORS for accounts holding a live paid plan (2026-08-31).
+ *
+ * The cohort ceilings above were sized for free usage, and until this floor a
+ * paying customer inherited them unchanged: measured over the 48h before it
+ * shipped, 11 live subscribers were spend-refused — six limited-region
+ * Starters at the $3 region ceiling they had paid to escape, three in a
+ * restricted country at thirty cents a day against an $8/month plan.
+ *
+ * A floor, not an exemption: the plan's own monthly spend cap remains the
+ * money bound, and a stolen card should still not buy unbounded daily burn.
+ * Composed as max() AFTER the cohort minimum, so it can only ever RAISE a
+ * paying account's ceiling, never lower one — a full-region paid account whose
+ * cohort maths already exceeds the floor keeps the higher number.
+ *
+ * Full access floors higher than everyone else ($7 vs $3) on the operator's
+ * explicit split: paid limited-region and paid suspicious-cohort accounts go
+ * to $3. `third_party_client` is deliberately NOT floored — an account
+ * observed sending a foreign toolset while paying is the reseller pattern
+ * (see freebuff2api), and the one cohort where a card is evidence of a
+ * business model rather than a person.
+ */
+export const FREEBUFF_PAID_DAILY_SPEND_FLOOR_USD: Record<
+  FreebuffAccessTier,
+  number
+> = {
+  full: 7,
+  limited: 3,
+}
+
+/** The reasons a paid floor may override. Everything except the reseller
+ *  cohort — see FREEBUFF_PAID_DAILY_SPEND_FLOOR_USD. */
+const PAID_FLOOR_REASONS: ReadonlySet<string> = new Set([
+  'region',
+  'elevated_country',
+  'restricted_country',
+  'privacy_egress',
+  'flagged_email_domain',
+  'unverified_egress',
+  'trust_level',
+])
+
 /**
  * Reasons whose ceiling is small enough that the hard multiplier applies.
  *
- * `region`, `elevated_country` and `trust_level` are excluded: all three are
- * whole-population limits where the fresh-admission gate is proportionate, and
- * applying a hard cut there would interrupt ordinary paying-in-attention users
- * mid-thought. `elevated_country` sits at the same $5 as a limited-region
- * account precisely so it can be reasoned about as a region ceiling rather
- * than as a suspicion, and cutting it live would undo that.
+ * `region` and `trust_level` are excluded: whole-population limits where the
+ * fresh-admission gate is proportionate, and applying a hard cut there would
+ * interrupt ordinary paying-in-attention users mid-thought.
+ *
+ * `elevated_country` JOINED this set on 2026-08-31 when its ceiling dropped
+ * $5 → $1: at one dollar, overshoot is no longer proportionally small, and
+ * the multiplier is what grants an open session leeway to finish before the
+ * hard cut — the same trade the restricted ceilings make.
  */
 const HARD_CAPPED_REASONS: ReadonlySet<string> = new Set([
   'restricted_country',
+  'elevated_country',
   'privacy_egress',
   'flagged_email_domain',
   'third_party_client',
@@ -391,12 +438,20 @@ export interface FreebuffSpendCeilingInput {
   /** The trust matrix's ceiling, when that rollout is enforcing. */
   trustLevelCeilingUsd?: number | null
   /** Overrides, all optional so a missing env var changes nothing. */
+  /**
+   * True when the account holds a live paid plan (Postgres-entitling row —
+   * never a mirror; see the coercion rule in triggerGates). Resolved LAZILY
+   * by the caller, only when the cohort ceiling would refuse: the ordinary
+   * request must not pay a subscription read to learn a ceiling it is under.
+   */
+  hasPaidSubscription?: boolean
   overrides?: {
     regionUsd?: Partial<Record<FreebuffAccessTier, number>>
     restrictedUsd?: number
     restrictedCountries?: readonly string[]
     elevatedUsd?: number
     elevatedCountries?: readonly string[]
+    paidFloorUsd?: Partial<Record<FreebuffAccessTier, number>>
   }
 }
 
@@ -462,6 +517,18 @@ export function resolveFreebuffSpendCeiling(
     if (candidate.usd < winner.usd) winner = candidate
   }
 
+  // The paid floor, AFTER the minimum: it may only raise. The reason keeps
+  // naming the cohort that was floored — a support question about a paid
+  // account still deserves the one-word answer for why it isn't higher.
+  if (input.hasPaidSubscription && PAID_FLOOR_REASONS.has(winner.reason)) {
+    const floor =
+      input.overrides?.paidFloorUsd?.[input.accessTier] ??
+      FREEBUFF_PAID_DAILY_SPEND_FLOOR_USD[input.accessTier]
+    if (typeof floor === 'number' && floor > winner.usd) {
+      return { usd: floor, reason: winner.reason, applied }
+    }
+  }
+
   return { usd: winner.usd, reason: winner.reason, applied }
 }