Fix the ₹0-collected class of read (D1 100-parameter cap) and feed the empty team screens

docs/STAGING_DEPLOY.md

@@ -76,6 +76,19 @@ npx wrangler d1 execute pawspace-staging --remote --file=scripts/staging-seed.sq
 After loading, open `/team/acquisition-funnel` and hit **Refresh sweep** to compute funnel stages, ₹300
 recoveries and App-Inbound leads from the seeded data — instant material for the CRM/Sales test.
 
+**Then load the team demo pack** so the internal surfaces are not blank. It adds the sales team the
+performance leaderboard measures (4 reps mapped to `sales`, 27 leads with SLA clocks, recorded calls
+and conversions into the seeded bookings, an active productivity policy) and the governed campaign
+command centre (a live campaign with its audience snapshot and holdout, one awaiting approval, and ad
+spend rows for the CAC line). Idempotent, and it reuses the customers and bookings above, so load it
+second:
+```bash
+npx wrangler d1 execute pawspace-staging --remote --file=scripts/uat-demo-seed.sql
+```
+(Regenerate with `node scripts/uat-demo-seed-gen.mjs`.) Then open `/team/performance` and press
+**Generate 30-day report** — one click turns the seeded lead work into a ranked leaderboard, which is
+also the check that the whole policy → run → board pipeline is live.
+
 **Best option — MASKED REAL data** (the actual 4-year book, safe for staging). Run the importer against
 `The_PawSpace_TRUTH.xlsx` locally (the workbook and the generated SQL contain customer data — never
 commit either; keep them off shared drives):

lib/accounts-business-view.ts

@@ -1,3 +1,4 @@
+import { chunkedIn } from "./d1-chunked-in";
 type Db = D1Database;
 type Row = Record<string, unknown>;
 
@@ -43,10 +44,9 @@ export async function buildAccountsBusinessView(db: Db) {
   const bookingIds = bookings.map(b => String(b.id));
   let invoices: Row[] = [], payments: Row[] = [];
   if (bookingIds.length) {
-    const placeholders = bookingIds.map(() => "?").join(",");
     [invoices, payments] = await Promise.all([
-      safeAll(db, `SELECT id,booking_id,customer_id,invoice_number,status,gross_amount,tax_amount,net_amount,issued_at FROM booking_invoices WHERE booking_id IN (${placeholders})`, bookingIds),
-      safeAll(db, `SELECT booking_id,amount,status,method FROM booking_payments WHERE booking_id IN (${placeholders})`, bookingIds),
+      chunkedIn(bookingIds, (chunk, placeholders) => safeAll(db, `SELECT id,booking_id,customer_id,invoice_number,status,gross_amount,tax_amount,net_amount,issued_at FROM booking_invoices WHERE booking_id IN (${placeholders})`, chunk)),
+      chunkedIn(bookingIds, (chunk, placeholders) => safeAll(db, `SELECT booking_id,amount,status,method FROM booking_payments WHERE booking_id IN (${placeholders})`, chunk)),
     ]);
   }
   const invoiceByBooking = new Map(invoices.map(i => [String(i.booking_id), i]));

lib/company-analytics.ts

@@ -1,9 +1,10 @@
 import { attributeGroomingBookingCosts } from "./grooming-cost-attribution";
+import{chunkedIn}from"./d1-chunked-in";
 
 type Row=Record<string,unknown>;
 const rows=<T=Row>(r:{results?:unknown[]})=>(r.results||[]) as T[];
 async function safeAll(db:D1Database,sql:string,binds:unknown[]=[]){try{let q=db.prepare(sql);if(binds.length)q=q.bind(...binds);return rows(await q.all<Row>());}catch{return [] as Row[];}}
-export async function buildCompanyAnalytics(db:D1Database,input:{from?:string;to?:string;serviceCode?:string;zoneId?:string}={}){const from=input.from||"1970-01-01",to=input.to||"2999-12-31",filters:string[]=["scheduled_start>=?","scheduled_start<?"],binds:unknown[]=[from,to];if(input.serviceCode){filters.push("service_code=?");binds.push(input.serviceCode);}if(input.zoneId){filters.push("zone_id=?");binds.push(input.zoneId);}const where=filters.join(" AND ");const bookings=await safeAll(db,`SELECT id,customer_id,service_code,package_code,zone_id,provider_id,status,total_amount,currency,scheduled_start,scheduled_end FROM canonical_bookings WHERE ${where}`,binds);const ids=bookings.map(item=>String(item.id));let payments:Row[]=[],tickets:Row[]=[];if(ids.length){const placeholders=ids.map(()=>"?").join(",");payments=await safeAll(db,`SELECT booking_id,amount,status,gateway FROM booking_payments WHERE booking_id IN (${placeholders})`,ids);tickets=await safeAll(db,`SELECT booking_id,category,priority,status,created_at,resolved_at,reopened_count FROM customer_experience_tickets WHERE booking_id IN (${placeholders})`,ids);}const providers=await safeAll(db,"SELECT id,provider_model,status,live,quality_score,rating FROM provider_capacity_profiles");const paymentByBooking=new Map(payments.map(p=>[String(p.booking_id),p]));const completed=bookings.filter(b=>String(b.status)==="completed"),cancelled=bookings.filter(b=>String(b.status)==="cancelled"),collected=bookings.reduce((s,b)=>{const p=paymentByBooking.get(String(b.id));return s+(p&&["captured","paid"].includes(String(p.status))?Number(p.amount||0):0)},0);
+export async function buildCompanyAnalytics(db:D1Database,input:{from?:string;to?:string;serviceCode?:string;zoneId?:string}={}){const from=input.from||"1970-01-01",to=input.to||"2999-12-31",filters:string[]=["scheduled_start>=?","scheduled_start<?"],binds:unknown[]=[from,to];if(input.serviceCode){filters.push("service_code=?");binds.push(input.serviceCode);}if(input.zoneId){filters.push("zone_id=?");binds.push(input.zoneId);}const where=filters.join(" AND ");const bookings=await safeAll(db,`SELECT id,customer_id,service_code,package_code,zone_id,provider_id,status,total_amount,currency,scheduled_start,scheduled_end FROM canonical_bookings WHERE ${where}`,binds);const ids=bookings.map(item=>String(item.id));let payments:Row[]=[],tickets:Row[]=[];if(ids.length){payments=await chunkedIn(ids,(chunk,placeholders)=>safeAll(db,`SELECT booking_id,amount,status,gateway FROM booking_payments WHERE booking_id IN (${placeholders})`,chunk));tickets=await chunkedIn(ids,(chunk,placeholders)=>safeAll(db,`SELECT booking_id,category,priority,status,created_at,resolved_at,reopened_count FROM customer_experience_tickets WHERE booking_id IN (${placeholders})`,chunk));}const providers=await safeAll(db,"SELECT id,provider_model,status,live,quality_score,rating FROM provider_capacity_profiles");const paymentByBooking=new Map(payments.map(p=>[String(p.booking_id),p]));const completed=bookings.filter(b=>String(b.status)==="completed"),cancelled=bookings.filter(b=>String(b.status)==="cancelled"),collected=bookings.reduce((s,b)=>{const p=paymentByBooking.get(String(b.id));return s+(p&&["captured","paid"].includes(String(p.status))?Number(p.amount||0):0)},0);
   // GMV recognizes the same bookings as the P&L (lib/pnl-reporting.ts): cancelled and draft
   // bookings carry a total_amount but no recognizable revenue, so counting them silently
   // inflated GMV above the P&L turnover for the identical period.

lib/customer-360.ts

@@ -1,3 +1,4 @@
+import{chunkedIn}from"./d1-chunked-in";
 type Db=D1Database;
 type Row=Record<string,unknown>;
 export type Customer360Record={customerId:string;name:string;primaryPhone:string;email:string|null;area:string|null;crmStage:string;owner:string;source:string;consent:{marketing:boolean;service:boolean;whatsapp:boolean;sms:boolean;email:boolean;updatedAt:number|null};addresses:Array<{id:string;label:string;line1:string;line2:string|null;area:string|null;city:string;postalCode:string|null;isDefault:boolean}>;pets:Array<{id:string;name:string;species:string;breed:string|null;vaccinationStatus:string}>;bookings:Array<{id:string;serviceCode:string;packageName:string;status:string;scheduledStart:string;scheduledEnd:string;totalAmount:number;currency:string}>;coupons:Array<{id:string;code:string;bookingId:string|null;discountAmount:number;status:string;createdAt:number}>;supportCases:Array<{id:string;caseType:string;severity:string;status:string;title:string;updatedAt:number}>;tickets:Array<{id:string;category:string;priority:string;status:string;subject:string;updatedAt:number}>;lifetimeValue:number;lastServiceAt:string|null;openTicketCount:number;dataQuality:{score:number;issues:string[];duplicateCandidateIds:string[]}};
@@ -21,14 +22,13 @@ const selectedIds=selected.map(([id])=>id);
 // D1's ~100 bound-parameter ceiling while cutting round trips by a third: 500 customers cost 7
 // chunks x 8 reads instead of 10 x 8. Sized to satisfy the call BUDGET asserted by
 // tests/customer-360-fanout.test.mjs - a chunk of 50 exceeded it at 82 calls for 500 customers.
-const ID_CHUNK=80;
 async function groupedByCustomer(sqlFor:(placeholders:string)=>string,key='customer_id'){
  const grouped=new Map<string,Row[]>();
- for(let index=0;index<selectedIds.length;index+=ID_CHUNK){
-  const slice=selectedIds.slice(index,index+ID_CHUNK);
-  for(const row of await safeAll(db,sqlFor(slice.map(()=>'?').join(',')),slice)){
-   const owner=String(row[key]??'');const list=grouped.get(owner)??[];list.push(row);grouped.set(owner,list);
-  }
+ // One chunk size for the whole platform (lib/d1-chunked-in.ts). It used to be declared here as 80
+ // and again as 50 inside lib/unit-economics.ts, which is how the same class of bug came back at a
+ // different size in a different module.
+ for(const row of await chunkedIn(selectedIds,(slice,placeholders)=>safeAll(db,sqlFor(placeholders),slice))){
+  const owner=String(row[key]??'');const list=grouped.get(owner)??[];list.push(row);grouped.set(owner,list);
  }
  return grouped;
 }

lib/customer-business-view.ts

@@ -1,4 +1,5 @@
 import { buildCustomer360 } from "./customer-360";
+import { chunkedIn } from "./d1-chunked-in";
 
 type Db = D1Database;
 type Row = Record<string, unknown>;
@@ -25,16 +26,15 @@ export async function buildCustomerBusinessView(db: Db, customerId?: string): Pr
   const records = await buildCustomer360(db, customerId);
   if (!records.length) return [];
   const ids = records.map(r => r.customerId);
-  const placeholders = ids.map(() => "?").join(",");
   let activeSubByCustomer = new Map<string, number>();
   let createdAtByCustomer = new Map<string, number>();
   try {
-    const subs = await db.prepare(`SELECT customer_id,MIN(expires_at) nearest_expiry FROM customer_grooming_subscriptions WHERE customer_id IN (${placeholders}) AND status='active' GROUP BY customer_id`).bind(...ids).all<Row>();
-    activeSubByCustomer = new Map(subs.results.map(row => [String(row.customer_id), Number(row.nearest_expiry)]));
+    const subs = await chunkedIn(ids, async (chunk, placeholders) => (await db.prepare(`SELECT customer_id,MIN(expires_at) nearest_expiry FROM customer_grooming_subscriptions WHERE customer_id IN (${placeholders}) AND status='active' GROUP BY customer_id`).bind(...chunk).all<Row>()).results);
+    activeSubByCustomer = new Map(subs.map(row => [String(row.customer_id), Number(row.nearest_expiry)]));
   } catch { /* table may not exist yet in some environments */ }
   try {
-    const created = await db.prepare(`SELECT id,created_at FROM canonical_customers WHERE id IN (${placeholders})`).bind(...ids).all<Row>();
-    createdAtByCustomer = new Map(created.results.map(row => [String(row.id), Number(row.created_at)]));
+    const created = await chunkedIn(ids, async (chunk, placeholders) => (await db.prepare(`SELECT id,created_at FROM canonical_customers WHERE id IN (${placeholders})`).bind(...chunk).all<Row>()).results);
+    createdAtByCustomer = new Map(created.map(row => [String(row.id), Number(row.created_at)]));
   } catch { /* table may not exist yet in some environments */ }
   const now = Date.now(), day = 86_400_000;
   return records.map(r => {

lib/d1-chunked-in.ts

@@ -0,0 +1,36 @@
+/**
+ * D1 caps a single query at 100 bound parameters. A `WHERE id IN (?,?,...)` built from a result set
+ * therefore works in every test fixture and every young environment, then starts failing the moment
+ * real volume arrives - and because these reads are wrapped in swallow-and-continue helpers, the
+ * failure surfaces as a confident zero rather than an error.
+ *
+ * Staging showed exactly that: /team/analytics reported 331 bookings and GMV of Rs 3,24,472 next to
+ * "Collected Rs 0" on every single service line, because the payments read for those 331 bookings
+ * asked D1 for 331 bound parameters and was discarded.
+ *
+ * Every IN-list read over an unbounded set goes through here: the ids are split into chunks that fit
+ * inside the cap and the chunk results are concatenated, so the answer is identical to the one the
+ * single query was meant to give.
+ */
+export const D1_IN_CHUNK = 80;
+
+export function idChunks<T>(ids: readonly T[], size = D1_IN_CHUNK): T[][] {
+  if (size < 1) throw new Error("Chunk size must be at least 1");
+  const chunks: T[][] = [];
+  for (let index = 0; index < ids.length; index += size) chunks.push(ids.slice(index, index + size));
+  return chunks;
+}
+
+/**
+ * Runs `read` once per chunk and concatenates the rows. `read` receives the chunk plus the matching
+ * `?,?,...` placeholder string, so call sites keep their own SQL, bindings and error handling.
+ */
+export async function chunkedIn<T, R>(
+  ids: readonly T[],
+  read: (chunk: T[], placeholders: string) => Promise<R[]>,
+  size = D1_IN_CHUNK,
+): Promise<R[]> {
+  if (!ids.length) return [];
+  const results = await Promise.all(idChunks(ids, size).map((chunk) => read(chunk, chunk.map(() => "?").join(","))));
+  return results.flat();
+}

lib/grooming-cost-attribution.ts

@@ -1,4 +1,5 @@
 import { computeGroomerMonthlyIncentive } from "./grooming-incentive-engine";
+import { chunkedIn } from "./d1-chunked-in";
 
 type Db = D1Database;
 type Row = Record<string, unknown>;
@@ -25,10 +26,9 @@ type Row = Record<string, unknown>;
 export async function attributeGroomingBookingCosts(db: Db, bookingIds: string[]): Promise<Map<string, number | null>> {
   const result = new Map<string, number | null>();
   if (!bookingIds.length) return result;
-  const placeholders = bookingIds.map(() => "?").join(",");
-  const rows = await db.prepare(
+  const rows = { results: await chunkedIn(bookingIds, async (chunk, placeholders) => (await db.prepare(
     `SELECT id,provider_id,total_amount,scheduled_start FROM canonical_bookings WHERE id IN (${placeholders}) AND service_code='grooming' AND status='completed'`
-  ).bind(...bookingIds).all<Row>();
+  ).bind(...chunk).all<Row>()).results) };
 
   const groups = new Map<string, { headGroomerId: string; monthStart: string; bookings: Array<{ id: string; amount: number }> }>();
   for (const row of rows.results) {

lib/manager-dashboard.ts

@@ -3,6 +3,7 @@ import { currentGroomerBracket, computeGroomerMonthlyIncentive } from "./groomin
 import { computeTrainerMonthlyIncentive } from "./trainer-incentive-engine";
 import { dailyClosureReadiness } from "./rep-daily-closure-governance";
 import { dailyTalkTimeSummary } from "./talk-time-governance";
+import{chunkedIn}from"./d1-chunked-in";
 
 type Db=D1Database;
 type Row=Record<string,unknown>;
@@ -34,9 +35,8 @@ async function employeesInScope(db:Db,scope:Scope){
     return rows.results;
   }
   if(!scope.employeeEmails.length)return[];
-  const placeholders=scope.employeeEmails.map(()=>"?").join(",");
-  const rows=await db.prepare(`SELECT e.id,e.work_email,e.user_email,e.display_name,v.title,v.team_code FROM employees e JOIN employee_employment_versions v ON v.employee_id=e.id AND v.effective_until IS NULL WHERE lower(COALESCE(e.user_email,e.work_email)) IN (${placeholders}) ORDER BY e.display_name`).bind(...scope.employeeEmails).all<Row>();
-  return rows.results;
+  return chunkedIn(scope.employeeEmails,async(chunk,placeholders)=>(await db.prepare(`SELECT e.id,e.work_email,e.user_email,e.display_name,v.title,v.team_code FROM employees e JOIN employee_employment_versions v ON v.employee_id=e.id AND v.effective_until IS NULL WHERE lower(COALESCE(e.user_email,e.work_email)) IN (${placeholders}) ORDER BY e.display_name`).bind(...chunk).all<Row>()).results);
+
 }
 
 /**

lib/partner-job-feed.ts

@@ -1,3 +1,4 @@
+import{chunkedIn}from"./d1-chunked-in";
 // Partner Job Feed: one unified, chronological feed of a provider's confirmed customer bookings
 // across ALL services, aggregated read-only from the real canonical tables. Founder requirement:
 // "once the booking is done the same info has to be updated in the partner app".
@@ -68,8 +69,7 @@ export async function listProviderJobs(db:Db,providerId:string,now=Date.now()):P
   const customerIds=[...new Set(bookings.map(row=>String(row.customer_id)))].filter(Boolean);
   const nameByCustomer=new Map<string,string>();
   if(customerIds.length){
-    const placeholders=customerIds.map(()=>"?").join(",");
-    for(const row of await safeAll(db,`SELECT id,name FROM canonical_customers WHERE id IN (${placeholders})`,customerIds))nameByCustomer.set(String(row.id),firstName(row.name));
+    for(const row of await chunkedIn(customerIds,(chunk,placeholders)=>safeAll(db,`SELECT id,name FROM canonical_customers WHERE id IN (${placeholders})`,chunk)))nameByCustomer.set(String(row.id),firstName(row.name));
   }
 
   const reference=new Date(now),startOfToday=new Date(reference.getFullYear(),reference.getMonth(),reference.getDate()).getTime(),endOfToday=startOfToday+DAY_MS;