@kylewadegrove/cutline-mcp-cli 0.6.0 → 0.6.1

package/dist/servers/{chunk-IVWF7VYZ.js → chunk-M37M2UA4.js}

@@ -87,8 +87,8 @@ async function identifyTrialUser(attrs) {
       created_at: Math.floor(Date.now() / 1e3)
     });
     console.log(`[Customer.io] Identified trial user: ${attrs.email}`);
-  } catch (error5) {
-    console.error("[Customer.io] Error identifying trial user:", error5);
+  } catch (error6) {
+    console.error("[Customer.io] Error identifying trial user:", error6);
   }
 }
 async function trackTrialEvent(email, event, data) {
@@ -101,8 +101,8 @@ async function trackTrialEvent(email, event, data) {
       data: { ...data, timestamp: Math.floor(Date.now() / 1e3) }
     });
     console.log(`[Customer.io] Tracked ${event} for ${email}`);
-  } catch (error5) {
-    console.error(`[Customer.io] Error tracking ${event}:`, error5);
+  } catch (error6) {
+    console.error(`[Customer.io] Error tracking ${event}:`, error6);
   }
 }
 var rateLimitStore = /* @__PURE__ */ new Map();
@@ -908,8 +908,8 @@ var stripeWebhooks = onRequest4({ cors: true, timeoutSeconds: 30, memory: "512Mi
       await processStripeEvent(event, stripe);
       audit({ eventType: "data.updated", resourceType: "stripe_webhook", resourceId: event.id, data: { type: event.type } });
       res.status(200).json({ success: true });
-    } catch (error5) {
-      console.error(`[Stripe] Webhook handling failed for ${event.type}:`, error5);
+    } catch (error6) {
+      console.error(`[Stripe] Webhook handling failed for ${event.type}:`, error6);
       audit({ eventType: "pipeline.failed", resourceType: "stripe_webhook", resourceId: event.id, success: false, error: "Webhook handling failed", data: { type: event.type } });
       res.status(500).json({ error: "Webhook handling failed" });
     }
@@ -5737,9 +5737,9 @@ Respond as ${personaContext.persona.name} would. Be authentic, specific, and tru
       confidence: parsed.confidence,
       reasoning: parsed.reasoning
     };
-  } catch (error5) {
-    console.error("[persona-agent] Error generating response:", error5);
-    throw new Error(`Failed to generate persona response: ${error5.message}`);
+  } catch (error6) {
+    console.error("[persona-agent] Error generating response:", error6);
+    throw new Error(`Failed to generate persona response: ${error6.message}`);
   }
 }
 
@@ -6602,8 +6602,8 @@ async function identifyVibekitUser(attrs) {
       created_at: Math.floor(Date.now() / 1e3)
     });
     console.log(`[Customer.io] Identified vibekit user: ${attrs.email}`);
-  } catch (error5) {
-    console.error("[Customer.io] Error identifying vibekit user:", error5);
+  } catch (error6) {
+    console.error("[Customer.io] Error identifying vibekit user:", error6);
   }
 }
 async function trackVibekitEvent(email, event, data) {
@@ -6616,8 +6616,8 @@ async function trackVibekitEvent(email, event, data) {
       data: { ...data, timestamp: Math.floor(Date.now() / 1e3) }
     });
     console.log(`[Customer.io] Tracked ${event} for ${email}`);
-  } catch (error5) {
-    console.error(`[Customer.io] Error tracking ${event}:`, error5);
+  } catch (error6) {
+    console.error(`[Customer.io] Error tracking ${event}:`, error6);
   }
 }
 var ALLOWED_ORIGINS = [
@@ -7747,8 +7747,8 @@ Respond conversationally while advancing the discovery. Put structured data in a
       response.artifacts = artifacts;
     }
     return response;
-  } catch (error5) {
-    console.error("[consulting-discovery-agent] Error:", error5);
+  } catch (error6) {
+    console.error("[consulting-discovery-agent] Error:", error6);
     return {
       content: getDegenerateFallback2(context.currentAct, context),
       wasFallback: true
@@ -9504,18 +9504,18 @@ var personaAgent = onRequest17({ cors: true, timeoutSeconds: 60, memory: "512MiB
         confidence: response.confidence,
         reasoning: response.reasoning
       });
-    } catch (error5) {
-      console.error("[persona-agent] Error:", error5);
+    } catch (error6) {
+      console.error("[persona-agent] Error:", error6);
       res.status(500).json({
         error: "Failed to generate persona response",
-        message: error5?.message || "Unknown error"
+        message: error6?.message || "Unknown error"
       });
     }
-  } catch (error5) {
-    console.error("[persona-agent] Request error:", error5);
+  } catch (error6) {
+    console.error("[persona-agent] Request error:", error6);
     res.status(500).json({
       error: "Internal server error",
-      message: error5?.message || "Unknown error"
+      message: error6?.message || "Unknown error"
     });
   }
 });
@@ -9604,18 +9604,18 @@ var mcpGenerateTokenG2 = onCall({ timeoutSeconds: 60 }, async (request) => {
       deviceId,
       email: auth?.token.email
     };
-  } catch (error5) {
+  } catch (error6) {
     logger.error("MCP token generation failed", {
       uid,
       deviceId,
       error: {
-        message: error5.message,
-        code: error5.code
+        message: error6.message,
+        code: error6.code
       }
     });
     audit({ eventType: "security.anomaly", userId: uid, resourceType: "mcp_token", resourceId: deviceId, success: false, error: "Token generation failed" });
-    if (error5 instanceof HttpsError2) {
-      throw error5;
+    if (error6 instanceof HttpsError2) {
+      throw error6;
     }
     throw new HttpsError2("internal", "Failed to generate MCP token");
   }
@@ -9670,13 +9670,13 @@ var mcpSubscriptionStatus = onRequest18({
     };
     logger2.info("Subscription status retrieved", { uid, status: response.status });
     res.json(response);
-  } catch (error5) {
-    logger2.error("Failed to get subscription status", { error: error5.message });
-    if (error5.code === "auth/id-token-expired") {
+  } catch (error6) {
+    logger2.error("Failed to get subscription status", { error: error6.message });
+    if (error6.code === "auth/id-token-expired") {
       res.status(401).json({ error: "Token expired" });
       return;
     }
-    if (error5.code === "auth/argument-error" || error5.code === "auth/invalid-id-token") {
+    if (error6.code === "auth/argument-error" || error6.code === "auth/invalid-id-token") {
       res.status(401).json({ error: "Invalid token" });
       return;
     }
@@ -9716,13 +9716,13 @@ var mcpListProducts = onRequest19({ timeoutSeconds: 30, cors: true }, async (req
       };
     });
     res.json({ products });
-  } catch (error5) {
-    logger3.error("Failed to list products", { error: error5.message });
-    if (error5.code === "auth/id-token-expired") {
+  } catch (error6) {
+    logger3.error("Failed to list products", { error: error6.message });
+    if (error6.code === "auth/id-token-expired") {
       res.status(401).json({ error: "Token expired" });
       return;
     }
-    if (error5.code === "auth/argument-error" || error5.code === "auth/invalid-id-token") {
+    if (error6.code === "auth/argument-error" || error6.code === "auth/invalid-id-token") {
       res.status(401).json({ error: "Invalid token" });
       return;
     }
@@ -9730,11 +9730,433 @@ var mcpListProducts = onRequest19({ timeoutSeconds: 30, cors: true }, async (req
   }
 });
 
+// ../lib/mcp/data-proxy.js
+import { onRequest as onRequest20 } from "firebase-functions/v2/https";
+import * as logger4 from "firebase-functions/logger";
+import admin17 from "firebase-admin";
+var handlers = {};
+function register(action, handler) {
+  handlers[action] = handler;
+}
+register("premortem.list", async (uid, params) => {
+  const db = admin17.firestore();
+  let query = db.collection("premortem_jobs").where("uid", "==", uid).orderBy("createdAt", "desc");
+  if (params.status) {
+    query = query.where("status", "==", params.status);
+  }
+  if (params.limit) {
+    query = query.limit(Math.min(params.limit, 100));
+  }
+  const snap = await query.get();
+  return { docs: snap.docs.map((d) => ({ id: d.id, ...d.data() })) };
+});
+register("premortem.get", async (uid, params) => {
+  const db = admin17.firestore();
+  const doc = await db.collection("premortem_jobs").doc(params.id).get();
+  if (!doc.exists)
+    return { doc: null };
+  const data = doc.data();
+  if (data?.uid !== uid)
+    return { doc: null };
+  return { doc: { id: doc.id, ...data } };
+});
+register("premortem.create", async (uid, params) => {
+  const db = admin17.firestore();
+  const ref = params.id ? db.collection("premortem_jobs").doc(params.id) : db.collection("premortem_jobs").doc();
+  await ref.set({ ...params.data, uid, createdAt: admin17.firestore.FieldValue.serverTimestamp() });
+  return { id: ref.id };
+});
+register("premortem.update", async (uid, params) => {
+  const db = admin17.firestore();
+  const ref = db.collection("premortem_jobs").doc(params.id);
+  const doc = await ref.get();
+  if (!doc.exists || doc.data()?.uid !== uid) {
+    throw new Error("Not found or not authorized");
+  }
+  await ref.update(params.data);
+  return { ok: true };
+});
+register("premortem.getIdea", async (uid, params) => {
+  const db = admin17.firestore();
+  const doc = await db.collection("idea_reports").doc(params.id).get();
+  if (!doc.exists)
+    return { doc: null };
+  return { doc: { id: doc.id, ...doc.data() } };
+});
+register("chat.save", async (uid, params) => {
+  const db = admin17.firestore();
+  const ref = db.collection("premortem_chats").doc(params.id);
+  await ref.set({ ...params.data, uid, updatedAt: admin17.firestore.FieldValue.serverTimestamp() });
+  return { id: ref.id };
+});
+register("chat.get", async (uid, params) => {
+  const db = admin17.firestore();
+  const doc = await db.collection("premortem_chats").doc(params.id).get();
+  if (!doc.exists)
+    return { doc: null };
+  const data = doc.data();
+  if (data?.uid !== uid)
+    return { doc: null };
+  return { doc: { id: doc.id, ...data } };
+});
+register("chat.update", async (uid, params) => {
+  const db = admin17.firestore();
+  const ref = db.collection("premortem_chats").doc(params.id);
+  const doc = await ref.get();
+  if (!doc.exists || doc.data()?.uid !== uid) {
+    throw new Error("Not found or not authorized");
+  }
+  await ref.update(params.data);
+  return { ok: true };
+});
+register("exploration.create", async (uid, params) => {
+  const db = admin17.firestore();
+  const collection = params.collection || "exploration_sessions";
+  const ref = db.collection(collection).doc(params.id);
+  await ref.set({ ...params.data, uid, createdAt: admin17.firestore.FieldValue.serverTimestamp() });
+  return { id: ref.id };
+});
+register("exploration.get", async (uid, params) => {
+  const db = admin17.firestore();
+  const collection = params.collection || "exploration_sessions";
+  const doc = await db.collection(collection).doc(params.id).get();
+  if (!doc.exists)
+    return { doc: null };
+  const data = doc.data();
+  if (data?.uid !== uid)
+    return { doc: null };
+  return { doc: { id: doc.id, ...data } };
+});
+register("exploration.update", async (uid, params) => {
+  const db = admin17.firestore();
+  const collection = params.collection || "exploration_sessions";
+  const ref = db.collection(collection).doc(params.id);
+  const doc = await ref.get();
+  if (!doc.exists || doc.data()?.uid !== uid) {
+    throw new Error("Not found or not authorized");
+  }
+  await ref.update(params.data);
+  return { ok: true };
+});
+register("exploration.list", async (uid, params) => {
+  const db = admin17.firestore();
+  const collection = params.collection || "exploration_sessions";
+  const limit = Math.min(params.limit || 20, 100);
+  const snap = await db.collection(collection).where("uid", "==", uid).orderBy("createdAt", "desc").limit(limit).get();
+  return { docs: snap.docs.map((d) => ({ id: d.id, ...d.data() })) };
+});
+function graphCol(productId, sub) {
+  return admin17.firestore().collection("context_graph").doc(productId).collection(sub);
+}
+register("graph.getEntities", async (_uid, params) => {
+  const snap = await graphCol(params.productId, "entities").get();
+  return { docs: snap.docs.map((d) => ({ id: d.id, ...d.data() })) };
+});
+register("graph.upsertEntities", async (_uid, params) => {
+  const col = graphCol(params.productId, "entities");
+  const batch = admin17.firestore().batch();
+  if (params.deleteIds?.length) {
+    for (const id of params.deleteIds) {
+      batch.delete(col.doc(id));
+    }
+  }
+  if (params.entities?.length) {
+    for (const entity of params.entities) {
+      const id = entity.id || col.doc().id;
+      batch.set(col.doc(id), entity);
+    }
+  }
+  await batch.commit();
+  return { ok: true };
+});
+register("graph.getEdges", async (_uid, params) => {
+  const snap = await graphCol(params.productId, "edges").get();
+  return { docs: snap.docs.map((d) => ({ id: d.id, ...d.data() })) };
+});
+register("graph.upsertEdges", async (_uid, params) => {
+  const col = graphCol(params.productId, "edges");
+  const batch = admin17.firestore().batch();
+  if (params.deleteIds?.length) {
+    for (const id of params.deleteIds) {
+      batch.delete(col.doc(id));
+    }
+  }
+  if (params.edges?.length) {
+    for (const edge of params.edges) {
+      const id = edge.id || col.doc().id;
+      batch.set(col.doc(id), edge);
+    }
+  }
+  await batch.commit();
+  return { ok: true };
+});
+register("graph.getBindings", async (_uid, params) => {
+  const col = graphCol(params.productId, "bindings");
+  let query = col;
+  if (params.entityId) {
+    query = col.where("entityId", "==", params.entityId);
+  }
+  const snap = await query.get();
+  return { docs: snap.docs.map((d) => ({ id: d.id, ...d.data() })) };
+});
+register("graph.upsertBindings", async (_uid, params) => {
+  const col = graphCol(params.productId, "bindings");
+  const batch = admin17.firestore().batch();
+  if (params.deleteIds?.length) {
+    for (const id of params.deleteIds) {
+      batch.delete(col.doc(id));
+    }
+  }
+  if (params.bindings?.length) {
+    for (const binding of params.bindings) {
+      const id = binding.id || col.doc().id;
+      batch.set(col.doc(id), binding, { merge: true });
+    }
+  }
+  await batch.commit();
+  return { ok: true };
+});
+register("graph.getNodes", async (_uid, params) => {
+  const col = graphCol(params.productId, "nodes");
+  let query = col;
+  if (params.categories?.length) {
+    query = col.where("category", "in", params.categories);
+  }
+  if (params.sourceType) {
+    query = col.where("source_type", "==", params.sourceType);
+  }
+  if (params.light) {
+    query = query.select("id", "category", "title", "severity", "source_type", "tags");
+  }
+  const snap = await query.get();
+  return { docs: snap.docs.map((d) => ({ id: d.id, ...d.data() })) };
+});
+register("graph.upsertNodes", async (_uid, params) => {
+  const col = graphCol(params.productId, "nodes");
+  const batch = admin17.firestore().batch();
+  if (params.deleteIds?.length) {
+    for (const id of params.deleteIds) {
+      batch.delete(col.doc(id));
+    }
+  }
+  if (params.nodes?.length) {
+    for (const node of params.nodes) {
+      const id = node.id || col.doc().id;
+      batch.set(col.doc(id), node);
+    }
+  }
+  await batch.commit();
+  return { ok: true };
+});
+register("graph.getTestCases", async (_uid, params) => {
+  const col = graphCol(params.productId, "test_cases");
+  let query = col;
+  if (params.entityId) {
+    query = col.where("entityId", "==", params.entityId);
+  }
+  const snap = await query.get();
+  return { docs: snap.docs.map((d) => ({ id: d.id, ...d.data() })) };
+});
+register("graph.addTestCases", async (_uid, params) => {
+  const col = graphCol(params.productId, "test_cases");
+  const batch = admin17.firestore().batch();
+  for (const tc of params.testCases || []) {
+    const id = tc.id || col.doc().id;
+    batch.set(col.doc(id), tc, { merge: true });
+  }
+  await batch.commit();
+  return { ok: true };
+});
+register("graph.getMeta", async (_uid, params) => {
+  const doc = await admin17.firestore().collection("context_graph").doc(params.productId).collection("_meta").doc("graph").get();
+  return { doc: doc.exists ? { id: doc.id, ...doc.data() } : null };
+});
+register("graph.updateMeta", async (_uid, params) => {
+  const ref = admin17.firestore().collection("context_graph").doc(params.productId).collection("_meta").doc("graph");
+  await ref.set(params.data, { merge: true });
+  return { ok: true };
+});
+register("graph.recordScore", async (_uid, params) => {
+  const db = admin17.firestore();
+  const histRef = db.collection("context_graph").doc(params.productId).collection("score_history").doc(params.snapshotId);
+  await histRef.set(params.snapshot);
+  if (params.jobUpdate) {
+    const jobRef = db.collection("premortem_jobs").doc(params.productId);
+    const jobDoc = await jobRef.get();
+    if (jobDoc.exists) {
+      await jobRef.update(params.jobUpdate);
+    }
+  }
+  return { ok: true };
+});
+register("graph.deleteAll", async (_uid, params) => {
+  const db = admin17.firestore();
+  const subs = ["entities", "edges", "bindings", "test_cases", "nodes"];
+  for (const sub of subs) {
+    const snap = await db.collection("context_graph").doc(params.productId).collection(sub).get();
+    if (!snap.empty) {
+      const batch = db.batch();
+      snap.docs.forEach((d) => batch.delete(d.ref));
+      await batch.commit();
+    }
+  }
+  return { ok: true };
+});
+register("graph.hasConstraints", async (_uid, params) => {
+  const snap = await graphCol(params.productId, "nodes").limit(1).get();
+  return { hasConstraints: !snap.empty };
+});
+register("graph.updateEmbedding", async (_uid, params) => {
+  const ref = graphCol(params.productId, params.collection || "entities").doc(params.docId);
+  await ref.update({ embedding: params.embedding });
+  return { ok: true };
+});
+register("template.list", async (uid, params) => {
+  const db = admin17.firestore();
+  let query = db.collection("templates").where("uid", "==", uid);
+  if (params.type) {
+    query = query.where("type", "==", params.type);
+  }
+  const snap = await query.get();
+  return { docs: snap.docs.map((d) => ({ id: d.id, ...d.data() })) };
+});
+register("template.get", async (uid, params) => {
+  const db = admin17.firestore();
+  const doc = await db.collection("templates").doc(params.id).get();
+  if (!doc.exists)
+    return { doc: null };
+  const data = doc.data();
+  if (data?.uid !== uid)
+    return { doc: null };
+  return { doc: { id: doc.id, ...data } };
+});
+register("template.create", async (uid, params) => {
+  const db = admin17.firestore();
+  const id = params.id || db.collection("templates").doc().id;
+  const ref = db.collection("templates").doc(id);
+  await ref.set({ ...params.data, uid, createdAt: admin17.firestore.FieldValue.serverTimestamp() });
+  return { id: ref.id };
+});
+register("template.update", async (uid, params) => {
+  const db = admin17.firestore();
+  const ref = db.collection("templates").doc(params.id);
+  const doc = await ref.get();
+  if (!doc.exists || doc.data()?.uid !== uid) {
+    throw new Error("Not found or not authorized");
+  }
+  await ref.update(params.data);
+  return { ok: true };
+});
+register("scan.save", async (uid, params) => {
+  const db = admin17.firestore();
+  const collection = params.collection || "scan_reports";
+  const id = params.id || db.collection(collection).doc().id;
+  const ref = db.collection(collection).doc(id);
+  await ref.set({ ...params.data, uid, createdAt: admin17.firestore.FieldValue.serverTimestamp() });
+  return { id: ref.id };
+});
+register("scan.rateCheck", async (uid, _params) => {
+  const db = admin17.firestore();
+  const ref = db.collection("users").doc(uid);
+  const doc = await ref.get();
+  if (!doc.exists) {
+    return { scanCount: 0, periodStart: null };
+  }
+  const data = doc.data();
+  return {
+    scanCount: data?.freeScanCount ?? 0,
+    periodStart: data?.freeScanPeriodStart?.toDate?.()?.toISOString() ?? null,
+    subscription: data?.subscription?.status ?? "free"
+  };
+});
+register("scan.rateUpdate", async (uid, params) => {
+  const db = admin17.firestore();
+  const ref = db.collection("users").doc(uid);
+  await ref.set(params.data, { merge: true });
+  return { ok: true };
+});
+register("readiness.get", async (_uid, params) => {
+  const db = admin17.firestore();
+  const doc = await db.collection("readiness_reports").doc(params.id).get();
+  return { doc: doc.exists ? { id: doc.id, ...doc.data() } : null };
+});
+register("readiness.save", async (_uid, params) => {
+  const db = admin17.firestore();
+  const ref = db.collection("readiness_reports").doc(params.id);
+  await ref.set(params.data);
+  return { ok: true };
+});
+register("persona.list", async (uid, params) => {
+  const db = admin17.firestore();
+  let query = db.collection("users").doc(uid).collection("personas");
+  if (params.productId) {
+    query = query.where("productId", "==", params.productId);
+  }
+  const snap = await query.orderBy("createdAt", "desc").get();
+  return { docs: snap.docs.map((d) => ({ id: d.id, ...d.data() })) };
+});
+register("persona.get", async (uid, params) => {
+  const db = admin17.firestore();
+  const doc = await db.collection("users").doc(uid).collection("personas").doc(params.id).get();
+  if (!doc.exists)
+    return { doc: null };
+  return { doc: { id: doc.id, ...doc.data() } };
+});
+var mcpDataProxy = onRequest20({
+  timeoutSeconds: 60,
+  memory: "256MiB",
+  cors: true
+}, async (req, res) => {
+  ensureFirebaseAdmin();
+  if (req.method === "OPTIONS") {
+    res.status(204).send("");
+    return;
+  }
+  if (req.method !== "POST") {
+    res.status(405).json({ error: "Method not allowed" });
+    return;
+  }
+  const authHeader = req.headers.authorization;
+  if (!authHeader?.startsWith("Bearer ")) {
+    res.status(401).json({ error: "Missing or invalid Authorization header" });
+    return;
+  }
+  let decoded;
+  try {
+    decoded = await admin17.auth().verifyIdToken(authHeader.slice(7));
+  } catch (error6) {
+    if (error6.code === "auth/id-token-expired") {
+      res.status(401).json({ error: "Token expired" });
+      return;
+    }
+    res.status(401).json({ error: "Invalid token" });
+    return;
+  }
+  const uid = decoded.uid;
+  const { action, params } = req.body || {};
+  if (!action || typeof action !== "string") {
+    res.status(400).json({ error: "Missing action" });
+    return;
+  }
+  const handler = handlers[action];
+  if (!handler) {
+    res.status(400).json({ error: `Unknown action: ${action}` });
+    return;
+  }
+  try {
+    const result = await handler(uid, params || {});
+    res.json(result);
+  } catch (error6) {
+    logger4.error(`mcpDataProxy action=${action} error`, { uid, error: error6.message });
+    res.status(error6.message?.includes("not authorized") ? 403 : 500).json({ error: error6.message || "Internal error" });
+  }
+});
+
 // ../lib/subscription/cancel-scheduled.js
 import { onSchedule } from "firebase-functions/v2/scheduler";
 import Stripe2 from "stripe";
-import admin17 from "firebase-admin";
-import { logger as logger4 } from "firebase-functions";
+import admin18 from "firebase-admin";
+import { logger as logger5 } from "firebase-functions";
 ensureFirebaseAdmin();
 function getStripeInstance() {
   const secretKey = process.env.STRIPE_SECRET_KEY;
@@ -9746,7 +10168,7 @@ function getStripeInstance() {
   });
 }
 function getUsersCollection() {
-  return admin17.firestore().collection("users");
+  return admin18.firestore().collection("users");
 }
 var cancelScheduledSubscriptions = onSchedule({
   schedule: "every day 00:00",
@@ -9756,20 +10178,20 @@ var cancelScheduledSubscriptions = onSchedule({
   timeoutSeconds: 540
 }, async (event) => {
   try {
-    logger4.info("[cancel-scheduled-subscriptions] Starting scheduled cancellation check");
+    logger5.info("[cancel-scheduled-subscriptions] Starting scheduled cancellation check");
     const stripe = getStripeInstance();
     const users = getUsersCollection();
     const now = /* @__PURE__ */ new Date();
     const today = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate()));
     const todayISO = today.toISOString();
-    logger4.info(`[cancel-scheduled-subscriptions] Checking for cancellations on or before ${todayISO}`);
+    logger5.info(`[cancel-scheduled-subscriptions] Checking for cancellations on or before ${todayISO}`);
     const allUsersWithCancellation = await users.where("subscriptionCancellationDate", "<=", todayISO).get();
-    logger4.info(`[cancel-scheduled-subscriptions] Found ${allUsersWithCancellation.docs.length} users with cancellation dates <= ${todayISO}`);
+    logger5.info(`[cancel-scheduled-subscriptions] Found ${allUsersWithCancellation.docs.length} users with cancellation dates <= ${todayISO}`);
     const usersToCancel = allUsersWithCancellation.docs.filter((doc) => {
       const data = doc.data();
       return data?.subscription?.id;
     });
-    logger4.info(`[cancel-scheduled-subscriptions] Found ${usersToCancel.length} subscriptions to cancel`);
+    logger5.info(`[cancel-scheduled-subscriptions] Found ${usersToCancel.length} subscriptions to cancel`);
     let successCount = 0;
     let errorCount = 0;
     for (const userDoc of usersToCancel) {
@@ -9778,45 +10200,45 @@ var cancelScheduledSubscriptions = onSchedule({
       const subscriptionId = subscription?.id;
       const cancellationDate = userData?.subscriptionCancellationDate;
       if (!subscriptionId) {
-        logger4.warn(`[cancel-scheduled-subscriptions] User ${userDoc.id} has cancellation date but no subscription ID`);
+        logger5.warn(`[cancel-scheduled-subscriptions] User ${userDoc.id} has cancellation date but no subscription ID`);
         continue;
       }
       try {
         await stripe.subscriptions.cancel(subscriptionId);
-        logger4.info(`[cancel-scheduled-subscriptions] Cancelled Stripe subscription ${subscriptionId} for user ${userDoc.id}`);
+        logger5.info(`[cancel-scheduled-subscriptions] Cancelled Stripe subscription ${subscriptionId} for user ${userDoc.id}`);
         await users.doc(userDoc.id).set({
-          subscription: admin17.firestore.FieldValue.delete(),
-          subscriptionCancellationDate: admin17.firestore.FieldValue.delete(),
-          subscriptionUpdatedAt: admin17.firestore.FieldValue.serverTimestamp()
+          subscription: admin18.firestore.FieldValue.delete(),
+          subscriptionCancellationDate: admin18.firestore.FieldValue.delete(),
+          subscriptionUpdatedAt: admin18.firestore.FieldValue.serverTimestamp()
         }, { merge: true });
-        logger4.info(`[cancel-scheduled-subscriptions] Removed subscription from Firestore for user ${userDoc.id}`);
+        logger5.info(`[cancel-scheduled-subscriptions] Removed subscription from Firestore for user ${userDoc.id}`);
         successCount++;
-      } catch (error5) {
-        logger4.error({
+      } catch (error6) {
+        logger5.error({
           userId: userDoc.id,
           subscriptionId,
           cancellationDate,
-          error: error5?.message
+          error: error6?.message
         }, `[cancel-scheduled-subscriptions] Failed to cancel subscription for user ${userDoc.id}`);
         errorCount++;
       }
     }
-    logger4.info({
+    logger5.info({
       total: usersToCancel.length,
       success: successCount,
       errors: errorCount
     }, "[cancel-scheduled-subscriptions] Completed scheduled cancellation check");
-  } catch (error5) {
-    logger4.error({ error: error5?.message, stack: error5?.stack }, "[cancel-scheduled-subscriptions] Fatal error in scheduled function");
-    throw error5;
+  } catch (error6) {
+    logger5.error({ error: error6?.message, stack: error6?.stack }, "[cancel-scheduled-subscriptions] Fatal error in scheduled function");
+    throw error6;
   }
 });
 
 // ../lib/personas/cancel-scheduled.js
 import { onSchedule as onSchedule2 } from "firebase-functions/v2/scheduler";
 import Stripe3 from "stripe";
-import admin18 from "firebase-admin";
-import { logger as logger5 } from "firebase-functions";
+import admin19 from "firebase-admin";
+import { logger as logger6 } from "firebase-functions";
 ensureFirebaseAdmin();
 function getStripeInstance2() {
   const secretKey = process.env.STRIPE_SECRET_KEY;
@@ -9828,7 +10250,7 @@ function getStripeInstance2() {
   });
 }
 function getUsersCollection2() {
-  return admin18.firestore().collection("users");
+  return admin19.firestore().collection("users");
 }
 var cancelScheduledPersonas = onSchedule2({
   schedule: "every day 00:00",
@@ -9838,7 +10260,7 @@ var cancelScheduledPersonas = onSchedule2({
   timeoutSeconds: 540
 }, async (event) => {
   try {
-    logger5.info("[cancel-scheduled-personas] Starting scheduled persona cancellation check");
+    logger6.info("[cancel-scheduled-personas] Starting scheduled persona cancellation check");
     const stripe = getStripeInstance2();
     const users = getUsersCollection2();
     const now = /* @__PURE__ */ new Date();
@@ -9856,7 +10278,7 @@ var cancelScheduledPersonas = onSchedule2({
         const cancellationDate = data?.lifecycle?.cancellation_date;
         if (!cancellationDate)
           return false;
-        const cancelDate = cancellationDate instanceof admin18.firestore.Timestamp ? cancellationDate.toDate() : new Date(cancellationDate);
+        const cancelDate = cancellationDate instanceof admin19.firestore.Timestamp ? cancellationDate.toDate() : new Date(cancellationDate);
         return cancelDate <= today;
       });
       totalPersonasToCancel += personasWithCancellation.length;
@@ -9876,43 +10298,43 @@ var cancelScheduledPersonas = onSchedule2({
               const subscription = subscriptions.data.find((sub) => sub.items.data.some((item) => item.id === subscriptionItemId));
               if (subscription && !subscription.cancel_at_period_end) {
                 await stripe.subscriptions.cancel(subscription.id);
-                logger5.info(`[cancel-scheduled-personas] Cancelled Stripe subscription ${subscription.id} for persona ${personaId} (user ${userId})`);
+                logger6.info(`[cancel-scheduled-personas] Cancelled Stripe subscription ${subscription.id} for persona ${personaId} (user ${userId})`);
               }
             }
           }
           await personasRef.doc(personaId).set({
             "lifecycle.status": "archived",
-            "lifecycle.cancellation_date": admin18.firestore.FieldValue.delete(),
-            updatedAt: admin18.firestore.FieldValue.serverTimestamp()
+            "lifecycle.cancellation_date": admin19.firestore.FieldValue.delete(),
+            updatedAt: admin19.firestore.FieldValue.serverTimestamp()
           }, { merge: true });
-          logger5.info(`[cancel-scheduled-personas] Archived persona ${personaId} for user ${userId}`);
+          logger6.info(`[cancel-scheduled-personas] Archived persona ${personaId} for user ${userId}`);
           successCount++;
-        } catch (error5) {
-          logger5.error({
+        } catch (error6) {
+          logger6.error({
             userId,
             personaId,
             subscriptionItemId,
-            error: error5?.message
+            error: error6?.message
           }, `[cancel-scheduled-personas] Failed to cancel persona ${personaId} for user ${userId}`);
           errorCount++;
         }
       }
     }
-    logger5.info({
+    logger6.info({
       total: totalPersonasToCancel,
       success: successCount,
       errors: errorCount
     }, "[cancel-scheduled-personas] Completed scheduled persona cancellation check");
-  } catch (error5) {
-    logger5.error({ error: error5?.message, stack: error5?.stack }, "[cancel-scheduled-personas] Fatal error in scheduled function");
-    throw error5;
+  } catch (error6) {
+    logger6.error({ error: error6?.message, stack: error6?.stack }, "[cancel-scheduled-personas] Fatal error in scheduled function");
+    throw error6;
   }
 });
 
 // ../lib/trial/expire-trials.js
 import { onSchedule as onSchedule3 } from "firebase-functions/v2/scheduler";
-import admin19 from "firebase-admin";
-import { logger as logger6 } from "firebase-functions";
+import admin20 from "firebase-admin";
+import { logger as logger7 } from "firebase-functions";
 ensureFirebaseAdmin();
 function getTrialConfig() {
   const isProduction = process.env.GCLOUD_PROJECT === "cutline-prod" || process.env.K_SERVICE?.includes("prod");
@@ -9955,18 +10377,18 @@ var expireTrials = onSchedule3({
   // Reduced since it runs frequently now
 }, async (event) => {
   const config = getTrialConfig();
-  logger6.info({
+  logger7.info({
     trialDuration: config.durationLabel,
     schedule: scheduleConfig.scheduleLabel,
     checkTime: (/* @__PURE__ */ new Date()).toISOString()
   }, "[expire-trials] Starting trial expiration check");
   try {
-    const db = admin19.firestore();
+    const db = admin20.firestore();
     const users = db.collection("users");
     const now = Date.now();
     const expirationThreshold = now - config.durationMs;
     const expiredTrials = await users.where("trialStatus", "==", "active").where("trialStartedAt", "<=", new Date(expirationThreshold)).get();
-    logger6.info({
+    logger7.info({
       foundCount: expiredTrials.docs.length,
       expirationThreshold: new Date(expirationThreshold).toISOString()
     }, "[expire-trials] Found trials to expire");
@@ -9976,36 +10398,36 @@ var expireTrials = onSchedule3({
       try {
         await users.doc(userDoc.id).update({
           trialStatus: "expired",
-          trialExpiredAt: admin19.firestore.FieldValue.serverTimestamp()
+          trialExpiredAt: admin20.firestore.FieldValue.serverTimestamp()
         });
-        logger6.info({ userId: userDoc.id }, "[expire-trials] Expired trial for user");
+        logger7.info({ userId: userDoc.id }, "[expire-trials] Expired trial for user");
         successCount++;
-      } catch (error5) {
-        logger6.error({
+      } catch (error6) {
+        logger7.error({
           userId: userDoc.id,
-          error: error5?.message
+          error: error6?.message
         }, "[expire-trials] Failed to expire trial");
         errorCount++;
       }
     }
-    logger6.info({
+    logger7.info({
       total: expiredTrials.docs.length,
       success: successCount,
       errors: errorCount,
       trialDuration: config.durationLabel
     }, "[expire-trials] Completed trial expiration check");
-  } catch (error5) {
-    logger6.error({
-      error: error5?.message,
-      stack: error5?.stack
+  } catch (error6) {
+    logger7.error({
+      error: error6?.message,
+      stack: error6?.stack
     }, "[expire-trials] Fatal error in scheduled function");
-    throw error5;
+    throw error6;
   }
 });
 
 // ../lib/persona-testing/trigger.js
 import { onDocumentCreated as onDocumentCreated2 } from "firebase-functions/v2/firestore";
-import * as logger7 from "firebase-functions/logger";
+import * as logger8 from "firebase-functions/logger";
 import { getFirestore as getFirestore2, FieldValue } from "firebase-admin/firestore";
 function getPersonaTesterUrl() {
   const url = process.env.PERSONA_TESTER_URL;
@@ -10017,24 +10439,24 @@ function getPersonaTesterUrl() {
 var onPersonaTestCreated = onDocumentCreated2("users/{userId}/personas/{personaId}/tests/{testId}", async (event) => {
   const snap = event.data;
   if (!snap) {
-    logger7.error("[PersonaTest] No data in event");
+    logger8.error("[PersonaTest] No data in event");
     return;
   }
   const { userId, personaId, testId } = event.params;
   const testData = snap.data();
-  logger7.info(`[PersonaTest] New test created: ${testId}`, {
+  logger8.info(`[PersonaTest] New test created: ${testId}`, {
     userId,
     personaId,
     testId,
     status: testData.status
   });
   if (testData.status !== "queued") {
-    logger7.info(`[PersonaTest] Skipping test ${testId} - status is ${testData.status}`);
+    logger8.info(`[PersonaTest] Skipping test ${testId} - status is ${testData.status}`);
     return;
   }
   try {
     const personaTesterUrl = getPersonaTesterUrl();
-    logger7.info(`[PersonaTest] Calling Cloud Run service for test ${testId}`, { url: personaTesterUrl });
+    logger8.info(`[PersonaTest] Calling Cloud Run service for test ${testId}`, { url: personaTesterUrl });
     const response = await fetch(`${personaTesterUrl}/execute`, {
       method: "POST",
       headers: {
@@ -10051,10 +10473,10 @@ var onPersonaTestCreated = onDocumentCreated2("users/{userId}/personas/{personaI
       throw new Error(`Cloud Run service returned ${response.status}: ${errorText}`);
     }
     const result = await response.json();
-    logger7.info(`[PersonaTest] Test ${testId} execution started`, result);
-  } catch (error5) {
-    const err = error5;
-    logger7.error(`[PersonaTest] Failed to trigger test ${testId}:`, err);
+    logger8.info(`[PersonaTest] Test ${testId} execution started`, result);
+  } catch (error6) {
+    const err = error6;
+    logger8.error(`[PersonaTest] Failed to trigger test ${testId}:`, err);
     const firestore = getFirestore2();
     await firestore.collection("users").doc(userId).collection("personas").doc(personaId).collection("tests").doc(testId).update({
       status: "failed",