diff --git a/.claude/skills/write-test/SKILL.md b/.claude/skills/write-test/SKILL.md
index 5db9eea80..9160ec341 100644
--- a/.claude/skills/write-test/SKILL.md
+++ b/.claude/skills/write-test/SKILL.md
@@ -79,6 +79,7 @@ Load these on-demand for detailed information:
 - [references/EXPECTATIONS.md](references/EXPECTATIONS.md) - All expectation utilities
 - [references/GOTCHAS.md](references/GOTCHAS.md) - Common pitfalls, debugging, billing edge cases
 - [references/WEBHOOKS.md](references/WEBHOOKS.md) - Outbound webhook testing with Svix Play
+- [references/STRIPE-BEHAVIORS.md](references/STRIPE-BEHAVIORS.md) - Stripe webhook behaviors for consumables, trials, cancellations
 
 ## File Location
 
diff --git a/.claude/skills/write-test/references/STRIPE-BEHAVIORS.md b/.claude/skills/write-test/references/STRIPE-BEHAVIORS.md
new file mode 100644
index 000000000..b48358703
--- /dev/null
+++ b/.claude/skills/write-test/references/STRIPE-BEHAVIORS.md
@@ -0,0 +1,81 @@
+# Stripe Behaviors Reference
+
+How Stripe handles billing events and how Autumn responds to them.
+
+## Consumable (Arrear) Billing
+
+Consumable items are charged in arrears - usage is tracked during a billing period and charged at the end.
+
+### Renewals (invoice.created)
+
+For regular billing cycle renewals, we use the `invoice.created` webhook to add consumable line items.
+
+**Handler:** `server/src/external/stripe/webhookHandlers/handleStripeInvoiceCreated/tasks/processConsumablePricesForInvoiceCreated.ts`
+
+**How it works:**
+1. Stripe fires `invoice.created` at the start of each billing cycle
+2. We check if it's a periodic invoice (`billing_reason === "subscription_cycle"`)
+3. We calculate usage for the previous period and add line items to the draft invoice
+4. Stripe then finalizes and charges the invoice
+
+### Last Invoice (Cancellation)
+
+When a subscription is canceled, the handling differs between customer-level and entity-level products.
+
+#### Customer-Level Products (Stripe Metered Items)
+
+**Stripe Behavior:** Stripe creates an EXTRA invoice after the subscription is canceled because metered items (usage-based) need final usage to be billed.
+
+**Handler:** `invoice.created` still applies - same as renewals
+
+**Important:** If a trial ends (not a cancellation), Stripe does NOT create an extra invoice. We detect this by checking if `current_period_start === trial_end` and skip consumable charges in that case.
+
+```typescript
+// From processConsumablePricesForInvoiceCreated.ts
+const hasTrialJustEnded = ({ stripeSubscription }) => {
+  const trialEnd = stripeSubscription.trial_end;
+  if (!trialEnd) return false;
+  const periodStart = getLatestPeriodStart({ sub: stripeSubscription });
+  return trialEnd === periodStart;
+};
+```
+
+#### Entity-Level Products (Non-Metered)
+
+**Stripe Behavior:** Stripe does NOT create an extra invoice because we use empty price items ($0 placeholder prices for entity subscriptions).
+
+**Handler:** `server/src/external/stripe/webhookHandlers/handleStripeSubscriptionDeleted/tasks/processConsumablePricesForSubscriptionDeleted.ts`
+
+**How it works:**
+1. When `subscription.deleted` fires, we check if the subscription has metered items
+2. If NO metered items (entity-level), we manually create an invoice for arrear charges
+3. We skip this if:
+   - Subscription has metered items (Stripe handles it via `invoice.created`)
+   - It was an immediate cancellation (no overage charged on immediate cancels)
+   - It was a trial cancellation (`ended_at === trial_end`)
+
+```typescript
+// From processConsumablePricesForSubscriptionDeleted.ts
+const wasTrialCancellation = (stripeSubscription) => {
+  const trialEnd = stripeSubscription.trial_end;
+  const endedAt = stripeSubscription.ended_at;
+  if (!trialEnd || !endedAt) return false;
+  return trialEnd === endedAt;
+};
+```
+
+### Summary Table
+
+| Scenario | Customer-Level (Metered) | Entity-Level (Non-Metered) |
+|----------|--------------------------|----------------------------|
+| **Renewal** | `invoice.created` | `invoice.created` |
+| **Cancel End-of-Cycle** | Stripe creates extra invoice → `invoice.created` | No extra invoice → `subscription.deleted` creates invoice |
+| **Cancel Immediately** | No overage charged | No overage charged |
+| **Trial Ends** | No extra invoice, skip consumable charges | No extra invoice, skip consumable charges |
+| **Cancel at Trial End** | Skip consumable charges | Skip consumable charges |
+
+### Key Differences
+
+1. **Metered vs Non-Metered:** Stripe only creates an extra final invoice for subscriptions with metered items
+2. **Trial Handling:** Both paths skip billing when trial ends - trial usage is free
+3. **Immediate Cancel:** Neither path bills for overage on immediate cancellations
diff --git a/server/src/external/stripe/subscriptions/utils/classifyStripeSubscriptionUtils.ts b/server/src/external/stripe/subscriptions/utils/classifyStripeSubscriptionUtils.ts
index 262f71062..ad592405f 100644
--- a/server/src/external/stripe/subscriptions/utils/classifyStripeSubscriptionUtils.ts
+++ b/server/src/external/stripe/subscriptions/utils/classifyStripeSubscriptionUtils.ts
@@ -1,5 +1,6 @@
 import { notNullish } from "@autumn/shared";
 import type Stripe from "stripe";
+import { getLatestPeriodEnd } from "@/external/stripe/stripeSubUtils/convertSubUtils";
 
 /** Stripe subscription that is trialing with guaranteed trial_end */
 export type TrialingStripeSubscription = Stripe.Subscription & {
@@ -79,3 +80,33 @@ export const isStripeSubscriptionVercel = (
 
 	return Boolean(stripeSubscription.metadata?.vercel_installation_id);
 };
+
+/**
+ * Checks if a Stripe subscription was canceled immediately (not at end of period).
+ *
+ * For Stripe dashboard-initiated cancellations:
+ * - "Cancel at end of period" → cancel_at_period_end = true → returns false
+ * - "Cancel immediately" → cancel_at_period_end = false → returns true
+ *
+ * Note: This is only reliable for external (non-Autumn) cancellations.
+ * Autumn-initiated cancellations use a lock mechanism and are filtered out
+ * before this check in the subscription.deleted handler.
+ */
+export const wasImmediateStripeCancellation = (
+	stripeSubscription?: Stripe.Subscription,
+): boolean => {
+	if (!stripeSubscription) return false;
+
+	if (!stripeSubscription.ended_at) return false;
+
+	const latestPeriodEnd = getLatestPeriodEnd({ sub: stripeSubscription });
+	const differenceInSeconds = Math.abs(
+		stripeSubscription.ended_at - latestPeriodEnd,
+	);
+
+	return differenceInSeconds > 20;
+
+	// // If cancel_at_period_end is true, it was an end-of-period cancellation
+	// // If false, it was an immediate cancellation
+	// return !stripeSubscription.cancel_at_period_end;
+};
diff --git a/server/src/external/stripe/webhookHandlers/handleStripeInvoiceCreated/tasks/processConsumablePricesForInvoiceCreated.ts b/server/src/external/stripe/webhookHandlers/handleStripeInvoiceCreated/tasks/processConsumablePricesForInvoiceCreated.ts
index e810df8a0..03fee9ab1 100644
--- a/server/src/external/stripe/webhookHandlers/handleStripeInvoiceCreated/tasks/processConsumablePricesForInvoiceCreated.ts
+++ b/server/src/external/stripe/webhookHandlers/handleStripeInvoiceCreated/tasks/processConsumablePricesForInvoiceCreated.ts
@@ -1,4 +1,5 @@
 import { customerEntitlementShouldBeBilled, secondsToMs } from "@autumn/shared";
+import { getLatestPeriodStart } from "@/external/stripe/stripeSubUtils/convertSubUtils";
 import { eventContextToArrearLineItems } from "@/external/stripe/webhookHandlers/common";
 import { lineItemsToCreateInvoiceItemsParams } from "@/internal/billing/v2/providers/stripe/utils/invoiceLines/lineItemsToCreateInvoiceItemsParams";
 import { createStripeInvoiceItems } from "@/internal/billing/v2/providers/stripe/utils/invoices/stripeInvoiceOps";
@@ -6,6 +7,24 @@ import { CusEntService } from "@/internal/customers/cusProducts/cusEnts/CusEntit
 import type { StripeWebhookContext } from "../../../webhookMiddlewares/stripeWebhookContext";
 import type { InvoiceCreatedContext } from "../setupInvoiceCreatedContext";
 
+/**
+ * Checks if the subscription's trial just ended.
+ * When a trial ends, Stripe creates the first real billing period where
+ * `current_period_start` equals `trial_end`. In this case, we should skip
+ * billing for consumable usage since trial usage is free.
+ */
+const hasTrialJustEnded = ({
+	stripeSubscription,
+}: {
+	stripeSubscription: InvoiceCreatedContext["stripeSubscription"];
+}): boolean => {
+	const trialEnd = stripeSubscription.trial_end;
+	if (!trialEnd) return false;
+
+	const periodStart = getLatestPeriodStart({ sub: stripeSubscription });
+	return trialEnd === periodStart;
+};
+
 /**
  * Processes consumable (usage-in-arrear) prices for an invoice.
  * Adds usage line items to the invoice for the billing period.
@@ -24,9 +43,21 @@ export const processConsumablePricesForInvoiceCreated = async ({
 	ctx: StripeWebhookContext;
 	eventContext: InvoiceCreatedContext;
 }): Promise<void> => {
-	const { stripeInvoice } = eventContext;
+	const { stripeInvoice, stripeSubscription } = eventContext;
 
-	if (stripeInvoice.billing_reason !== "subscription_cycle") return;
+	const isPeriodicInvoice =
+		stripeInvoice.billing_reason === "subscription_cycle";
+
+	const trialJustEnded = hasTrialJustEnded({ stripeSubscription });
+
+	if (!isPeriodicInvoice) return;
+
+	if (trialJustEnded) {
+		ctx.logger.info(
+			"[invoice.created] Trial just ended, skipping consumable charges",
+		);
+		return;
+	}
 
 	const invoicePeriodEndMs = secondsToMs(stripeInvoice.period_end);
 
diff --git a/server/src/external/stripe/webhookHandlers/handleStripeInvoiceCreated/tasks/upsertAutumnInvoice.ts b/server/src/external/stripe/webhookHandlers/handleStripeInvoiceCreated/tasks/upsertAutumnInvoice.ts
index babe74a9e..14288fdfe 100644
--- a/server/src/external/stripe/webhookHandlers/handleStripeInvoiceCreated/tasks/upsertAutumnInvoice.ts
+++ b/server/src/external/stripe/webhookHandlers/handleStripeInvoiceCreated/tasks/upsertAutumnInvoice.ts
@@ -20,9 +20,9 @@ export const upsertAutumnInvoice = async ({
 	const { stripeInvoice, customerProducts, fullCustomer } = eventContext;
 
 	// Skip first invoice (subscription_create)
-	if (stripeInvoice.billing_reason === "subscription_create") {
+	if (stripeInvoice.billing_reason !== "subscription_cycle") {
 		ctx.logger.debug(
-			"[invoice.created] Skipping invoice upsert for subscription_create",
+			"[invoice.created] Skipping invoice upsert for non periodic invoice",
 		);
 		return;
 	}
diff --git a/server/src/external/stripe/webhookHandlers/handleStripeInvoicePaid/setupStripeInvoicePaidContext.ts b/server/src/external/stripe/webhookHandlers/handleStripeInvoicePaid/setupStripeInvoicePaidContext.ts
index 7fb57ae8c..d1a619162 100644
--- a/server/src/external/stripe/webhookHandlers/handleStripeInvoicePaid/setupStripeInvoicePaidContext.ts
+++ b/server/src/external/stripe/webhookHandlers/handleStripeInvoicePaid/setupStripeInvoicePaidContext.ts
@@ -1,10 +1,13 @@
-import { ALL_STATUSES, cp, type FullCusProduct } from "@autumn/shared";
+import {
+	type FullCusProduct,
+	isCustomerProductOnStripeSubscription,
+} from "@autumn/shared";
 import type Stripe from "stripe";
 import {
 	type ExpandedStripeInvoice,
 	getStripeInvoice,
 } from "@/external/stripe/invoices/operations/getStripeInvoice.js";
-import { CusProductService } from "@/internal/customers/cusProducts/CusProductService";
+import { customerProductActions } from "@/internal/customers/cusProducts/actions";
 import { stripeInvoiceToStripeSubscriptionId } from "../../invoices/utils/convertStripeInvoice";
 import type { StripeWebhookContext } from "../../webhookMiddlewares/stripeWebhookContext.js";
 
@@ -39,12 +42,16 @@ export const setupStripeInvoicePaidContext = async ({
 	let customerProducts: FullCusProduct[] | undefined;
 
 	if (fullCustomer && stripeSubscriptionId) {
-		customerProducts = await CusProductService.getByStripeSubId({
-			db: ctx.db,
-			stripeSubId: stripeSubscriptionId,
-			orgId: ctx.org.id,
-			env: ctx.env,
-			inStatuses: ALL_STATUSES,
+		customerProducts = fullCustomer.customer_products.filter((cp) =>
+			isCustomerProductOnStripeSubscription({
+				customerProduct: cp,
+				stripeSubscriptionId,
+			}),
+		);
+
+		customerProducts = await customerProductActions.expiredCache.getAndMerge({
+			customerProducts,
+			stripeSubscriptionId,
 		});
 
 		fullCustomer.customer_products = customerProducts;
diff --git a/server/src/external/stripe/webhookHandlers/handleStripeSubscriptionDeleted/tasks/processConsumablePricesForSubscriptionDeleted.ts b/server/src/external/stripe/webhookHandlers/handleStripeSubscriptionDeleted/tasks/processConsumablePricesForSubscriptionDeleted.ts
index 5f360fb28..9f31245c5 100644
--- a/server/src/external/stripe/webhookHandlers/handleStripeSubscriptionDeleted/tasks/processConsumablePricesForSubscriptionDeleted.ts
+++ b/server/src/external/stripe/webhookHandlers/handleStripeSubscriptionDeleted/tasks/processConsumablePricesForSubscriptionDeleted.ts
@@ -1,5 +1,8 @@
 import { customerProductsToProducts, secondsToMs } from "@autumn/shared";
-import { stripeSubscriptionHasMeteredItems } from "@/external/stripe/subscriptions/utils/classifyStripeSubscriptionUtils";
+import {
+	stripeSubscriptionHasMeteredItems,
+	wasImmediateStripeCancellation,
+} from "@/external/stripe/subscriptions/utils/classifyStripeSubscriptionUtils";
 import { eventContextToArrearLineItems } from "@/external/stripe/webhookHandlers/common";
 import type { StripeWebhookContext } from "@/external/stripe/webhookMiddlewares/stripeWebhookContext";
 import { lineItemsToInvoiceAddLinesParams } from "@/internal/billing/v2/providers/stripe/utils/invoiceLines/lineItemsToInvoiceAddLinesParams";
@@ -8,10 +11,34 @@ import { upsertInvoiceFromBilling } from "@/internal/billing/v2/utils/upsertFrom
 import { CusEntService } from "@/internal/customers/cusProducts/cusEnts/CusEntitlementService";
 import type { StripeSubscriptionDeletedContext } from "../setupStripeSubscriptionDeletedContext";
 
+/**
+ * Checks if the subscription was canceled during/at trial end.
+ * When a trialing subscription is canceled at period end, `ended_at` equals `trial_end`.
+ * In this case, we should skip arrear charges since trial usage is free.
+ */
+const wasTrialCancellation = (
+	stripeSubscription: StripeSubscriptionDeletedContext["stripeSubscription"],
+): boolean => {
+	const trialEnd = stripeSubscription.trial_end;
+	const endedAt = stripeSubscription.ended_at;
+
+	if (!trialEnd || !endedAt) return false;
+
+	// If ended_at equals trial_end, the subscription was canceled at trial end
+	return trialEnd === endedAt;
+};
+
 /**
  * Creates a single invoice for all usage-based (arrear) prices across all customer products
  * when a subscription is deleted.
- * Skips if the deletion was initiated by Autumn (e.g., during an upgrade flow).
+ *
+ * Skips creating an arrear invoice if:
+ * 1. The subscription has metered items (Stripe handles metered billing automatically)
+ * 2. The cancellation was immediate (not end-of-period) - we don't charge overage on immediate cancels
+ * 3. The subscription was canceled at trial end - trial usage is free
+ *
+ * Note: Autumn-initiated deletions are filtered out before this via the lock mechanism
+ * in setupStripeSubscriptionDeletedContext.
  */
 export const processConsumablePricesForSubscriptionDeleted = async ({
 	ctx,
@@ -23,9 +50,23 @@ export const processConsumablePricesForSubscriptionDeleted = async ({
 	const { db } = ctx;
 	const { stripeSubscription, fullCustomer, customerProducts } = eventContext;
 
-	// Check upcoming invoice
+	// Skip if subscription has metered items - Stripe handles metered billing automatically
 	if (stripeSubscriptionHasMeteredItems(stripeSubscription)) return;
 
+	// Skip if this was an immediate cancellation (not end-of-period)
+	// We only bill arrear usage when the subscription naturally ends at period end
+	// This matches the behavior of customer-level consumables (metered) where
+	// Stripe also doesn't charge overage on immediate cancels
+	if (wasImmediateStripeCancellation(stripeSubscription)) return;
+
+	// Skip if the subscription was canceled at trial end - trial usage is free
+	if (wasTrialCancellation(stripeSubscription)) {
+		ctx.logger.info(
+			"[subscription.deleted] Subscription canceled at trial end, skipping consumable charges",
+		);
+		return;
+	}
+
 	// 1. Generate arrear line items
 	// Use ended_at (when subscription was actually deleted) as the period end.
 	// This handles mid-cycle cancellations correctly - we bill up to when they canceled,
diff --git a/server/src/internal/billing/v2/cancelTests.md b/server/src/internal/billing/v2/cancelTests.md
index 7b9d22ad2..cde8024ad 100644
--- a/server/src/internal/billing/v2/cancelTests.md
+++ b/server/src/internal/billing/v2/cancelTests.md
@@ -25,6 +25,9 @@ Tests for canceling add-on products in various scenarios.
 | mergedAddOn1.test.ts | merged/addOn/ | Cancel add-on end-of-cycle → advance clock → verify add-on removed | [ ] |
 | mergedAddOn4.test.ts | merged/addOn/ | Cancel add-on immediately while scheduled product exists → verify scheduled preserved | [ ] |
 | renew-addon1.test.ts | integration/billing/renew/ | Cancel add-on end-of-cycle, then re-attach (renew) → verify canceled_at is null | [ ] |
+| cancel-addon4.test.ts | integration/billing/cancel/add-ons/ | Cancel usage add-on with failed payment → verify invoice still created | [ ] |
+| mergedAddOn3.test.ts | merged/addOn/ | Cancel add-on immediately with entity → verify pro still active | [ ] |
+| mergedAddOn5.test.ts | merged/addOn/ | Cancel add-on immediately with scheduled → advance clock → verify scheduled becomes active | [ ] |
 
 ---
 
@@ -33,10 +36,7 @@ Basic tests for canceling immediately (non-add-on products).
 
 | Legacy File | Location | Description | Status |
 |-------------|----------|-------------|--------|
-| cancel-addon4.test.ts | integration/billing/cancel/add-ons/ | Cancel usage add-on with failed payment → verify invoice still created | [ ] |
 | upgrade7.test.ts | attach/upgrade/ | Cancel immediately then attach premium → verify upgrade path | [ ] |
-| mergedAddOn3.test.ts | merged/addOn/ | Cancel add-on immediately with entity → verify pro still active | [ ] |
-| mergedAddOn5.test.ts | merged/addOn/ | Cancel add-on immediately with scheduled → advance clock → verify scheduled becomes active | [ ] |
 | mergedGroup1.test.ts | merged/group/ | Cancel scheduled product from different group immediately → verify sub correct | [ ] |
 | mergedGroup2.test.ts | merged/group/ | Cancel scheduled product from different group immediately | [ ] |
 
diff --git a/server/src/internal/billing/v2/utils/billingContext/getTrialStateTransition.ts b/server/src/internal/billing/v2/utils/billingContext/getTrialStateTransition.ts
index 3fbb0dba9..4859cb278 100644
--- a/server/src/internal/billing/v2/utils/billingContext/getTrialStateTransition.ts
+++ b/server/src/internal/billing/v2/utils/billingContext/getTrialStateTransition.ts
@@ -11,6 +11,7 @@ export const getTrialStateTransition = ({
 	const isTrialing = isStripeSubscriptionTrialing(
 		billingContext.stripeSubscription,
 	);
+
 	const willBeTrialing = billingContextHasTrial({ billingContext });
 
 	return { isTrialing, willBeTrialing };
diff --git a/server/src/internal/billing/v2/utils/billingPlan/billingPlanToNextCyclePreview.ts b/server/src/internal/billing/v2/utils/billingPlan/billingPlanToNextCyclePreview.ts
index 898140589..4b2bc5e8a 100644
--- a/server/src/internal/billing/v2/utils/billingPlan/billingPlanToNextCyclePreview.ts
+++ b/server/src/internal/billing/v2/utils/billingPlan/billingPlanToNextCyclePreview.ts
@@ -2,9 +2,9 @@ import {
 	type BillingPreviewResponse,
 	cp,
 	cusProductsToPrices,
-	formatMs,
 	getCycleEnd,
 	getSmallestInterval,
+	hasCustomerProductEnded,
 	sumValues,
 } from "@autumn/shared";
 import type { AutumnContext } from "@/honoUtils/HonoEnv";
@@ -37,7 +37,8 @@ export const billingPlanToNextCyclePreview = ({
 		...insertCustomerProducts,
 		...(updatedCustomerProduct ? [updatedCustomerProduct] : []),
 	];
-	const customerProducts = allCustomerProducts.filter(
+
+	let customerProducts = allCustomerProducts.filter(
 		(customerProduct) =>
 			cp(customerProduct).paid().recurring().hasActiveStatus().valid,
 	);
@@ -51,16 +52,6 @@ export const billingPlanToNextCyclePreview = ({
 
 	if (!smallestInterval) return undefined;
 
-	ctx.logger.debug(
-		`[billingPlanToNextCyclePreview] Billing cycle anchor: ${formatMs(billingCycleAnchorMs)}`,
-	);
-	ctx.logger.debug(
-		`[billingPlanToNextCyclePreview] Smallest interval: ${smallestInterval.interval}`,
-	);
-	ctx.logger.debug(
-		`[billingPlanToNextCyclePreview] Current epoch ms: ${formatMs(billingContext.currentEpochMs)}`,
-	);
-
 	const nextCycleStart = getCycleEnd({
 		anchor: billingCycleAnchorMs,
 		interval: smallestInterval.interval,
@@ -69,9 +60,13 @@ export const billingPlanToNextCyclePreview = ({
 		floor: billingCycleAnchorMs,
 	});
 
-	ctx.logger.debug(
-		`[billingPlanToNextCyclePreview] Next cycle start: ${formatMs(nextCycleStart)}`,
-	);
+	customerProducts = customerProducts.filter((customerProduct) => {
+		return !hasCustomerProductEnded(customerProduct, {
+			nowMs: nextCycleStart,
+		});
+	});
+
+	if (customerProducts.length === 0) return undefined;
 
 	const autumnLineItems = customerProducts.flatMap((customerProduct) =>
 		customerProductToLineItems({
diff --git a/server/src/internal/billing/v2/utils/initFullCustomerProduct/initCustomerProduct.ts b/server/src/internal/billing/v2/utils/initFullCustomerProduct/initCustomerProduct.ts
index df1d69cf1..b829038d4 100644
--- a/server/src/internal/billing/v2/utils/initFullCustomerProduct/initCustomerProduct.ts
+++ b/server/src/internal/billing/v2/utils/initFullCustomerProduct/initCustomerProduct.ts
@@ -42,6 +42,8 @@ export const initCustomerProduct = ({
 	const initCustomerProductStatus = () => {
 		if (initOptions?.status) return initOptions?.status;
 
+		// 1 minute tolerance to determine if customer product should be scheduled. (for test clock time frozen issues)
+		// const TOLERANCE_MS = ms.minutes(1);
 		if (startsAt && startsAt > now) {
 			return CusProductStatus.Scheduled;
 		}
diff --git a/server/src/internal/billing/v2/utils/lineItems/customerProductToArrearLineItems.ts b/server/src/internal/billing/v2/utils/lineItems/customerProductToArrearLineItems.ts
index a82ce2a61..544d531b8 100644
--- a/server/src/internal/billing/v2/utils/lineItems/customerProductToArrearLineItems.ts
+++ b/server/src/internal/billing/v2/utils/lineItems/customerProductToArrearLineItems.ts
@@ -39,7 +39,6 @@ export const customerProductToArrearLineItems = ({
 	updateCustomerEntitlements: UpdateCustomerEntitlement[];
 } => {
 	const lineItems: LineItem[] = [];
-	const billedCusEnts: FullCusEntWithFullCusProduct[] = [];
 
 	let filteredPrices = cusProductToPrices({ cusProduct: customerProduct });
 
@@ -51,6 +50,8 @@ export const customerProductToArrearLineItems = ({
 
 	const updateCustomerEntitlements: UpdateCustomerEntitlement[] = [];
 
+	// If is trialing, or trial just ended, skip this...?
+
 	for (const cusPrice of customerProduct.customer_prices) {
 		const price = cusPrice.price;
 
diff --git a/server/src/internal/customers/attach/attachFunctions/addProductFlow/handlePaidProduct.ts b/server/src/internal/customers/attach/attachFunctions/addProductFlow/handlePaidProduct.ts
index 59d21d7da..fece506c5 100644
--- a/server/src/internal/customers/attach/attachFunctions/addProductFlow/handlePaidProduct.ts
+++ b/server/src/internal/customers/attach/attachFunctions/addProductFlow/handlePaidProduct.ts
@@ -268,6 +268,7 @@ export const handlePaidProduct = async ({
 				carryExistingUsages: config.carryUsage,
 				scenario: AttachScenario.New,
 				trialEndsAt: trialEndsAt || undefined,
+				startsAt: attachParams.now,
 				logger,
 			}),
 		);
diff --git a/server/src/internal/customers/cusProducts/actions/expireAndActivateDefault.ts b/server/src/internal/customers/cusProducts/actions/expireAndActivateDefault.ts
index 20f9735b9..4fcc98c1e 100644
--- a/server/src/internal/customers/cusProducts/actions/expireAndActivateDefault.ts
+++ b/server/src/internal/customers/cusProducts/actions/expireAndActivateDefault.ts
@@ -67,6 +67,11 @@ export const expireCustomerProductAndActivateDefault = async ({
 			: cp,
 	);
 
+	ctx.logger.info(
+		`IS ENTITY SCOPED: ${isCustomerProductEntityScoped(customerProduct)}`,
+	);
+	ctx.logger.info(`IS ADD ON: ${isCustomerProductAddOn(customerProduct)}`);
+
 	// 3. Skip default activation for add-ons
 	if (isCustomerProductAddOn(customerProduct)) return { updates };
 	if (isCustomerProductEntityScoped(customerProduct)) return { updates };
diff --git a/server/src/utils/scriptUtils/testUtils/initCustomerV3.ts b/server/src/utils/scriptUtils/testUtils/initCustomerV3.ts
index 7dabc04cd..85224394e 100644
--- a/server/src/utils/scriptUtils/testUtils/initCustomerV3.ts
+++ b/server/src/utils/scriptUtils/testUtils/initCustomerV3.ts
@@ -64,7 +64,8 @@ export const initCustomerV3 = async ({
 		stripe_id: stripeCus.id,
 		internalOptions: {
 			disable_defaults: !withDefault,
-			default_group: defaultGroup,
+			// Only pass default_group when defaults are enabled
+			...(withDefault && { default_group: defaultGroup }),
 		},
 		skipWebhooks,
 	});
diff --git a/server/tests/core/cancel/cancel4.test.ts b/server/tests/core/cancel/cancel4.test.ts
deleted file mode 100644
index a6b0c55c2..000000000
--- a/server/tests/core/cancel/cancel4.test.ts
+++ /dev/null
@@ -1,135 +0,0 @@
-import { beforeAll, describe, expect, test } from "bun:test";
-import {
-	type AppEnv,
-	CusProductStatus,
-	LegacyVersion,
-	type Organization,
-} from "@autumn/shared";
-import { TestFeature } from "@tests/setup/v2Features.js";
-import { attachAndExpectCorrect } from "@tests/utils/expectUtils/expectAttach.js";
-import { expectProductAttached } from "@tests/utils/expectUtils/expectProductAttached.js";
-import ctx from "@tests/utils/testInitUtils/createTestContext.js";
-import chalk from "chalk";
-import type { Stripe } from "stripe";
-import type { DrizzleCli } from "@/db/initDrizzle.js";
-import { AutumnInt } from "@/external/autumn/autumnCli.js";
-import {
-	constructArrearItem,
-	constructFeatureItem,
-} from "@/utils/scriptUtils/constructItem.js";
-import { constructProduct } from "@/utils/scriptUtils/createTestProducts.js";
-import { initCustomerV3 } from "@/utils/scriptUtils/testUtils/initCustomerV3.js";
-import { initProductsV0 } from "@/utils/scriptUtils/testUtils/initProductsV0.js";
-
-const premium = constructProduct({
-	id: "premium",
-	items: [constructArrearItem({ featureId: TestFeature.Words })],
-	type: "premium",
-});
-const addOn = constructProduct({
-	id: "free_add_on",
-	items: [constructFeatureItem({ featureId: TestFeature.Credits })],
-	type: "free",
-	isAddOn: true,
-	isDefault: false,
-});
-
-const ops = [
-	{
-		product: premium,
-		results: [{ product: premium, status: CusProductStatus.Active }],
-		skipSubCheck: true,
-	},
-	{
-		product: addOn,
-		results: [
-			{ product: premium, status: CusProductStatus.Active },
-			{ product: addOn, status: CusProductStatus.Active },
-		],
-	},
-];
-
-const testCase = "cancel4";
-describe(`${chalk.yellowBright("cancel4: Cancelling free add on product")}`, () => {
-	const customerId = testCase;
-	const autumn: AutumnInt = new AutumnInt({ version: LegacyVersion.v1_4 });
-
-	let stripeCli: Stripe;
-	let db: DrizzleCli;
-	let org: Organization;
-	let env: AppEnv;
-
-	beforeAll(async () => {
-		await initProductsV0({
-			ctx,
-			products: [premium, addOn],
-			prefix: testCase,
-			customerId,
-		});
-
-		await initCustomerV3({
-			ctx,
-			customerId,
-			attachPm: "success",
-			withTestClock: false,
-		});
-
-		stripeCli = ctx.stripeCli;
-		db = ctx.db;
-		org = ctx.org;
-		env = ctx.env;
-	});
-
-	const entities = [
-		{
-			id: "1",
-			name: "Entity 1",
-			feature_id: TestFeature.Users,
-		},
-		{
-			id: "2",
-			name: "Entity 2",
-			feature_id: TestFeature.Users,
-		},
-	];
-
-	test("should run operations", async () => {
-		await autumn.entities.create(customerId, entities);
-
-		for (let index = 0; index < ops.length; index++) {
-			const op = ops[index];
-			try {
-				await attachAndExpectCorrect({
-					autumn,
-					customerId,
-					product: op.product,
-					stripeCli,
-					db,
-					org,
-					env,
-					skipSubCheck: op.skipSubCheck,
-				});
-			} catch (error) {
-				console.log(`Operation failed: ${op.product.id}, index: ${index}`);
-				throw error;
-			}
-		}
-	});
-
-	test("should track usage cancel, advance test clock and have correct invoice", async () => {
-		await autumn.cancel({
-			customer_id: customerId,
-			product_id: addOn.id,
-			cancel_immediately: true,
-		});
-
-		const cus = await autumn.customers.get(customerId);
-		expectProductAttached({
-			customer: cus,
-			product: premium,
-		});
-
-		const products = cus.products.filter((p) => p.group === addOn.group);
-		expect(products.length).toBe(1);
-	});
-});
diff --git a/server/tests/integration/billing/cancel/add-ons/cancel-addon2.test.ts b/server/tests/integration/billing/cancel/add-ons/cancel-addon2.test.ts
deleted file mode 100644
index 0e3cb0854..000000000
--- a/server/tests/integration/billing/cancel/add-ons/cancel-addon2.test.ts
+++ /dev/null
@@ -1,100 +0,0 @@
-import { beforeAll, describe, expect, test } from "bun:test";
-import { ApiVersion, CusProductStatus } from "@autumn/shared";
-import { TestFeature } from "@tests/setup/v2Features.js";
-import ctx from "@tests/utils/testInitUtils/createTestContext.js";
-import chalk from "chalk";
-import { AutumnInt } from "@/external/autumn/autumnCli.js";
-import { constructFeatureItem } from "@/utils/scriptUtils/constructItem.js";
-import { constructProduct } from "@/utils/scriptUtils/createTestProducts.js";
-import { initCustomerV3 } from "@/utils/scriptUtils/testUtils/initCustomerV3.js";
-import { initProductsV0 } from "@/utils/scriptUtils/testUtils/initProductsV0.js";
-import { expectSubToBeCorrect } from "@tests/merged/mergeUtils/expectSubCorrect";
-import {
-	expectProductAttached,
-	expectProductNotAttached,
-} from "@tests/utils/expectUtils/expectProductAttached";
-
-const pro = constructProduct({
-	type: "pro",
-	isDefault: false,
-
-	items: [
-		constructFeatureItem({
-			featureId: TestFeature.Messages,
-			includedUsage: 50,
-		}),
-	],
-});
-const monthlyAddOn = constructProduct({
-	id: "monthlyAddOn",
-	type: "pro",
-	isAddOn: true,
-	items: [
-		constructFeatureItem({
-			featureId: TestFeature.Messages,
-			includedUsage: 300,
-		}),
-	],
-});
-
-describe(`${chalk.yellowBright("cancel-addon2: Attach pro + monthly add on, then cancel monthly add on immediately")}`, () => {
-	const customerId = "cancel-addon2";
-	const autumn: AutumnInt = new AutumnInt({ version: ApiVersion.V1_2 });
-
-	beforeAll(async () => {
-		await initCustomerV3({
-			ctx,
-			customerId,
-			customerData: {},
-			attachPm: "success",
-			withTestClock: true,
-		});
-
-		await initProductsV0({
-			ctx,
-			products: [pro, monthlyAddOn],
-			prefix: customerId,
-		});
-	});
-
-	test("should attach pro and monthly add on, then cancel monthly add on immediately", async () => {
-		await autumn.attach({
-			customer_id: customerId,
-			product_id: pro.id,
-		});
-
-		await autumn.attach({
-			customer_id: customerId,
-			product_id: monthlyAddOn.id,
-		});
-
-		await autumn.cancel({
-			customer_id: customerId,
-			product_id: monthlyAddOn.id,
-			cancel_immediately: true,
-		});
-
-		const customer = await autumn.customers.get(customerId);
-		expectProductAttached({
-			customer,
-			product: pro,
-			status: CusProductStatus.Active,
-		});
-
-		expectProductNotAttached({
-			customer,
-			product: monthlyAddOn,
-		});
-
-		// 1. Subs should be correct
-		await expectSubToBeCorrect({
-			db: ctx.db,
-			customerId,
-			org: ctx.org,
-			env: ctx.env,
-			shouldBeCanceled: false,
-		});
-
-		expect(customer.invoices?.[0]?.total).toBe(-20);
-	});
-});
diff --git a/server/tests/integration/billing/cancel/add-ons/cancel-addon3.test.ts b/server/tests/integration/billing/cancel/add-ons/cancel-addon3.test.ts
deleted file mode 100644
index 8ea24a3bf..000000000
--- a/server/tests/integration/billing/cancel/add-ons/cancel-addon3.test.ts
+++ /dev/null
@@ -1,114 +0,0 @@
-import { beforeAll, describe, expect, test } from "bun:test";
-import { ApiVersion, CusProductStatus } from "@autumn/shared";
-import { TestFeature } from "@tests/setup/v2Features.js";
-import ctx from "@tests/utils/testInitUtils/createTestContext.js";
-import chalk from "chalk";
-import { AutumnInt } from "@/external/autumn/autumnCli.js";
-import {
-	constructArrearItem,
-	constructFeatureItem,
-} from "@/utils/scriptUtils/constructItem.js";
-import { constructProduct } from "@/utils/scriptUtils/createTestProducts.js";
-import { initCustomerV3 } from "@/utils/scriptUtils/testUtils/initCustomerV3.js";
-import { initProductsV0 } from "@/utils/scriptUtils/testUtils/initProductsV0.js";
-import { expectSubToBeCorrect } from "@tests/merged/mergeUtils/expectSubCorrect";
-import {
-	expectProductAttached,
-	expectProductNotAttached,
-} from "@tests/utils/expectUtils/expectProductAttached";
-import { timeout } from "@tests/utils/genUtils";
-
-const pro = constructProduct({
-	type: "pro",
-	isDefault: false,
-
-	items: [
-		constructFeatureItem({
-			featureId: TestFeature.Messages,
-			includedUsage: 0,
-		}),
-	],
-});
-const monthlyAddOn = constructProduct({
-	id: "monthlyAddOn",
-	type: "pro",
-	isAddOn: true,
-	items: [
-		constructArrearItem({
-			featureId: TestFeature.Messages,
-			includedUsage: 0,
-			billingUnits: 1,
-			price: 0.5,
-		}),
-	],
-});
-
-describe(`${chalk.yellowBright("cancel-addon3: Attach pro + usage add on, use overage, then cancel usage add on immediately")}`, () => {
-	const customerId = "cancel-addon3";
-	const autumn: AutumnInt = new AutumnInt({ version: ApiVersion.V1_2 });
-
-	beforeAll(async () => {
-		await initCustomerV3({
-			ctx,
-			customerId,
-			customerData: {},
-			attachPm: "success",
-			withTestClock: true,
-		});
-
-		await initProductsV0({
-			ctx,
-			products: [pro, monthlyAddOn],
-			prefix: customerId,
-		});
-	});
-
-	test("should attach pro and monthly add on, then cancel monthly add on immediately", async () => {
-		await autumn.attach({
-			customer_id: customerId,
-			product_id: pro.id,
-		});
-
-		await autumn.attach({
-			customer_id: customerId,
-			product_id: monthlyAddOn.id,
-		});
-
-		await autumn.track({
-			customer_id: customerId,
-			feature_id: TestFeature.Messages,
-			value: 1000,
-		});
-
-		await timeout(3000);
-
-		await autumn.cancel({
-			customer_id: customerId,
-			product_id: monthlyAddOn.id,
-			cancel_immediately: true,
-		});
-
-		const customer = await autumn.customers.get(customerId);
-		expectProductAttached({
-			customer,
-			product: pro,
-			status: CusProductStatus.Active,
-		});
-
-		expectProductNotAttached({
-			customer,
-			product: monthlyAddOn,
-		});
-
-		// 1. Subs should be correct
-		await expectSubToBeCorrect({
-			db: ctx.db,
-			customerId,
-			org: ctx.org,
-			env: ctx.env,
-			shouldBeCanceled: false,
-		});
-
-		expect(customer.invoices?.[0]?.total).toBe(500 - 20);
-	});
-});
diff --git a/server/tests/integration/billing/stripe-webhooks/invoice-created/invoice-created-consumable-trial.test.ts b/server/tests/integration/billing/stripe-webhooks/invoice-created/invoice-created-consumable-trial.test.ts
new file mode 100644
index 000000000..2cb4992f9
--- /dev/null
+++ b/server/tests/integration/billing/stripe-webhooks/invoice-created/invoice-created-consumable-trial.test.ts
@@ -0,0 +1,298 @@
+/**
+ * Invoice Created Webhook Tests - Consumable Prices During Trial
+ *
+ * Tests for handling the `invoice.created` Stripe webhook event when a customer
+ * is on a trial with consumable (usage-in-arrear) prices. When a trial ends,
+ * the first invoice after trial should NOT include consumable charges from
+ * the trial period - trial usage is "free".
+ *
+ * Key behavior tested:
+ * - Trial ends → first invoice has base price only (no consumable overage)
+ * - Balance resets after trial ends
+ * - Works for both customer-level and entity-level products
+ */
+
+import { test } from "bun:test";
+import type { ApiCustomerV3 } from "@autumn/shared";
+import { expectCustomerFeatureCorrect } from "@tests/integration/billing/utils/expectCustomerFeatureCorrect";
+import { expectCustomerInvoiceCorrect } from "@tests/integration/billing/utils/expectCustomerInvoiceCorrect";
+import { expectProductActive } from "@tests/integration/billing/utils/expectCustomerProductCorrect";
+import { expectProductNotTrialing } from "@tests/integration/billing/utils/expectCustomerProductTrialing";
+import { TestFeature } from "@tests/setup/v2Features";
+import { items } from "@tests/utils/fixtures/items";
+import { products } from "@tests/utils/fixtures/products";
+import { advanceTestClock } from "@tests/utils/stripeUtils";
+import { initScenario, s } from "@tests/utils/testInitUtils/initScenario";
+import chalk from "chalk";
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// TEST 1: Customer-level - Trial ends with overage → no consumable charge
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Scenario:
+ * - Customer attaches Pro with 14-day trial + consumable messages (100 included, $0.10/unit)
+ * - Track 250 messages during trial (150 overage)
+ * - Advance past trial end (14 days)
+ *
+ * Expected Result:
+ * - First invoice after trial: $20 base only (no $15 overage charge for trial usage)
+ * - Balance should be reset to 100 (included usage)
+ */
+test(`${chalk.yellowBright("invoice.created trial: customer-level overage during trial → no charge after trial ends")}`, async () => {
+	const customerId = "inv-trial-cus-overage";
+
+	const consumableItem = items.consumableMessages({ includedUsage: 100 });
+
+	const proTrial = products.proWithTrial({
+		id: "pro-trial",
+		items: [consumableItem],
+		trialDays: 14,
+	});
+
+	const { autumnV1, advancedTo } = await initScenario({
+		customerId,
+		setup: [
+			s.customer({ paymentMethod: "success" }),
+			s.products({ list: [proTrial] }),
+		],
+		actions: [
+			s.attach({ productId: proTrial.id }),
+			s.track({ featureId: TestFeature.Messages, value: 250 }), // 150 overage
+			s.advanceTestClock({ days: 16 }), // Advance past trial end
+		],
+	});
+
+	// Verify customer state after trial ends
+	const customerAfterTrialEnd =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+
+	// Product should be active (not trialing anymore)
+	await expectProductActive({
+		customer: customerAfterTrialEnd,
+		productId: proTrial.id,
+	});
+
+	await expectProductNotTrialing({
+		customer: customerAfterTrialEnd,
+		productId: proTrial.id,
+		nowMs: advancedTo,
+	});
+
+	// Balance should be reset to 100 (included usage) after trial ends
+	expectCustomerFeatureCorrect({
+		customer: customerAfterTrialEnd,
+		featureId: TestFeature.Messages,
+		balance: -150, // trial ending doesn't reset consumable balance.
+	});
+
+	// Should have 1 invoice: first real invoice after trial = $20 base only
+	// NO overage charge for the 150 messages tracked during trial
+	expectCustomerInvoiceCorrect({
+		customer: customerAfterTrialEnd,
+		count: 2,
+		latestTotal: 20, // Only base price, no overage
+		latestInvoiceProductId: proTrial.id,
+	});
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// TEST 2: Entity-level - Trial ends with overage → no consumable charge
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Scenario:
+ * - Create 1 entity
+ * - Attach Pro with 14-day trial + consumable messages to entity
+ * - Track 200 messages for entity during trial (100 overage)
+ * - Advance past trial end
+ *
+ * Expected Result:
+ * - First invoice after trial: $20 base only (no $10 overage charge)
+ * - Entity balance should be reset to 100
+ */
+test(`${chalk.yellowBright("invoice.created trial: entity-level overage during trial → no charge after trial ends")}`, async () => {
+	const customerId = "inv-trial-ent-overage";
+
+	const consumableItem = items.consumableMessages({ includedUsage: 100 });
+
+	const monthlyPriceItem = items.monthlyPrice();
+	const proTrial = products.base({
+		id: "pro-trial",
+		items: [monthlyPriceItem],
+		trialDays: 14,
+	});
+
+	const { autumnV1, advancedTo, entities, ctx, testClockId } =
+		await initScenario({
+			customerId,
+			setup: [
+				s.customer({ paymentMethod: "success" }),
+				s.products({ list: [proTrial] }),
+				s.entities({ count: 1, featureId: TestFeature.Users }),
+			],
+			actions: [s.attach({ productId: proTrial.id, entityIndex: 0 })],
+		});
+
+	await autumnV1.subscriptions.update(
+		{
+			customer_id: customerId,
+			product_id: proTrial.id,
+			entity_id: entities[0].id,
+			items: [consumableItem, monthlyPriceItem],
+		},
+		{
+			timeout: 2000,
+		},
+	);
+
+	await autumnV1.track({
+		customer_id: customerId,
+		feature_id: TestFeature.Messages,
+		value: 200,
+		entity_id: entities[0].id,
+	});
+
+	await advanceTestClock({
+		stripeCli: ctx.stripeCli,
+		testClockId: testClockId!,
+		numberOfDays: 16,
+	});
+
+	const entityId = entities[0].id;
+
+	// Verify entity state after trial ends
+	const entityAfterTrialEnd = await autumnV1.entities.get(customerId, entityId);
+
+	// Product should be active (not trialing anymore)
+	await expectProductActive({
+		customer: entityAfterTrialEnd,
+		productId: proTrial.id,
+	});
+
+	await expectProductNotTrialing({
+		customer: entityAfterTrialEnd,
+		productId: proTrial.id,
+		nowMs: advancedTo,
+	});
+
+	// Balance should be reset to 100 after trial ends
+	expectCustomerFeatureCorrect({
+		customer: entityAfterTrialEnd,
+		featureId: TestFeature.Messages,
+		balance: -100,
+	});
+
+	// Check invoices at customer level
+	const customerAfterTrialEnd =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+
+	// After first update to add consumable, a $0 invoice is created.
+	// For second udpate, NO OVERAGE CHARGES.
+	// NO overage charge for the 100 messages overage tracked during trial
+	expectCustomerInvoiceCorrect({
+		customer: customerAfterTrialEnd,
+		count: 3,
+		latestTotal: 20, // Only base price, no overage
+		latestInvoiceProductId: proTrial.id,
+	});
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// TEST 3: Multiple entities with trial → no consumable charge on any
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Scenario:
+ * - Create 2 entities
+ * - Attach Pro with 14-day trial to both entities (on same subscription)
+ * - Track overage on both entities during trial:
+ *   - Entity 0: 200 messages (100 overage → would be $10)
+ *   - Entity 1: 250 messages (150 overage → would be $15)
+ * - Advance past trial end
+ *
+ * Expected Result:
+ * - First invoice after trial: $40 base ($20 x 2) only
+ * - NO overage charges for either entity's trial usage
+ * - Both entity balances should be reset to 100
+ */
+test(`${chalk.yellowBright("invoice.created trial: multiple entities with overage during trial → no charge after trial ends")}`, async () => {
+	const customerId = "inv-trial-multi-ent";
+
+	const consumableItem = items.consumableMessages({ includedUsage: 100 });
+
+	const proTrial = products.proWithTrial({
+		id: "pro-trial",
+		items: [consumableItem],
+		trialDays: 14,
+	});
+
+	const { autumnV1, advancedTo, entities } = await initScenario({
+		customerId,
+		setup: [
+			s.customer({ paymentMethod: "success" }),
+			s.products({ list: [proTrial] }),
+			s.entities({ count: 2, featureId: TestFeature.Users }),
+		],
+		actions: [
+			s.attach({ productId: proTrial.id, entityIndex: 0 }),
+			s.attach({ productId: proTrial.id, entityIndex: 1, timeout: 2000 }),
+			s.track({ featureId: TestFeature.Messages, value: 200, entityIndex: 0 }), // 100 overage
+			s.track({ featureId: TestFeature.Messages, value: 250, entityIndex: 1 }), // 150 overage
+			s.advanceTestClock({ days: 16 }), // Advance past trial end
+		],
+	});
+
+	// Verify entity 0 state after trial ends
+	const entity0AfterTrialEnd = await autumnV1.entities.get(
+		customerId,
+		entities[0].id,
+	);
+	await expectProductActive({
+		customer: entity0AfterTrialEnd,
+		productId: proTrial.id,
+	});
+	await expectProductNotTrialing({
+		customer: entity0AfterTrialEnd,
+		productId: proTrial.id,
+		nowMs: advancedTo,
+	});
+	expectCustomerFeatureCorrect({
+		customer: entity0AfterTrialEnd,
+		featureId: TestFeature.Messages,
+		balance: 100,
+	});
+
+	// Verify entity 1 state after trial ends
+	const entity1AfterTrialEnd = await autumnV1.entities.get(
+		customerId,
+		entities[1].id,
+	);
+	await expectProductActive({
+		customer: entity1AfterTrialEnd,
+		productId: proTrial.id,
+	});
+	await expectProductNotTrialing({
+		customer: entity1AfterTrialEnd,
+		productId: proTrial.id,
+		nowMs: advancedTo,
+	});
+	expectCustomerFeatureCorrect({
+		customer: entity1AfterTrialEnd,
+		featureId: TestFeature.Messages,
+		balance: -250,
+	});
+
+	// Check invoices at customer level
+	const customerAfterTrialEnd =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+
+	// Should have 1 invoice (both entities share subscription during trial)
+	// First real invoice = $40 base ($20 x 2) only
+	// NO overage charges for either entity's trial usage ($10 + $15 = $25 would be charged if not trial)
+	expectCustomerInvoiceCorrect({
+		customer: customerAfterTrialEnd,
+		count: 3,
+		latestTotal: 40, // Only base price for both entities, no overage
+	});
+});
diff --git a/server/tests/integration/billing/stripe-webhooks/invoice-created/invoice-created-entity-consumable.test.ts b/server/tests/integration/billing/stripe-webhooks/invoice-created/invoice-created-entity-consumable.test.ts
index 104d44f56..7b2dcbfd7 100644
--- a/server/tests/integration/billing/stripe-webhooks/invoice-created/invoice-created-entity-consumable.test.ts
+++ b/server/tests/integration/billing/stripe-webhooks/invoice-created/invoice-created-entity-consumable.test.ts
@@ -1,30 +1,25 @@
 /**
- * Invoice Created Webhook Tests - Entity + Customer Consumables with Cancel
+ * Invoice Created Webhook Tests - Entity Consumables (Renewal)
  *
- * Tests for handling the `invoice.created` Stripe webhook when both entity-level
- * and customer-level consumable products exist, particularly around cancellation.
+ * Tests for handling the `invoice.created` Stripe webhook for entity-level
+ * consumable products during regular renewal cycles.
  *
- * Key concern:
- * - Entity-level consumables use new invoice line items method (added during invoice.created)
- * - Customer-level consumables use Stripe metered prices (legacy, billed automatically)
- * - subscription.deleted creates arrear invoice for entity products
- * - invoice.created ALSO fires and may try to add line items
- * - Risk of DOUBLE BILLING for entity-level consumables
+ * Key behaviors:
+ * - Entity-level consumables use invoice line items method (added during invoice.created)
+ * - Overage is billed exactly once via invoice line items
+ * - Balance resets after each cycle
+ * - Each entity's overage is rounded up to billing units INDIVIDUALLY
  *
- * Expected behaviors:
- * - Entity-level consumables should only be billed ONCE
- * - Customer-level consumables with meters should not get duplicate charges
+ * For cancel-related consumable tests, see:
+ * - cancel/end-of-cycle/cancel-end-of-cycle-consumable.test.ts
+ * - cancel/immediately/cancel-immediately-consumable.test.ts
  */
 
 import { expect, test } from "bun:test";
 import type { ApiCustomerV3 } from "@autumn/shared";
 import { expectCustomerFeatureCorrect } from "@tests/integration/billing/utils/expectCustomerFeatureCorrect";
 import { expectCustomerInvoiceCorrect } from "@tests/integration/billing/utils/expectCustomerInvoiceCorrect";
-import {
-	expectProductActive,
-	expectProductCanceling,
-	expectProductNotPresent,
-} from "@tests/integration/billing/utils/expectCustomerProductCorrect";
+import { expectProductActive } from "@tests/integration/billing/utils/expectCustomerProductCorrect";
 import { expectStripeInvoiceLineItemPeriodCorrect } from "@tests/integration/billing/utils/stripe/expectStripeInvoiceLineItemPeriodCorrect";
 import { TestFeature } from "@tests/setup/v2Features";
 import { items } from "@tests/utils/fixtures/items";
@@ -35,7 +30,7 @@ import chalk from "chalk";
 import { addMonths } from "date-fns";
 
 // ═══════════════════════════════════════════════════════════════════════════════
-// TEST 3: Regular cycle renewal (no cancel) - entity consumable
+// TEST 1: Regular cycle renewal (no cancel) - entity consumable
 // ═══════════════════════════════════════════════════════════════════════════════
 
 /**
@@ -123,256 +118,6 @@ test(`${chalk.yellowBright("invoice.created entity: regular renewal - overage bi
 	});
 });
 
-// ═══════════════════════════════════════════════════════════════════════════════
-// TEST 1: Entity consumable + Customer consumable - cancel customer end of cycle
-// ═══════════════════════════════════════════════════════════════════════════════
-
-/**
- * Scenario:
- * - Customer has customer-level Pro with consumable messages (uses Stripe meters)
- * - Customer also has entity-level Pro with consumable messages (uses invoice line items)
- * - Track overage on BOTH customer and entity
- * - Cancel CUSTOMER-level product end of cycle (entity stays active)
- * - Advance to next invoice
-
- */
-test(`${chalk.yellowBright("invoice.created entity+customer: cancel customer end of cycle - no double billing")}`, async () => {
-	const customerId = "inv-created-ent-cus-eoc";
-
-	// Customer-level consumable messages (will use Stripe meters)
-	const customerConsumable = items.consumableMessages({ includedUsage: 100 });
-
-	// Entity-level consumable messages (will use invoice line items)
-	const entityConsumable = items.consumableMessages({
-		includedUsage: 100,
-		entityFeatureId: TestFeature.Users,
-	});
-
-	// Two separate products - both $20 base
-	const customerPro = products.pro({
-		id: "customer-pro",
-		items: [customerConsumable],
-	});
-
-	const entityPro = products.pro({
-		id: "entity-pro",
-		items: [entityConsumable],
-	});
-
-	const { autumnV1, ctx, testClockId, entities } = await initScenario({
-		customerId,
-		setup: [
-			s.customer({ paymentMethod: "success" }),
-			s.products({ list: [customerPro, entityPro] }),
-			s.entities({ count: 1, featureId: TestFeature.Users }),
-		],
-		actions: [
-			s.attach({ productId: customerPro.id }), // Customer-level
-			s.attach({ productId: entityPro.id, entityIndex: 0, timeout: 4000 }), // Entity-level
-			s.track({ featureId: TestFeature.Messages, value: 300 }),
-			s.track({ featureId: TestFeature.Messages, value: 250 }),
-			s.updateSubscription({
-				productId: customerPro.id,
-				cancel: "end_of_cycle",
-			}),
-		],
-	});
-
-	const entityId = entities[0].id;
-
-	// Verify initial invoices: $20 for customer-pro + $20 for entity-pro = $40
-	const customerAfterAttach =
-		await autumnV1.customers.get<ApiCustomerV3>(customerId);
-	expectCustomerInvoiceCorrect({
-		customer: customerAfterAttach,
-		count: 2,
-	});
-
-	const customerAfterTrack =
-		await autumnV1.customers.get<ApiCustomerV3>(customerId);
-
-	const entityAfterTrack = await autumnV1.entities.get(customerId, entityId);
-
-	expect(customerAfterTrack.features[TestFeature.Messages].balance).toBe(-350);
-
-	expect(entityAfterTrack.features[TestFeature.Messages].balance).toBe(-350);
-
-	// Verify customer product is canceling
-	const customerAfterCancel =
-		await autumnV1.customers.get<ApiCustomerV3>(customerId);
-	await expectProductCanceling({
-		customer: customerAfterCancel,
-		productId: customerPro.id,
-	});
-
-	// Advance to next invoice
-	const advancedTo = await advanceToNextInvoice({
-		stripeCli: ctx.stripeCli,
-		testClockId: testClockId!,
-	});
-
-	// Verify final state
-	const customerFinal = await autumnV1.customers.get<ApiCustomerV3>(customerId);
-
-	// Customer product should be removed
-	await expectProductNotPresent({
-		customer: customerFinal,
-		productId: customerPro.id,
-	});
-
-	// Entity product should still be active (not canceled)
-	const entityFinal = await autumnV1.entities.get(customerId, entityId);
-	await expectProductActive({
-		customer: entityFinal,
-		productId: entityPro.id,
-	});
-
-	expectCustomerFeatureCorrect({
-		customer: customerFinal,
-		featureId: TestFeature.Messages,
-		balance: 100,
-		resetsAt: addMonths(Date.now(), 2).getTime(),
-	});
-
-	const overageTotal = 35;
-	expectCustomerInvoiceCorrect({
-		customer: customerFinal,
-		count: 3, // 2 initial attaches + 1 overage invoice
-		latestTotal: overageTotal + 20, // 20 for one renewal.
-	});
-
-	// Verify line item billing periods are correct (now -> now + 1 month)
-	await expectStripeInvoiceLineItemPeriodCorrect({
-		customerId,
-		productId: entityPro.id,
-		periodStartMs: Date.now(),
-		periodEndMs: advancedTo,
-	});
-});
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// TEST 1b: Entity consumable + Customer consumable - cancel BOTH end of cycle
-// ═══════════════════════════════════════════════════════════════════════════════
-
-/**
- * Scenario:
- * - Customer has customer-level Pro with consumable messages (uses Stripe meters)
- * - Customer also has entity-level Pro with consumable messages (uses invoice line items)
- * - Track overage on BOTH customer and entity
- * - Cancel BOTH products end of cycle
- * - Advance to next invoice
- *
- * Expected Result:
- * - Final invoice should only contain overages (no base prices)
- * - Customer overage: $20 (200 * $0.10)
- * - Entity overage: $15 (150 * $0.10)
- * - Total final invoice: $35
- */
-test(`${chalk.yellowBright("invoice.created entity+customer: cancel both end of cycle - no double billing")}`, async () => {
-	const customerId = "inv-created-both-cancel-eoc";
-
-	// Customer-level consumable messages (will use Stripe meters)
-	const customerConsumable = items.consumableMessages({ includedUsage: 100 });
-
-	// Entity-level consumable messages (will use invoice line items)
-	const entityConsumable = items.consumableMessages({
-		includedUsage: 100,
-		entityFeatureId: TestFeature.Users,
-	});
-
-	// Two separate products - both $20 base
-	const customerPro = products.pro({
-		id: "customer-pro",
-		items: [customerConsumable],
-	});
-
-	const entityPro = products.pro({
-		id: "entity-pro",
-		items: [entityConsumable],
-	});
-
-	const { autumnV1, ctx, testClockId, entities } = await initScenario({
-		customerId,
-		setup: [
-			s.customer({ paymentMethod: "success" }),
-			s.products({ list: [customerPro, entityPro] }),
-			s.entities({ count: 1, featureId: TestFeature.Users }),
-		],
-		actions: [
-			s.attach({ productId: customerPro.id }), // Customer-level
-			s.attach({ productId: entityPro.id, entityIndex: 0, timeout: 4000 }), // Entity-level
-			s.track({ featureId: TestFeature.Messages, value: 300 }),
-			s.track({ featureId: TestFeature.Messages, value: 250 }),
-			s.updateSubscription({
-				productId: customerPro.id,
-				cancel: "end_of_cycle",
-			}),
-			s.updateSubscription({
-				entityIndex: 0,
-				productId: entityPro.id,
-				cancel: "end_of_cycle",
-			}),
-		],
-	});
-
-	const entityId = entities[0].id;
-
-	const customerAfterTrack =
-		await autumnV1.customers.get<ApiCustomerV3>(customerId);
-	const entityAfterTrack = await autumnV1.entities.get(customerId, entityId);
-
-	// Customer and entity balance: 200 - 550 = -350
-	expect(customerAfterTrack.features[TestFeature.Messages].balance).toBe(-350);
-	expect(entityAfterTrack.features[TestFeature.Messages].balance).toBe(-350);
-
-	// Verify both products are canceling
-	const customerAfterCancel =
-		await autumnV1.customers.get<ApiCustomerV3>(customerId);
-	await expectProductCanceling({
-		customer: customerAfterCancel,
-		productId: customerPro.id,
-	});
-
-	const entityAfterCancel = await autumnV1.entities.get(customerId, entityId);
-	await expectProductCanceling({
-		customer: entityAfterCancel,
-		productId: entityPro.id,
-	});
-
-	// Advance to next invoice
-	const advancedTo = await advanceToNextInvoice({
-		stripeCli: ctx.stripeCli,
-		testClockId: testClockId!,
-	});
-
-	// Verify final state - both products should be removed
-	const customerFinal = await autumnV1.customers.get<ApiCustomerV3>(customerId);
-	await expectProductNotPresent({
-		customer: customerFinal,
-		productId: customerPro.id,
-	});
-
-	const entityFinal = await autumnV1.entities.get(customerId, entityId);
-	await expectProductNotPresent({
-		customer: entityFinal,
-		productId: entityPro.id,
-	});
-
-	expectCustomerInvoiceCorrect({
-		customer: customerFinal,
-		count: 3, // 2 initial attaches + 1 overage invoice
-		latestTotal: 35,
-	});
-
-	// Verify line item billing periods are correct (now -> now + 1 month)
-	await expectStripeInvoiceLineItemPeriodCorrect({
-		customerId,
-		productId: entityPro.id,
-		periodStartMs: Date.now(),
-		periodEndMs: advancedTo,
-	});
-});
-
 // ═══════════════════════════════════════════════════════════════════════════════
 // TEST 2: Entity consumable with billing units - multiple entities (per-entity rounding)
 // ═══════════════════════════════════════════════════════════════════════════════
diff --git a/server/tests/integration/billing/stripe-webhooks/subscription-deleted/subscription-deleted-entities.test.ts b/server/tests/integration/billing/stripe-webhooks/subscription-deleted/subscription-deleted-entities.test.ts
deleted file mode 100644
index d05b46d59..000000000
--- a/server/tests/integration/billing/stripe-webhooks/subscription-deleted/subscription-deleted-entities.test.ts
+++ /dev/null
@@ -1,276 +0,0 @@
-/**
- * Subscription Deleted Webhook Tests - Entity Scenarios
- *
- * Tests for handling the `customer.subscription.deleted` Stripe webhook event
- * in multi-entity scenarios. These tests simulate canceling subscriptions
- * directly through the Stripe client to verify the webhook handler works correctly
- * for entity-level products.
- */
-
-import { test } from "bun:test";
-import type { ApiEntityV0 } from "@autumn/shared";
-import { expectCustomerFeatureCorrect } from "@tests/integration/billing/utils/expectCustomerFeatureCorrect";
-import {
-	expectCustomerProducts,
-	expectProductActive,
-} from "@tests/integration/billing/utils/expectCustomerProductCorrect";
-import { expectNoStripeSubscription } from "@tests/integration/billing/utils/expectNoStripeSubscription";
-import { TestFeature } from "@tests/setup/v2Features";
-import { items } from "@tests/utils/fixtures/items";
-import { products } from "@tests/utils/fixtures/products";
-import { initScenario, s } from "@tests/utils/testInitUtils/initScenario";
-import chalk from "chalk";
-import type { AutumnContext } from "@/honoUtils/HonoEnv";
-import { CusService } from "@/internal/customers/CusService";
-import { timeout } from "@/utils/genUtils";
-
-/**
- * Helper to get subscription ID for an entity's customer product.
- */
-const getEntitySubscriptionId = async ({
-	ctx,
-	customerId,
-	entityId,
-	productId,
-}: {
-	ctx: AutumnContext;
-	customerId: string;
-	entityId: string;
-	productId: string;
-}): Promise<string> => {
-	const fullCustomer = await CusService.getFull({
-		db: ctx.db,
-		idOrInternalId: customerId,
-		orgId: ctx.org.id,
-		env: ctx.env,
-	});
-
-	const customerProduct = fullCustomer.customer_products.find(
-		(cp) => cp.product.id === productId && cp.entity_id === entityId,
-	);
-
-	if (!customerProduct?.subscription_ids?.length) {
-		throw new Error(
-			`No subscription found for product ${productId} on entity ${entityId}`,
-		);
-	}
-
-	return customerProduct.subscription_ids[0];
-};
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// TEST 1: Cancel subscription with multiple entities via Stripe
-// ═══════════════════════════════════════════════════════════════════════════════
-
-/**
- * Scenario:
- * - Init pro ($20/mo) and free (default) products
- * - Create 2 entities
- * - Attach pro to entity 1 and entity 2
- * - Cancel the subscription directly via Stripe client
- *
- * Expected Result:
- * - Pro is removed from both entities
- * - Free default becomes active for both entities
- * - No Stripe subscription exists
- */
-test(`${chalk.yellowBright("sub.deleted entities: cancel subscription with multiple entities via Stripe")}`, async () => {
-	const customerId = "sub-deleted-multi-entity";
-
-	const messagesItem = items.monthlyMessages({ includedUsage: 100 });
-
-	const free = products.base({
-		id: "free",
-		items: [messagesItem],
-		isDefault: true,
-	});
-
-	const pro = products.pro({
-		id: "pro",
-		items: [messagesItem],
-	});
-
-	const { autumnV1, ctx, entities } = await initScenario({
-		customerId,
-		setup: [
-			s.customer({ paymentMethod: "success" }),
-			s.products({ list: [free, pro] }),
-			s.entities({ count: 2, featureId: TestFeature.Users }),
-		],
-		actions: [
-			s.attach({ productId: pro.id, entityIndex: 0 }),
-			s.attach({ productId: pro.id, entityIndex: 1 }),
-		],
-	});
-
-	// Verify both entities have pro active
-	const entity1After = await autumnV1.entities.get<ApiEntityV0>(
-		customerId,
-		entities[0].id,
-	);
-	const entity2After = await autumnV1.entities.get<ApiEntityV0>(
-		customerId,
-		entities[1].id,
-	);
-
-	await expectProductActive({ customer: entity1After, productId: pro.id });
-	await expectProductActive({ customer: entity2After, productId: pro.id });
-
-	// Get subscription ID from entity 1's product
-	const subscriptionId = await getEntitySubscriptionId({
-		ctx,
-		customerId,
-		entityId: entities[0].id,
-		productId: pro.id,
-	});
-
-	// Cancel subscription directly via Stripe client
-	await ctx.stripeCli.subscriptions.cancel(subscriptionId);
-
-	// Wait for webhook to process
-	await timeout(8000);
-
-	// Verify both entities have pro removed and free active
-	const entity1Final = await autumnV1.entities.get<ApiEntityV0>(
-		customerId,
-		entities[0].id,
-	);
-	const entity2Final = await autumnV1.entities.get<ApiEntityV0>(
-		customerId,
-		entities[1].id,
-	);
-
-	// entities don't have default products...
-	await expectCustomerProducts({
-		customer: entity1Final,
-		notPresent: [pro.id, free.id],
-	});
-	await expectCustomerProducts({
-		customer: entity2Final,
-		notPresent: [pro.id, free.id],
-	});
-
-	// Verify no Stripe subscription exists
-	await expectNoStripeSubscription({
-		db: ctx.db,
-		customerId,
-		org: ctx.org,
-		env: ctx.env,
-	});
-});
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// TEST 2: Cancel subscription after tracking usage into overage via Stripe
-// ═══════════════════════════════════════════════════════════════════════════════
-
-/**
- * Scenario:
- * - Init pro ($20/mo) with consumable overage ($0.10/unit) and free (default)
- * - Create 1 entity
- * - Attach pro to entity 1
- * - Track usage into overage (use more than included)
- * - Cancel the subscription directly via Stripe client
- *
- * Expected Result:
- * - Pro is removed
- * - Free default becomes active
- * - Overage charges should have been handled
- * - No Stripe subscription exists
- */
-test(`${chalk.yellowBright("sub.deleted entities: cancel after tracking usage into overage via Stripe")}`, async () => {
-	const customerId = "sub-deleted-entity-overage";
-
-	const consumableItem = items.consumableMessages({ includedUsage: 100 });
-
-	const free = products.base({
-		id: "free",
-		items: [items.monthlyMessages({ includedUsage: 50 })],
-		isDefault: true,
-	});
-
-	const pro = products.pro({
-		id: "pro",
-		items: [consumableItem],
-	});
-
-	const { autumnV1, ctx, entities } = await initScenario({
-		customerId,
-		setup: [
-			s.customer({ paymentMethod: "success" }),
-			s.products({ list: [free, pro] }),
-			s.entities({ count: 1, featureId: TestFeature.Users }),
-		],
-		actions: [s.attach({ productId: pro.id, entityIndex: 0 })],
-	});
-
-	// Verify entity 1 has pro active with 100 included usage
-	const entityAfterAttach = await autumnV1.entities.get<ApiEntityV0>(
-		customerId,
-		entities[0].id,
-	);
-	await expectProductActive({ customer: entityAfterAttach, productId: pro.id });
-	expectCustomerFeatureCorrect({
-		customer: entityAfterAttach,
-		featureId: TestFeature.Messages,
-		includedUsage: 100,
-		balance: 100,
-		usage: 0,
-	});
-
-	// Track usage beyond included (150 total, 50 overage)
-	await autumnV1.track({
-		customer_id: customerId,
-		entity_id: entities[0].id,
-		feature_id: TestFeature.Messages,
-		value: 150,
-	});
-
-	// Wait for sync
-	await timeout(2000);
-
-	// Verify usage was tracked
-	const entityAfterTrack = await autumnV1.entities.get<ApiEntityV0>(
-		customerId,
-		entities[0].id,
-	);
-	expectCustomerFeatureCorrect({
-		customer: entityAfterTrack,
-		featureId: TestFeature.Messages,
-		includedUsage: 100,
-		balance: -50, // 100 - 150 = -50
-		usage: 150,
-	});
-
-	// Get subscription ID from entity's product
-	const subscriptionId = await getEntitySubscriptionId({
-		ctx,
-		customerId,
-		entityId: entities[0].id,
-		productId: pro.id,
-	});
-
-	// Cancel subscription directly via Stripe client
-	await ctx.stripeCli.subscriptions.cancel(subscriptionId);
-
-	// Wait for webhook to process
-	await timeout(8000);
-
-	// Verify entity has pro removed and free active
-	const entityFinal = await autumnV1.entities.get<ApiEntityV0>(
-		customerId,
-		entities[0].id,
-	);
-
-	await expectCustomerProducts({
-		customer: entityFinal,
-		notPresent: [pro.id, free.id],
-	});
-
-	// Verify no Stripe subscription exists
-	await expectNoStripeSubscription({
-		db: ctx.db,
-		customerId,
-		org: ctx.org,
-		env: ctx.env,
-	});
-});
diff --git a/server/tests/integration/billing/stripe-webhooks/subscription-deleted/subscription-deleted-invoice.test.ts b/server/tests/integration/billing/stripe-webhooks/subscription-deleted/subscription-deleted-invoice.test.ts
new file mode 100644
index 000000000..d241c478e
--- /dev/null
+++ b/server/tests/integration/billing/stripe-webhooks/subscription-deleted/subscription-deleted-invoice.test.ts
@@ -0,0 +1,834 @@
+/**
+ * Subscription Deleted Invoice Tests
+ *
+ * Tests for invoice creation when subscriptions are deleted via Stripe client
+ * (not through Autumn's cancel API).
+ *
+ * Key behaviors:
+ * - Immediate cancellation (cancel_at_period_end = false) → NO final arrear invoice
+ * - End-of-period cancellation (cancel_at_period_end = true) → Final arrear invoice created
+ * - Customer-level consumables use Stripe metered prices → Stripe handles final billing
+ * - Entity-level consumables use invoice line items → Autumn creates final invoice (only for end-of-period)
+ *
+ * The wasImmediateStripeCancellation() check ensures we don't charge overage
+ * on immediate cancellations, matching the behavior of customer-level consumables.
+ */
+
+import { expect, test } from "bun:test";
+import type { ApiCustomerV3 } from "@autumn/shared";
+import { expectCustomerInvoiceCorrect } from "@tests/integration/billing/utils/expectCustomerInvoiceCorrect";
+import {
+	expectProductActive,
+	expectProductNotPresent,
+} from "@tests/integration/billing/utils/expectCustomerProductCorrect";
+import { expectNoStripeSubscription } from "@tests/integration/billing/utils/expectNoStripeSubscription";
+import {
+	getEntitySubscriptionId,
+	getSubscriptionId,
+} from "@tests/integration/billing/utils/stripe/getSubscriptionId";
+import { TestFeature } from "@tests/setup/v2Features";
+import { items } from "@tests/utils/fixtures/items";
+import { products } from "@tests/utils/fixtures/products";
+import { advanceTestClock } from "@tests/utils/stripeUtils";
+import { initScenario, s } from "@tests/utils/testInitUtils/initScenario";
+import chalk from "chalk";
+import { addMonths } from "date-fns";
+import { timeout } from "@/utils/genUtils";
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// TEST 1: Customer consumable → Stripe cancel immediately → NO final invoice
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Scenario:
+ * - Customer has Pro with customer-level consumable messages (uses Stripe metered prices)
+ * - Track overage usage
+ * - Cancel subscription IMMEDIATELY via Stripe client
+ *
+ * Expected Result:
+ * - Product is removed
+ * - Autumn does NOT create a final arrear invoice (metered + immediate cancel)
+ * - Only the initial attach invoice exists
+ */
+test(`${chalk.yellowBright("sub.deleted invoice: customer consumable → Stripe cancel immediately → no final invoice")}`, async () => {
+	const customerId = "sub-del-inv-cus-imm";
+
+	const consumableItem = items.consumableMessages({ includedUsage: 100 });
+	const pro = products.pro({
+		id: "pro",
+		items: [consumableItem],
+	});
+
+	const { autumnV1, ctx } = await initScenario({
+		customerId,
+		setup: [
+			s.customer({ paymentMethod: "success" }),
+			s.products({ list: [pro] }),
+		],
+		actions: [s.attach({ productId: pro.id })],
+	});
+
+	// Verify pro is active
+	const customerAfterAttach =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+	await expectProductActive({
+		customer: customerAfterAttach,
+		productId: pro.id,
+	});
+
+	// Initial attach invoice: $20 base price
+	expectCustomerInvoiceCorrect({
+		customer: customerAfterAttach,
+		count: 1,
+		latestTotal: 20,
+	});
+
+	// Track 500 messages (100 included, 400 overage = $40 if billed)
+	await autumnV1.track({
+		customer_id: customerId,
+		feature_id: TestFeature.Messages,
+		value: 500,
+	});
+
+	// Verify usage was tracked
+	const customerAfterTrack =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+	expect(customerAfterTrack.features[TestFeature.Messages].balance).toBe(-400);
+
+	// Get subscription ID
+	const subscriptionId = await getSubscriptionId({
+		ctx,
+		customerId,
+		productId: pro.id,
+	});
+
+	// Cancel subscription IMMEDIATELY via Stripe client
+	await ctx.stripeCli.subscriptions.cancel(subscriptionId);
+
+	// Wait for webhook to process
+	await timeout(8000);
+
+	// Verify product is removed
+	const customerAfterCancel =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+	await expectProductNotPresent({
+		customer: customerAfterCancel,
+		productId: pro.id,
+	});
+
+	// Verify no Stripe subscription exists
+	await expectNoStripeSubscription({
+		db: ctx.db,
+		customerId,
+		org: ctx.org,
+		env: ctx.env,
+	});
+
+	// Key assertion: Only 1 invoice (initial attach)
+	// No final arrear invoice because:
+	// 1. Customer-level consumables use metered prices (Stripe handles)
+	// 2. This was an immediate cancel (wasImmediateStripeCancellation = true)
+	expectCustomerInvoiceCorrect({
+		customer: customerAfterCancel,
+		count: 1,
+		latestTotal: 20,
+	});
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// TEST 2: Entity consumable → Stripe cancel immediately → NO final invoice
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Scenario:
+ * - Entity has Pro with entity-level consumable messages (uses invoice line items, NOT metered)
+ * - Track overage usage on entity
+ * - Cancel subscription IMMEDIATELY via Stripe client
+ *
+ * Expected Result:
+ * - Product is removed from entity
+ * - Autumn does NOT create a final arrear invoice (immediate cancel = no overage charge)
+ * - Only the initial attach invoice exists
+ *
+ * This matches the behavior of customer-level consumables where immediate
+ * cancellation does not charge overage.
+ */
+test(`${chalk.yellowBright("sub.deleted invoice: entity consumable → Stripe cancel immediately → no final invoice")}`, async () => {
+	const customerId = "sub-del-inv-ent-imm";
+
+	const consumableItem = items.consumableMessages({ includedUsage: 100 });
+	const pro = products.pro({
+		id: "pro",
+		items: [consumableItem],
+	});
+
+	const { autumnV1, ctx, entities } = await initScenario({
+		customerId,
+		setup: [
+			s.customer({ paymentMethod: "success" }),
+			s.products({ list: [pro] }),
+			s.entities({ count: 1, featureId: TestFeature.Users }),
+		],
+		actions: [s.attach({ productId: pro.id, entityIndex: 0 })],
+	});
+
+	const entityId = entities[0].id;
+
+	// Verify pro is active on entity
+	const entity = await autumnV1.entities.get(customerId, entityId);
+	await expectProductActive({
+		customer: entity,
+		productId: pro.id,
+	});
+
+	// Verify initial attach invoice: $20 base price
+	const customerAfterAttach =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+	expectCustomerInvoiceCorrect({
+		customer: customerAfterAttach,
+		count: 1,
+		latestTotal: 20,
+	});
+
+	// Track 500 messages on entity (100 included, 400 overage = $40 if billed)
+	await autumnV1.track({
+		customer_id: customerId,
+		entity_id: entityId,
+		feature_id: TestFeature.Messages,
+		value: 500,
+	});
+
+	// Verify usage was tracked
+	const entityAfterTrack = await autumnV1.entities.get(customerId, entityId);
+	expect(entityAfterTrack.features[TestFeature.Messages].balance).toBe(-400);
+
+	// Get subscription ID for entity's product
+	const subscriptionId = await getEntitySubscriptionId({
+		ctx,
+		customerId,
+		entityId,
+		productId: pro.id,
+	});
+
+	// Cancel subscription IMMEDIATELY via Stripe client (not at period end)
+	await ctx.stripeCli.subscriptions.cancel(subscriptionId);
+
+	// Wait for webhook to process
+	await timeout(8000);
+
+	// Verify product is removed from entity
+	const entityAfterCancel = await autumnV1.entities.get(customerId, entityId);
+	await expectProductNotPresent({
+		customer: entityAfterCancel,
+		productId: pro.id,
+	});
+
+	// Verify no Stripe subscription exists
+	await expectNoStripeSubscription({
+		db: ctx.db,
+		customerId,
+		org: ctx.org,
+		env: ctx.env,
+	});
+
+	// Key assertion: Autumn should NOT have created an arrear invoice
+	// because this was an immediate cancellation (cancel_at_period_end = false)
+	const customerAfterCancel =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+
+	// Should have only 1 invoice (initial attach) - no final arrear invoice
+	expectCustomerInvoiceCorrect({
+		customer: customerAfterCancel,
+		count: 1,
+		latestTotal: 20, // Initial attach only
+	});
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// TEST 4: Multi-interval → advance 1 month → Stripe cancel immediately → no invoice
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Scenario:
+ * - Entity has product with multi-interval items (monthly + annual)
+ * - Track overage usage
+ * - Advance test clock exactly 1 month (monthly item period ends, annual continues)
+ * - Cancel subscription IMMEDIATELY via Stripe client
+ *
+ * Expected Result:
+ * - Product is removed
+ * - Autumn does NOT create a final arrear invoice (immediate cancel)
+ * - Only initial attach + renewal invoices exist
+ *
+ * This tests that the wasImmediateStripeCancellation check works correctly
+ * even when subscription items have different period ends.
+ */
+test(`${chalk.yellowBright("sub.deleted invoice: multi-interval → advance 1 month → Stripe cancel immediately → no invoice")}`, async () => {
+	const customerId = "sub-del-inv-multi-int";
+
+	// Multi-interval: monthly consumable + annual base price
+	const consumableItem = items.consumableMessages({ includedUsage: 100 });
+	const annualPriceItem = items.annualPrice({ price: 120 });
+
+	const pro = products.base({
+		id: "pro",
+		items: [consumableItem, annualPriceItem],
+	});
+
+	const { autumnV1, ctx, entities, testClockId } = await initScenario({
+		customerId,
+		setup: [
+			s.customer({ paymentMethod: "success" }),
+			s.products({ list: [pro] }),
+			s.entities({ count: 1, featureId: TestFeature.Users }),
+		],
+		actions: [s.attach({ productId: pro.id, entityIndex: 0 })],
+	});
+
+	const entityId = entities[0].id;
+
+	// Verify pro is active on entity
+	const entity = await autumnV1.entities.get(customerId, entityId);
+	await expectProductActive({
+		customer: entity,
+		productId: pro.id,
+	});
+
+	// Verify initial attach invoice: $120 annual base price
+	const customerAfterAttach =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+	expectCustomerInvoiceCorrect({
+		customer: customerAfterAttach,
+		count: 1,
+		latestTotal: 120,
+	});
+
+	// Track 500 messages on entity (100 included, 400 overage = $40 if billed)
+	await autumnV1.track({
+		customer_id: customerId,
+		entity_id: entityId,
+		feature_id: TestFeature.Messages,
+		value: 500,
+	});
+
+	// Verify usage was tracked
+	const entityAfterTrack = await autumnV1.entities.get(customerId, entityId);
+	expect(entityAfterTrack.features[TestFeature.Messages].balance).toBe(-400);
+
+	// Advance test clock exactly 1 month
+	// This will trigger the monthly item's period end, but annual continues
+	await advanceTestClock({
+		stripeCli: ctx.stripeCli,
+		testClockId: testClockId!,
+		advanceTo: addMonths(new Date(), 1).getTime(),
+		waitForSeconds: 15,
+	});
+
+	// Get invoice count after 1 month advance
+	const customerAfterAdvance =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+	const invoiceCountAfterAdvance = customerAfterAdvance.invoices?.length ?? 0;
+
+	// Get subscription ID for entity's product
+	const subscriptionId = await getEntitySubscriptionId({
+		ctx,
+		customerId,
+		entityId,
+		productId: pro.id,
+	});
+
+	// Cancel subscription IMMEDIATELY via Stripe client (mid-annual-cycle)
+	await ctx.stripeCli.subscriptions.cancel(subscriptionId);
+
+	// Wait for webhook to process
+	await timeout(8000);
+
+	// Verify product is removed from entity
+	const entityAfterCancel = await autumnV1.entities.get(customerId, entityId);
+	await expectProductNotPresent({
+		customer: entityAfterCancel,
+		productId: pro.id,
+	});
+
+	// Verify no Stripe subscription exists
+	await expectNoStripeSubscription({
+		db: ctx.db,
+		customerId,
+		org: ctx.org,
+		env: ctx.env,
+	});
+
+	// Key assertion: No NEW invoice should be created by Autumn for arrear usage
+	// because this was an immediate cancellation (cancel_at_period_end = false)
+	const customerAfterCancel =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+
+	// Invoice count should be same as before cancel (no new arrear invoice)
+	expect(customerAfterCancel.invoices?.length).toBe(invoiceCountAfterAdvance);
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// TEST 5: Entity consumable → advance 1 month → Stripe cancel immediately → no invoice
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Scenario:
+ * - Entity has Pro with entity-level consumable messages (uses invoice line items)
+ * - Track overage usage on entity
+ * - Advance test clock 1 month (triggers renewal)
+ * - Cancel subscription IMMEDIATELY via Stripe client
+ *
+ * Expected Result:
+ * - Product is removed from entity
+ * - Autumn does NOT create a final arrear invoice (immediate cancel)
+ * - Only initial attach + renewal invoices exist
+ */
+test(`${chalk.yellowBright("sub.deleted invoice: entity consumable → advance 1 month → Stripe cancel immediately → no invoice")}`, async () => {
+	const customerId = "sub-del-inv-ent-adv";
+
+	const consumableItem = items.consumableMessages({ includedUsage: 100 });
+	const pro = products.pro({
+		id: "pro",
+		items: [consumableItem],
+	});
+
+	const { autumnV1, ctx, entities, testClockId } = await initScenario({
+		customerId,
+		setup: [
+			s.customer({ paymentMethod: "success" }),
+			s.products({ list: [pro] }),
+			s.entities({ count: 1, featureId: TestFeature.Users }),
+		],
+		actions: [s.attach({ productId: pro.id, entityIndex: 0 })],
+	});
+
+	const entityId = entities[0].id;
+
+	// Verify pro is active on entity
+	const entity = await autumnV1.entities.get(customerId, entityId);
+	await expectProductActive({
+		customer: entity,
+		productId: pro.id,
+	});
+
+	// Initial attach invoice: $20 base price
+	const customerAfterAttach =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+	expectCustomerInvoiceCorrect({
+		customer: customerAfterAttach,
+		count: 1,
+		latestTotal: 20,
+	});
+
+	// Advance test clock 1 month (triggers renewal)
+	await advanceTestClock({
+		stripeCli: ctx.stripeCli,
+		testClockId: testClockId!,
+		advanceTo: addMonths(new Date(), 1).getTime(),
+		waitForSeconds: 15,
+	});
+
+	// Track 500 messages on entity in the new cycle (100 included, 400 overage)
+	await autumnV1.track({
+		customer_id: customerId,
+		entity_id: entityId,
+		feature_id: TestFeature.Messages,
+		value: 500,
+	});
+
+	// Verify usage was tracked
+	const entityAfterTrack = await autumnV1.entities.get(customerId, entityId);
+	expect(entityAfterTrack.features[TestFeature.Messages].balance).toBe(-400);
+
+	// Get invoice count before cancel
+	const customerBeforeCancel =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+	const invoiceCountBeforeCancel = customerBeforeCancel.invoices?.length ?? 0;
+
+	// Get subscription ID for entity's product
+	const subscriptionId = await getEntitySubscriptionId({
+		ctx,
+		customerId,
+		entityId,
+		productId: pro.id,
+	});
+
+	// Cancel subscription IMMEDIATELY via Stripe client
+	await ctx.stripeCli.subscriptions.cancel(subscriptionId);
+
+	// Wait for webhook to process
+	await timeout(8000);
+
+	// Verify product is removed from entity
+	const entityAfterCancel = await autumnV1.entities.get(customerId, entityId);
+	await expectProductNotPresent({
+		customer: entityAfterCancel,
+		productId: pro.id,
+	});
+
+	// Verify no Stripe subscription exists
+	await expectNoStripeSubscription({
+		db: ctx.db,
+		customerId,
+		org: ctx.org,
+		env: ctx.env,
+	});
+
+	// Key assertion: No NEW invoice from Autumn
+	// Invoice count should be same as before cancel (no arrear invoice)
+	const customerAfterCancel =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+	expect(customerAfterCancel.invoices?.length).toBe(invoiceCountBeforeCancel);
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// TEST 6: Customer trial consumable → cancel at period end → NO arrear invoice
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Scenario:
+ * - Customer has Pro with 14-day trial + consumable messages (100 included)
+ * - Track overage usage during trial (250 messages = 150 overage)
+ * - Cancel subscription at PERIOD END via Stripe client (cancel_at_period_end = true)
+ * - Advance test clock to trial end (period end)
+ *
+ * Expected Result:
+ * - Product is removed at trial end
+ * - Autumn does NOT create an arrear invoice (trial usage is free)
+ * - No invoices created (trial = no charge)
+ */
+test(`${chalk.yellowBright("sub.deleted invoice: customer trial consumable → cancel at period end → NO arrear invoice")}`, async () => {
+	const customerId = "sub-del-inv-cus-trial";
+
+	const consumableItem = items.consumableMessages({ includedUsage: 100 });
+	const proTrial = products.proWithTrial({
+		id: "pro-trial",
+		items: [consumableItem],
+		trialDays: 14,
+	});
+
+	const { autumnV1, ctx, testClockId } = await initScenario({
+		customerId,
+		setup: [
+			s.customer({ paymentMethod: "success" }),
+			s.products({ list: [proTrial] }),
+		],
+		actions: [s.attach({ productId: proTrial.id })],
+	});
+
+	// Verify pro is active and trialing
+	const customerAfterAttach =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+	await expectProductActive({
+		customer: customerAfterAttach,
+		productId: proTrial.id,
+	});
+
+	// No invoices yet (trialing)
+	expectCustomerInvoiceCorrect({
+		customer: customerAfterAttach,
+		count: 0,
+	});
+
+	// Track 250 messages (100 included, 150 overage = $15 if billed)
+	await autumnV1.track({
+		customer_id: customerId,
+		feature_id: TestFeature.Messages,
+		value: 250,
+	});
+
+	// Verify usage was tracked
+	const customerAfterTrack =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+	expect(customerAfterTrack.features[TestFeature.Messages].balance).toBe(-150);
+
+	// Get subscription ID
+	const subscriptionId = await getSubscriptionId({
+		ctx,
+		customerId,
+		productId: proTrial.id,
+	});
+
+	// Cancel subscription at PERIOD END via Stripe client
+	await ctx.stripeCli.subscriptions.update(subscriptionId, {
+		cancel_at_period_end: true,
+	});
+
+	// Verify subscription is still trialing but scheduled for cancellation
+	const subAfterSchedule =
+		await ctx.stripeCli.subscriptions.retrieve(subscriptionId);
+	expect(subAfterSchedule.cancel_at_period_end).toBe(true);
+	expect(subAfterSchedule.status).toBe("trialing");
+
+	// Advance test clock to trial end (14 days)
+	await advanceTestClock({
+		stripeCli: ctx.stripeCli,
+		testClockId: testClockId!,
+		numberOfDays: 14,
+		waitForSeconds: 15,
+	});
+
+	// Verify product is removed
+	const customerAfterCancel =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+	await expectProductNotPresent({
+		customer: customerAfterCancel,
+		productId: proTrial.id,
+	});
+
+	// Verify no Stripe subscription exists
+	await expectNoStripeSubscription({
+		db: ctx.db,
+		customerId,
+		org: ctx.org,
+		env: ctx.env,
+	});
+
+	// Key assertion: No arrear invoice created because trial usage is free
+	expectCustomerInvoiceCorrect({
+		customer: customerAfterCancel,
+		count: 0, // No invoices at all (trial was canceled before converting)
+	});
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// TEST 7: Entity trial consumable → cancel at period end → NO arrear invoice
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Scenario:
+ * - Entity has Pro with 14-day trial + consumable messages (100 included)
+ * - Track overage usage on entity during trial (200 messages = 100 overage)
+ * - Cancel subscription at PERIOD END via Stripe client (cancel_at_period_end = true)
+ * - Advance test clock to trial end (period end)
+ *
+ * Expected Result:
+ * - Product is removed from entity at trial end
+ * - Autumn does NOT create an arrear invoice (trial usage is free)
+ * - No invoices created (trial = no charge)
+ */
+test(`${chalk.yellowBright("sub.deleted invoice: entity trial consumable → cancel at period end → NO arrear invoice")}`, async () => {
+	const customerId = "sub-del-inv-ent-trial";
+
+	const consumableItem = items.consumableMessages({ includedUsage: 100 });
+	const proTrial = products.proWithTrial({
+		id: "pro-trial",
+		items: [consumableItem],
+		trialDays: 14,
+	});
+
+	const { autumnV1, ctx, entities, testClockId } = await initScenario({
+		customerId,
+		setup: [
+			s.customer({ paymentMethod: "success" }),
+			s.products({ list: [proTrial] }),
+			s.entities({ count: 1, featureId: TestFeature.Users }),
+		],
+		actions: [s.attach({ productId: proTrial.id, entityIndex: 0 })],
+	});
+
+	const entityId = entities[0].id;
+
+	// Verify pro is active and trialing on entity
+	const entity = await autumnV1.entities.get(customerId, entityId);
+	await expectProductActive({
+		customer: entity,
+		productId: proTrial.id,
+	});
+
+	// No invoices yet (trialing)
+	const customerAfterAttach =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+	expectCustomerInvoiceCorrect({
+		customer: customerAfterAttach,
+		count: 0,
+	});
+
+	// Track 200 messages on entity (100 included, 100 overage = $10 if billed)
+	await autumnV1.track({
+		customer_id: customerId,
+		entity_id: entityId,
+		feature_id: TestFeature.Messages,
+		value: 200,
+	});
+
+	// Verify usage was tracked
+	const entityAfterTrack = await autumnV1.entities.get(customerId, entityId);
+	expect(entityAfterTrack.features[TestFeature.Messages].balance).toBe(-100);
+
+	// Get subscription ID for entity's product
+	const subscriptionId = await getEntitySubscriptionId({
+		ctx,
+		customerId,
+		entityId,
+		productId: proTrial.id,
+	});
+
+	// Cancel subscription at PERIOD END via Stripe client
+	await ctx.stripeCli.subscriptions.update(subscriptionId, {
+		cancel_at_period_end: true,
+	});
+
+	// Verify subscription is still trialing but scheduled for cancellation
+	const subAfterSchedule =
+		await ctx.stripeCli.subscriptions.retrieve(subscriptionId);
+	expect(subAfterSchedule.cancel_at_period_end).toBe(true);
+	expect(subAfterSchedule.status).toBe("trialing");
+
+	// Advance test clock to trial end (14 days)
+	await advanceTestClock({
+		stripeCli: ctx.stripeCli,
+		testClockId: testClockId!,
+		numberOfDays: 14,
+		waitForSeconds: 15,
+	});
+
+	// Verify product is removed from entity
+	const entityAfterCancel = await autumnV1.entities.get(customerId, entityId);
+	await expectProductNotPresent({
+		customer: entityAfterCancel,
+		productId: proTrial.id,
+	});
+
+	// Verify no Stripe subscription exists
+	await expectNoStripeSubscription({
+		db: ctx.db,
+		customerId,
+		org: ctx.org,
+		env: ctx.env,
+	});
+
+	// Key assertion: No arrear invoice created because trial usage is free
+	const customerAfterCancel =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+	expectCustomerInvoiceCorrect({
+		customer: customerAfterCancel,
+		count: 0, // No invoices at all (trial was canceled before converting)
+	});
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// TEST 8: Entity consumable → Stripe cancel at period end → CREATES arrear invoice
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Scenario:
+ * - Entity has Pro with entity-level consumable messages (uses invoice line items)
+ * - Track overage usage on entity
+ * - Cancel subscription at PERIOD END via Stripe client (cancel_at_period_end = true)
+ * - Advance test clock to period end
+ *
+ * Expected Result:
+ * - Product is removed at period end
+ * - Autumn DOES create a final arrear invoice (end-of-period = overage billed)
+ * - Invoice includes overage charges
+ *
+ * This is the opposite of the immediate cancel tests - end-of-period cancellation
+ * should bill any accumulated overage.
+ */
+test(`${chalk.yellowBright("sub.deleted invoice: entity consumable → Stripe cancel at period end → CREATES arrear invoice")}`, async () => {
+	const customerId = "sub-del-inv-ent-eop";
+
+	const consumableItem = items.consumableMessages({ includedUsage: 100 });
+	const pro = products.pro({
+		id: "pro",
+		items: [consumableItem],
+	});
+
+	const { autumnV1, ctx, entities, testClockId } = await initScenario({
+		customerId,
+		setup: [
+			s.customer({ paymentMethod: "success" }),
+			s.products({ list: [pro] }),
+			s.entities({ count: 1, featureId: TestFeature.Users }),
+		],
+		actions: [s.attach({ productId: pro.id, entityIndex: 0 })],
+	});
+
+	const entityId = entities[0].id;
+
+	// Verify pro is active on entity
+	const entity = await autumnV1.entities.get(customerId, entityId);
+	await expectProductActive({
+		customer: entity,
+		productId: pro.id,
+	});
+
+	// Verify initial attach invoice: $20 base price
+	const customerAfterAttach =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+	expectCustomerInvoiceCorrect({
+		customer: customerAfterAttach,
+		count: 1,
+		latestTotal: 20,
+	});
+
+	// Track 500 messages on entity (100 included, 400 overage = $40 if billed)
+	await autumnV1.track({
+		customer_id: customerId,
+		entity_id: entityId,
+		feature_id: TestFeature.Messages,
+		value: 500,
+	});
+
+	// Verify usage was tracked
+	const entityAfterTrack = await autumnV1.entities.get(customerId, entityId);
+	expect(entityAfterTrack.features[TestFeature.Messages].balance).toBe(-400);
+
+	// Get subscription ID for entity's product
+	const subscriptionId = await getEntitySubscriptionId({
+		ctx,
+		customerId,
+		entityId,
+		productId: pro.id,
+	});
+
+	// Cancel subscription at PERIOD END via Stripe client (NOT immediately)
+	await ctx.stripeCli.subscriptions.update(subscriptionId, {
+		cancel_at_period_end: true,
+	});
+
+	// Verify subscription is still active but scheduled for cancellation
+	const subAfterSchedule =
+		await ctx.stripeCli.subscriptions.retrieve(subscriptionId);
+	expect(subAfterSchedule.cancel_at_period_end).toBe(true);
+	expect(subAfterSchedule.status).toBe("active");
+
+	// Advance test clock to period end (1 month)
+	// This triggers the subscription.deleted event with cancel_at_period_end = true
+	await advanceTestClock({
+		stripeCli: ctx.stripeCli,
+		testClockId: testClockId!,
+		advanceTo: addMonths(new Date(), 1).getTime(),
+		waitForSeconds: 15,
+	});
+
+	// Verify product is removed from entity
+	const entityAfterCancel = await autumnV1.entities.get(customerId, entityId);
+	await expectProductNotPresent({
+		customer: entityAfterCancel,
+		productId: pro.id,
+	});
+
+	// Verify no Stripe subscription exists
+	await expectNoStripeSubscription({
+		db: ctx.db,
+		customerId,
+		org: ctx.org,
+		env: ctx.env,
+	});
+
+	// Key assertion: Autumn SHOULD have created an arrear invoice
+	// because this was an end-of-period cancellation (cancel_at_period_end = true)
+	const customerAfterCancel =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+
+	// Should have 2 invoices:
+	// 1. Initial attach: $20
+	// 2. Final arrear invoice: $40 (400 overage × $0.10)
+	expectCustomerInvoiceCorrect({
+		customer: customerAfterCancel,
+		count: 2,
+		latestTotal: 40, // Arrear invoice for overage
+	});
+});
diff --git a/server/tests/integration/billing/stripe-webhooks/subscription-deleted/subscription-deleted.test.ts b/server/tests/integration/billing/stripe-webhooks/subscription-deleted/subscription-deleted.test.ts
index 955000cad..ee1c8a1e6 100644
--- a/server/tests/integration/billing/stripe-webhooks/subscription-deleted/subscription-deleted.test.ts
+++ b/server/tests/integration/billing/stripe-webhooks/subscription-deleted/subscription-deleted.test.ts
@@ -20,44 +20,13 @@ import {
 	expectProductScheduled,
 } from "@tests/integration/billing/utils/expectCustomerProductCorrect";
 import { expectNoStripeSubscription } from "@tests/integration/billing/utils/expectNoStripeSubscription";
+import { getSubscriptionId } from "@tests/integration/billing/utils/stripe/getSubscriptionId";
 import { items } from "@tests/utils/fixtures/items";
 import { products } from "@tests/utils/fixtures/products";
 import { initScenario, s } from "@tests/utils/testInitUtils/initScenario";
 import chalk from "chalk";
-import type { AutumnContext } from "@/honoUtils/HonoEnv";
-import { CusService } from "@/internal/customers/CusService";
 import { timeout } from "@/utils/genUtils";
 
-/**
- * Helper to get subscription ID for a customer product.
- */
-const getSubscriptionId = async ({
-	ctx,
-	customerId,
-	productId,
-}: {
-	ctx: AutumnContext;
-	customerId: string;
-	productId: string;
-}): Promise<string> => {
-	const fullCustomer = await CusService.getFull({
-		db: ctx.db,
-		idOrInternalId: customerId,
-		orgId: ctx.org.id,
-		env: ctx.env,
-	});
-
-	const customerProduct = fullCustomer.customer_products.find(
-		(cp) => cp.product.id === productId,
-	);
-
-	if (!customerProduct?.subscription_ids?.length) {
-		throw new Error(`No subscription found for product ${productId}`);
-	}
-
-	return customerProduct.subscription_ids[0];
-};
-
 // ═══════════════════════════════════════════════════════════════════════════════
 // TEST 1: Cancel subscription directly via Stripe (with default free)
 // ═══════════════════════════════════════════════════════════════════════════════
diff --git a/server/tests/integration/billing/update-subscription/cancel/cancel-add-on.test.ts b/server/tests/integration/billing/update-subscription/cancel/cancel-add-on.test.ts
deleted file mode 100644
index 7a141faff..000000000
--- a/server/tests/integration/billing/update-subscription/cancel/cancel-add-on.test.ts
+++ /dev/null
@@ -1,142 +0,0 @@
-/**
- * Cancel Add-On Tests
- *
- * Tests for canceling products when add-ons are present.
- * Verifies that add-on products persist correctly when main products are canceled.
- */
-
-import { test } from "bun:test";
-import type { ApiCustomerV3 } from "@autumn/shared";
-import { expectCustomerInvoiceCorrect } from "@tests/integration/billing/utils/expectCustomerInvoiceCorrect";
-import {
-	expectCustomerProducts,
-	expectProductActive,
-} from "@tests/integration/billing/utils/expectCustomerProductCorrect";
-import { expectSubToBeCorrect } from "@tests/merged/mergeUtils/expectSubCorrect";
-import { items } from "@tests/utils/fixtures/items";
-import { products } from "@tests/utils/fixtures/products";
-import { advanceToNextInvoice } from "@tests/utils/testAttachUtils/testAttachUtils";
-import { initScenario, s } from "@tests/utils/testInitUtils/initScenario";
-import chalk from "chalk";
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// TEST 1: Cancel pro product, add-on persists with free default scheduled
-// ═══════════════════════════════════════════════════════════════════════════════
-
-/**
- * Scenario:
- * - Free default product exists
- * - Pro product ($20/mo)
- * - Recurring add-on product ($20/mo with 300 messages)
- * - User attaches Pro and Add-on
- * - User cancels Pro at end of cycle
- *
- * Expected Result:
- * - Pro should be canceling (active with canceled_at set)
- * - Free default should be scheduled
- * - Add-on should remain active (not affected by pro cancellation)
- * - After advancing to next invoice:
- *   - Pro is gone
- *   - Free is active
- *   - Add-on is still active
- */
-test.concurrent(`${chalk.yellowBright("cancel add-on: cancel pro, add-on persists with free scheduled")}`, async () => {
-	const customerId = "cancel-addon-pro-free-scheduled";
-
-	const messagesItem = items.monthlyMessages({ includedUsage: 100 });
-
-	// Free is the default product
-	const free = products.base({
-		id: "free",
-		items: [messagesItem],
-		isDefault: true,
-	});
-
-	// Pro product ($20/mo)
-	const pro = products.pro({
-		id: "pro",
-		items: [messagesItem],
-	});
-
-	// Recurring add-on with its own price ($20/mo + 300 messages)
-	const addon = products.recurringAddOn({
-		id: "addon",
-		items: [items.monthlyMessages({ includedUsage: 300 })],
-	});
-
-	const { autumnV1, ctx, testClockId } = await initScenario({
-		customerId,
-		setup: [
-			s.customer({ paymentMethod: "success" }),
-			s.products({ list: [free, pro, addon] }),
-		],
-		actions: [
-			s.attach({ productId: pro.id }),
-			s.attach({ productId: addon.id }),
-		],
-	});
-
-	// Verify pro and add-on are active
-	const customerAfterAttach =
-		await autumnV1.customers.get<ApiCustomerV3>(customerId);
-
-	await expectProductActive({
-		customer: customerAfterAttach,
-		productId: pro.id,
-	});
-
-	await expectProductActive({
-		customer: customerAfterAttach,
-		productId: addon.id,
-	});
-
-	// Verify invoices: pro attach ($20) + add-on attach ($20)
-	expectCustomerInvoiceCorrect({
-		customer: customerAfterAttach,
-		count: 2,
-		latestTotal: 20, // Add-on invoice
-	});
-
-	// Cancel pro at end of cycle
-	await autumnV1.subscriptions.update({
-		customer_id: customerId,
-		product_id: pro.id,
-		cancel: "end_of_cycle",
-	});
-
-	// Verify state after cancel
-	const customerAfterCancel =
-		await autumnV1.customers.get<ApiCustomerV3>(customerId);
-
-	await expectCustomerProducts({
-		customer: customerAfterCancel,
-		canceling: [pro.id],
-		scheduled: [free.id],
-		active: [addon.id],
-	});
-
-	// Advance to next billing cycle
-	await advanceToNextInvoice({
-		stripeCli: ctx.stripeCli,
-		testClockId: testClockId!,
-	});
-
-	// Verify state after cycle
-	const customerAfterAdvance =
-		await autumnV1.customers.get<ApiCustomerV3>(customerId);
-
-	await expectCustomerProducts({
-		customer: customerAfterAdvance,
-		notPresent: [pro.id],
-		active: [free.id, addon.id],
-	});
-
-	// Subscription should exist for the add-on
-	await expectSubToBeCorrect({
-		db: ctx.db,
-		customerId,
-		org: ctx.org,
-		env: ctx.env,
-		subCount: 1, // Add-on subscription remains
-	});
-});
diff --git a/server/tests/integration/billing/update-subscription/cancel/end-of-cycle/cancel-end-of-cycle-addon.test.ts b/server/tests/integration/billing/update-subscription/cancel/end-of-cycle/cancel-end-of-cycle-addon.test.ts
new file mode 100644
index 000000000..8f647a5dd
--- /dev/null
+++ b/server/tests/integration/billing/update-subscription/cancel/end-of-cycle/cancel-end-of-cycle-addon.test.ts
@@ -0,0 +1,625 @@
+/**
+ * Cancel End-of-Cycle Add-On Tests
+ *
+ * Tests for canceling add-on products at end of billing cycle.
+ * Verifies add-on cancellation behavior, subscription handling,
+ * and interaction with main products.
+ */
+
+import { expect, test } from "bun:test";
+import type { ApiCustomerV3 } from "@autumn/shared";
+import { expectCustomerInvoiceCorrect } from "@tests/integration/billing/utils/expectCustomerInvoiceCorrect";
+import {
+	expectCustomerProducts,
+	expectProductActive,
+	expectProductCanceling,
+	expectProductNotPresent,
+} from "@tests/integration/billing/utils/expectCustomerProductCorrect";
+import { getSubscriptionId } from "@tests/integration/billing/utils/stripe/getSubscriptionId";
+import { expectSubToBeCorrect } from "@tests/merged/mergeUtils/expectSubCorrect";
+import { items } from "@tests/utils/fixtures/items";
+import { products } from "@tests/utils/fixtures/products";
+import { advanceToNextInvoice } from "@tests/utils/testAttachUtils/testAttachUtils";
+import { initScenario, s } from "@tests/utils/testInitUtils/initScenario";
+import chalk from "chalk";
+import { isStripeSubscriptionCanceling } from "@/external/stripe/subscriptions/utils/classifyStripeSubscriptionUtils";
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// TEST 1: Cancel add-on EOC - add-on canceling, pro active, free default not scheduled
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Scenario:
+ * - Free default product exists
+ * - Pro product ($20/mo)
+ * - Recurring add-on product ($20/mo)
+ * - User attaches Pro and Add-on
+ * - User cancels Add-on at end of cycle
+ *
+ * Expected Result:
+ * - Pro should remain active
+ * - Add-on should be canceling (has canceled_at but still active)
+ * - Free default should NOT be scheduled (pro is still active)
+ * - After advancing to next invoice:
+ *   - Pro is still active
+ *   - Add-on is removed
+ *   - Free default is still not present
+ */
+test(`${chalk.yellowBright("cancel addon EOC: addon canceling, pro active, free default not scheduled")}`, async () => {
+	const customerId = "cancel-addon-eoc-basic";
+
+	const messagesItem = items.monthlyMessages({ includedUsage: 100 });
+
+	const free = products.base({
+		id: "free",
+		items: [messagesItem],
+		isDefault: true,
+	});
+
+	const pro = products.pro({
+		id: "pro",
+		items: [messagesItem],
+	});
+
+	const addon = products.recurringAddOn({
+		id: "addon",
+		items: [items.monthlyMessages({ includedUsage: 300 })],
+	});
+
+	const { autumnV1, ctx, testClockId } = await initScenario({
+		customerId,
+		setup: [
+			s.customer({ paymentMethod: "success" }),
+			s.products({ list: [free, pro, addon] }),
+		],
+		actions: [
+			s.attach({ productId: pro.id }),
+			s.attach({ productId: addon.id }),
+		],
+	});
+
+	// Verify pro and add-on are active, free not present
+	const customerAfterAttach =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+
+	await expectCustomerProducts({
+		customer: customerAfterAttach,
+		active: [pro.id, addon.id],
+		notPresent: [free.id],
+	});
+
+	// Verify invoices: pro attach ($20) + add-on attach ($20)
+	expectCustomerInvoiceCorrect({
+		customer: customerAfterAttach,
+		count: 2,
+		latestTotal: 20,
+	});
+
+	// Cancel add-on at end of cycle
+	await autumnV1.subscriptions.update({
+		customer_id: customerId,
+		product_id: addon.id,
+		cancel: "end_of_cycle",
+	});
+
+	// Verify state after cancel
+	const customerAfterCancel =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+
+	// Pro should still be active, add-on canceling, free NOT scheduled
+	await expectCustomerProducts({
+		customer: customerAfterCancel,
+		active: [pro.id],
+		canceling: [addon.id],
+		notPresent: [free.id],
+	});
+
+	// Advance to next billing cycle
+	await advanceToNextInvoice({
+		stripeCli: ctx.stripeCli,
+		testClockId: testClockId!,
+	});
+
+	// Verify state after cycle
+	const customerAfterAdvance =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+
+	// Pro should still be active, add-on removed, free still not present
+	await expectCustomerProducts({
+		customer: customerAfterAdvance,
+		active: [pro.id],
+		notPresent: [addon.id, free.id],
+	});
+
+	// Should have 1 subscription remaining (pro)
+	await expectSubToBeCorrect({
+		db: ctx.db,
+		customerId,
+		org: ctx.org,
+		env: ctx.env,
+		subCount: 1,
+	});
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// TEST 2: Cancel pro product, add-on persists with free default scheduled
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Scenario:
+ * - Free default product exists
+ * - Pro product ($20/mo)
+ * - Recurring add-on product ($20/mo with 300 messages)
+ * - User attaches Pro and Add-on
+ * - User cancels Pro at end of cycle
+ *
+ * Expected Result:
+ * - Pro should be canceling (active with canceled_at set)
+ * - Free default should be scheduled
+ * - Add-on should remain active (not affected by pro cancellation)
+ * - After advancing to next invoice:
+ *   - Pro is gone
+ *   - Free is active
+ *   - Add-on is still active
+ */
+test(`${chalk.yellowBright("cancel addon EOC: cancel pro, addon persists with free scheduled")}`, async () => {
+	const customerId = "cancel-addon-pro-free-scheduled";
+
+	const messagesItem = items.monthlyMessages({ includedUsage: 100 });
+
+	// Free is the default product
+	const free = products.base({
+		id: "free",
+		items: [messagesItem],
+		isDefault: true,
+	});
+
+	// Pro product ($20/mo)
+	const pro = products.pro({
+		id: "pro",
+		items: [messagesItem],
+	});
+
+	// Recurring add-on with its own price ($20/mo + 300 messages)
+	const addon = products.recurringAddOn({
+		id: "addon",
+		items: [items.monthlyMessages({ includedUsage: 300 })],
+	});
+
+	const { autumnV1, ctx, testClockId } = await initScenario({
+		customerId,
+		setup: [
+			s.customer({ paymentMethod: "success" }),
+			s.products({ list: [free, pro, addon] }),
+		],
+		actions: [
+			s.attach({ productId: pro.id }),
+			s.attach({ productId: addon.id }),
+		],
+	});
+
+	// Verify pro and add-on are active
+	const customerAfterAttach =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+
+	await expectProductActive({
+		customer: customerAfterAttach,
+		productId: pro.id,
+	});
+
+	await expectProductActive({
+		customer: customerAfterAttach,
+		productId: addon.id,
+	});
+
+	// Verify invoices: pro attach ($20) + add-on attach ($20)
+	expectCustomerInvoiceCorrect({
+		customer: customerAfterAttach,
+		count: 2,
+		latestTotal: 20, // Add-on invoice
+	});
+
+	// Cancel pro at end of cycle
+	await autumnV1.subscriptions.update({
+		customer_id: customerId,
+		product_id: pro.id,
+		cancel: "end_of_cycle",
+	});
+
+	// Verify state after cancel
+	const customerAfterCancel =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+
+	await expectCustomerProducts({
+		customer: customerAfterCancel,
+		canceling: [pro.id],
+		scheduled: [free.id],
+		active: [addon.id],
+	});
+
+	// Advance to next billing cycle
+	await advanceToNextInvoice({
+		stripeCli: ctx.stripeCli,
+		testClockId: testClockId!,
+	});
+
+	// Verify state after cycle
+	const customerAfterAdvance =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+
+	await expectCustomerProducts({
+		customer: customerAfterAdvance,
+		notPresent: [pro.id],
+		active: [free.id, addon.id],
+	});
+
+	// Subscription should exist for the add-on
+	await expectSubToBeCorrect({
+		db: ctx.db,
+		customerId,
+		org: ctx.org,
+		env: ctx.env,
+		subCount: 1, // Add-on subscription remains
+	});
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// TEST 3: Cancel add-on with separate subscription (new_billing_subscription)
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Scenario:
+ * - Pro product ($20/mo)
+ * - Recurring add-on product ($20/mo) attached with new_billing_subscription: true
+ * - User cancels Add-on at end of cycle
+ *
+ * Expected Result:
+ * - Two separate Stripe subscriptions exist initially
+ * - After cancel EOC, only the add-on's subscription should be marked as canceling
+ * - Pro's subscription should NOT be affected
+ * - After advancing to next invoice:
+ *   - Pro is still active with its subscription
+ *   - Add-on is removed
+ */
+test(`${chalk.yellowBright("cancel addon EOC: separate subscription (new_billing_subscription), correct sub canceled")}`, async () => {
+	const customerId = "cancel-addon-eoc-separate-sub";
+
+	const messagesItem = items.monthlyMessages({ includedUsage: 100 });
+
+	const pro = products.pro({
+		id: "pro",
+		items: [messagesItem],
+	});
+
+	const addon = products.recurringAddOn({
+		id: "addon",
+		items: [items.monthlyMessages({ includedUsage: 300 })],
+	});
+
+	const { autumnV1, ctx, testClockId } = await initScenario({
+		customerId,
+		setup: [
+			s.customer({ paymentMethod: "success" }),
+			s.products({ list: [pro, addon] }),
+		],
+		actions: [
+			s.attach({ productId: pro.id }),
+			s.attach({ productId: addon.id, newBillingSubscription: true }),
+		],
+	});
+
+	// Get both subscription IDs (customerId is used as product prefix by default)
+	const proSubId = await getSubscriptionId({
+		ctx,
+		customerId,
+		productId: `${pro.id}_${customerId}`,
+	});
+
+	const addonSubId = await getSubscriptionId({
+		ctx,
+		customerId,
+		productId: `${addon.id}_${customerId}`,
+	});
+
+	// Verify they are different subscriptions
+	expect(proSubId).not.toBe(addonSubId);
+
+	// Verify both subscriptions are active (not canceling)
+	const proSubBefore = await ctx.stripeCli.subscriptions.retrieve(proSubId);
+	const addonSubBefore = await ctx.stripeCli.subscriptions.retrieve(addonSubId);
+
+	expect(isStripeSubscriptionCanceling(proSubBefore)).toBe(false);
+	expect(isStripeSubscriptionCanceling(addonSubBefore)).toBe(false);
+
+	// Cancel add-on at end of cycle
+	await autumnV1.subscriptions.update({
+		customer_id: customerId,
+		product_id: addon.id,
+		cancel: "end_of_cycle",
+	});
+
+	// Verify only the add-on subscription is canceling
+	const proSubAfterCancel =
+		await ctx.stripeCli.subscriptions.retrieve(proSubId);
+	const addonSubAfterCancel =
+		await ctx.stripeCli.subscriptions.retrieve(addonSubId);
+
+	// Pro subscription should NOT be canceling
+	expect(isStripeSubscriptionCanceling(proSubAfterCancel)).toBe(false);
+
+	// Add-on subscription SHOULD be canceling
+	expect(isStripeSubscriptionCanceling(addonSubAfterCancel)).toBe(true);
+
+	// Verify customer product states
+	const customerAfterCancel =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+
+	await expectProductActive({
+		customer: customerAfterCancel,
+		productId: pro.id,
+	});
+
+	await expectProductCanceling({
+		customer: customerAfterCancel,
+		productId: addon.id,
+	});
+
+	// Advance to next billing cycle
+	await advanceToNextInvoice({
+		stripeCli: ctx.stripeCli,
+		testClockId: testClockId!,
+	});
+
+	// Verify state after cycle
+	const customerAfterAdvance =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+
+	// Pro should still be active
+	await expectProductActive({
+		customer: customerAfterAdvance,
+		productId: pro.id,
+	});
+
+	// Add-on should be removed
+	await expectProductNotPresent({
+		customer: customerAfterAdvance,
+		productId: addon.id,
+	});
+
+	// Pro subscription should still exist and be active
+	const proSubAfterAdvance =
+		await ctx.stripeCli.subscriptions.retrieve(proSubId);
+	expect(proSubAfterAdvance.status).toBe("active");
+	expect(isStripeSubscriptionCanceling(proSubAfterAdvance)).toBe(false);
+
+	// Should have 1 subscription remaining (pro)
+	await expectSubToBeCorrect({
+		db: ctx.db,
+		customerId,
+		org: ctx.org,
+		env: ctx.env,
+		subCount: 1,
+	});
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// TEST 4: Multiple add-ons - cancel one EOC, other persists
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Scenario:
+ * - Pro product ($20/mo)
+ * - Add-on 1 ($20/mo)
+ * - Add-on 2 ($20/mo)
+ * - User attaches Pro, Add-on 1, and Add-on 2
+ * - User cancels Add-on 1 at end of cycle
+ *
+ * Expected Result:
+ * - Pro and Add-on 2 remain active
+ * - Add-on 1 is canceling
+ * - After advancing to next invoice:
+ *   - Pro and Add-on 2 are still active
+ *   - Add-on 1 is removed
+ */
+test(`${chalk.yellowBright("cancel addon EOC: multiple addons, cancel one, other persists")}`, async () => {
+	const customerId = "cancel-addon-eoc-multiple";
+
+	const messagesItem = items.monthlyMessages({ includedUsage: 100 });
+
+	const pro = products.pro({
+		id: "pro",
+		items: [messagesItem],
+	});
+
+	const addon1 = products.recurringAddOn({
+		id: "addon1",
+		items: [items.monthlyMessages({ includedUsage: 200 })],
+	});
+
+	const addon2 = products.recurringAddOn({
+		id: "addon2",
+		items: [items.monthlyMessages({ includedUsage: 300 })],
+	});
+
+	const { autumnV1, ctx, testClockId } = await initScenario({
+		customerId,
+		setup: [
+			s.customer({ paymentMethod: "success" }),
+			s.products({ list: [pro, addon1, addon2] }),
+		],
+		actions: [
+			s.attach({ productId: pro.id }),
+			s.attach({ productId: addon1.id }),
+			s.attach({ productId: addon2.id }),
+		],
+	});
+
+	// Verify all products are active
+	const customerAfterAttach =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+
+	await expectProductActive({
+		customer: customerAfterAttach,
+		productId: pro.id,
+	});
+	await expectProductActive({
+		customer: customerAfterAttach,
+		productId: addon1.id,
+	});
+	await expectProductActive({
+		customer: customerAfterAttach,
+		productId: addon2.id,
+	});
+
+	// Verify invoices: pro ($20) + addon1 ($20) + addon2 ($20)
+	expectCustomerInvoiceCorrect({
+		customer: customerAfterAttach,
+		count: 3,
+		latestTotal: 20,
+	});
+
+	// Cancel add-on 1 at end of cycle
+	await autumnV1.subscriptions.update({
+		customer_id: customerId,
+		product_id: addon1.id,
+		cancel: "end_of_cycle",
+	});
+
+	// Verify state after cancel
+	const customerAfterCancel =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+
+	await expectProductActive({
+		customer: customerAfterCancel,
+		productId: pro.id,
+	});
+	await expectProductCanceling({
+		customer: customerAfterCancel,
+		productId: addon1.id,
+	});
+	await expectProductActive({
+		customer: customerAfterCancel,
+		productId: addon2.id,
+	});
+
+	// Advance to next billing cycle
+	await advanceToNextInvoice({
+		stripeCli: ctx.stripeCli,
+		testClockId: testClockId!,
+	});
+
+	// Verify state after cycle
+	const customerAfterAdvance =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+
+	await expectProductActive({
+		customer: customerAfterAdvance,
+		productId: pro.id,
+	});
+	await expectProductNotPresent({
+		customer: customerAfterAdvance,
+		productId: addon1.id,
+	});
+	await expectProductActive({
+		customer: customerAfterAdvance,
+		productId: addon2.id,
+	});
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// TEST 5: Entity-level add-on cancel EOC
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Scenario:
+ * - Entity has Pro product ($20/mo)
+ * - Entity has Add-on product ($20/mo)
+ * - User cancels Add-on at end of cycle on entity
+ *
+ * Expected Result:
+ * - Entity's Pro remains active
+ * - Entity's Add-on is canceling
+ * - After advancing to next invoice:
+ *   - Entity's Pro is still active
+ *   - Entity's Add-on is removed
+ */
+test(`${chalk.yellowBright("cancel addon EOC: entity-level addon cancel")}`, async () => {
+	const customerId = "cancel-addon-eoc-entity";
+
+	const messagesItem = items.monthlyMessages({ includedUsage: 100 });
+
+	const pro = products.pro({
+		id: "pro",
+		items: [messagesItem],
+	});
+
+	const addon = products.recurringAddOn({
+		id: "addon",
+		items: [items.monthlyMessages({ includedUsage: 300 })],
+	});
+
+	const { autumnV1, ctx, testClockId, entities } = await initScenario({
+		customerId,
+		setup: [
+			s.customer({ paymentMethod: "success" }),
+			s.products({ list: [pro, addon] }),
+			s.entities({ count: 1, featureId: "users" }),
+		],
+		actions: [
+			s.attach({ productId: pro.id, entityIndex: 0 }),
+			s.attach({ productId: addon.id, entityIndex: 0 }),
+		],
+	});
+
+	const entityId = entities[0].id;
+
+	// Verify pro and add-on are active on entity
+	const entityAfterAttach = await autumnV1.entities.get(customerId, entityId);
+
+	await expectProductActive({
+		customer: entityAfterAttach,
+		productId: pro.id,
+	});
+	await expectProductActive({
+		customer: entityAfterAttach,
+		productId: addon.id,
+	});
+
+	// Cancel add-on at end of cycle on entity
+	await autumnV1.subscriptions.update({
+		customer_id: customerId,
+		entity_id: entityId,
+		product_id: addon.id,
+		cancel: "end_of_cycle",
+	});
+
+	// Verify state after cancel
+	const entityAfterCancel = await autumnV1.entities.get(customerId, entityId);
+
+	await expectProductActive({
+		customer: entityAfterCancel,
+		productId: pro.id,
+	});
+	await expectProductCanceling({
+		customer: entityAfterCancel,
+		productId: addon.id,
+	});
+
+	// Advance to next billing cycle
+	await advanceToNextInvoice({
+		stripeCli: ctx.stripeCli,
+		testClockId: testClockId!,
+	});
+
+	// Verify state after cycle
+	const entityAfterAdvance = await autumnV1.entities.get(customerId, entityId);
+
+	await expectProductActive({
+		customer: entityAfterAdvance,
+		productId: pro.id,
+	});
+	await expectProductNotPresent({
+		customer: entityAfterAdvance,
+		productId: addon.id,
+	});
+});
diff --git a/server/tests/integration/billing/update-subscription/cancel/cancel-consumable-entities.test.ts b/server/tests/integration/billing/update-subscription/cancel/end-of-cycle/cancel-end-of-cycle-consumable.test.ts
similarity index 63%
rename from server/tests/integration/billing/update-subscription/cancel/cancel-consumable-entities.test.ts
rename to server/tests/integration/billing/update-subscription/cancel/end-of-cycle/cancel-end-of-cycle-consumable.test.ts
index 521e278a4..b55075b14 100644
--- a/server/tests/integration/billing/update-subscription/cancel/cancel-consumable-entities.test.ts
+++ b/server/tests/integration/billing/update-subscription/cancel/end-of-cycle/cancel-end-of-cycle-consumable.test.ts
@@ -1,36 +1,142 @@
 /**
- * Cancel Consumable Entity Tests
+ * Cancel End of Cycle Consumable Tests
  *
- * Tests for canceling entity-level products with consumable/arrear items (pay-per-use overage).
+ * Tests for canceling products with consumable/arrear items at end of cycle.
  * Consumable items create a final invoice at end of cycle for any overage usage.
  *
  * Key behaviors:
  * - Overage usage is billed at cycle end (arrear pricing)
  * - Cancel end of cycle: overage billed in final invoice when cycle ends naturally
- * - Cancel immediately: NO overage billed - only base price refund (arrear overages not charged on cancel)
- * - Default update subscription behavior does NOT charge for arrear overages
+ * - Both customer-level and entity-level consumables are covered
  */
 
 import { expect, test } from "bun:test";
 import type { ApiCustomerV3 } from "@autumn/shared";
 import { calculateExpectedInvoiceAmount } from "@tests/integration/billing/utils/calculateExpectedInvoiceAmount";
+import { expectCustomerFeatureCorrect } from "@tests/integration/billing/utils/expectCustomerFeatureCorrect";
 import { expectCustomerInvoiceCorrect } from "@tests/integration/billing/utils/expectCustomerInvoiceCorrect";
 import {
 	expectProductActive,
 	expectProductCanceling,
 	expectProductNotPresent,
 } from "@tests/integration/billing/utils/expectCustomerProductCorrect";
-import { expectNoStripeSubscription } from "@tests/integration/billing/utils/expectNoStripeSubscription";
-import { expectSubToBeCorrect } from "@tests/merged/mergeUtils/expectSubCorrect";
+import { expectStripeInvoiceLineItemPeriodCorrect } from "@tests/integration/billing/utils/stripe/expectStripeInvoiceLineItemPeriodCorrect";
 import { TestFeature } from "@tests/setup/v2Features";
 import { items } from "@tests/utils/fixtures/items";
 import { products } from "@tests/utils/fixtures/products";
 import { advanceToNextInvoice } from "@tests/utils/testAttachUtils/testAttachUtils";
 import { initScenario, s } from "@tests/utils/testInitUtils/initScenario";
 import chalk from "chalk";
+import { addMonths } from "date-fns";
 
 // ═══════════════════════════════════════════════════════════════════════════════
-// TEST 1: Track → cancel end of cycle → advance (entity)
+// TEST 1: Track → cancel end of cycle → advance (customer-level)
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Scenario:
+ * - Customer has Pro with consumable messages (100 included, $0.10/unit overage)
+ * - Track 500 messages (400 overage)
+ * - Cancel end of cycle
+ * - Advance to next invoice
+ *
+ * Expected Result:
+ * - Initial invoice: $20 (pro base price)
+ * - Final invoice: $40 (400 overage * $0.10)
+ * - Product removed after cycle ends
+ */
+test.concurrent(`${chalk.yellowBright("cancel end of cycle consumable: customer - track overage → cancel → advance")}`, async () => {
+	const customerId = "cancel-eoc-cons-cus";
+
+	const consumableItem = items.consumableMessages({ includedUsage: 100 });
+	const pro = products.pro({
+		id: "pro",
+		items: [consumableItem],
+	});
+
+	const { autumnV1Beta, ctx, testClockId } = await initScenario({
+		customerId,
+		setup: [
+			s.customer({ paymentMethod: "success" }),
+			s.products({ list: [pro] }),
+		],
+		actions: [s.attach({ productId: pro.id })],
+	});
+
+	// Verify pro is active
+	const customerAfterAttach =
+		await autumnV1Beta.customers.get<ApiCustomerV3>(customerId);
+	await expectProductActive({
+		customer: customerAfterAttach,
+		productId: pro.id,
+	});
+
+	// Initial attach invoice: $20 base price
+	expectCustomerInvoiceCorrect({
+		customer: customerAfterAttach,
+		count: 1,
+		latestTotal: 20,
+	});
+
+	// Track 500 messages (100 included, 400 overage)
+	await autumnV1Beta.track({
+		customer_id: customerId,
+		feature_id: TestFeature.Messages,
+		value: 500,
+	});
+
+	// Cancel end of cycle
+	await autumnV1Beta.subscriptions.update({
+		customer_id: customerId,
+		product_id: pro.id,
+		cancel: "end_of_cycle",
+	});
+
+	// Verify pro is canceling
+	const customerAfterCancel =
+		await autumnV1Beta.customers.get<ApiCustomerV3>(customerId);
+	await expectProductCanceling({
+		customer: customerAfterCancel,
+		productId: pro.id,
+	});
+
+	// Advance to next invoice
+	await advanceToNextInvoice({
+		stripeCli: ctx.stripeCli,
+		testClockId: testClockId!,
+	});
+
+	// Calculate expected overage amount
+	// 500 total usage - 100 included = 400 overage * $0.10 = $40
+	const expectedOverage = calculateExpectedInvoiceAmount({
+		items: pro.items,
+		usage: [{ featureId: TestFeature.Messages, value: 500 }],
+		options: { includeFixed: false, onlyArrear: true },
+	});
+
+	expect(expectedOverage).toBe(40);
+
+	// Verify final state
+	const customerAfterAdvance =
+		await autumnV1Beta.customers.get<ApiCustomerV3>(customerId);
+
+	// Product should be removed
+	await expectProductNotPresent({
+		customer: customerAfterAdvance,
+		productId: pro.id,
+	});
+
+	// Should have 2 invoices: initial ($20) + final overage ($40)
+	expectCustomerInvoiceCorrect({
+		customer: customerAfterAdvance,
+		count: 2,
+		latestTotal: expectedOverage,
+		latestInvoiceProductId: pro.id,
+	});
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// TEST 2: Track → cancel end of cycle → advance (entity)
 // ═══════════════════════════════════════════════════════════════════════════════
 
 /**
@@ -44,11 +150,9 @@ import chalk from "chalk";
  * - Initial invoice: $20 (pro base price)
  * - Final invoice: $40 (400 overage * $0.10)
  * - Entity product removed after cycle ends
- *
- * Migrated from: entity3.test.ts
  */
-test.concurrent(`${chalk.yellowBright("cancel consumable entity: track → cancel end of cycle → advance")}`, async () => {
-	const customerId = "cancel-cons-eoc-ent";
+test.concurrent(`${chalk.yellowBright("cancel end of cycle consumable: entity - track overage → cancel → advance")}`, async () => {
+	const customerId = "cancel-eoc-cons-ent";
 
 	const consumableItem = items.consumableMessages({ includedUsage: 100 });
 	const pro = products.pro({
@@ -124,103 +228,6 @@ test.concurrent(`${chalk.yellowBright("cancel consumable entity: track → cance
 	expect(customerAfterAdvance.invoices?.[0].total).toBe(40);
 });
 
-// ═══════════════════════════════════════════════════════════════════════════════
-// TEST 2: Track → cancel immediately (entity)
-// ═══════════════════════════════════════════════════════════════════════════════
-
-/**
- * Scenario:
- * - Entity has Pro with consumable messages (100 included, $0.10/unit overage)
- * - Track 500 messages on entity (400 overage)
- * - Cancel entity's product immediately
- *
- * Expected Result:
- * - Initial invoice: $20 (pro base price)
- * - Final invoice: -$20 (base refund only, no overage - arrear overages not charged on cancel)
- * - Entity product removed immediately
- */
-test.concurrent(`${chalk.yellowBright("cancel consumable entity: track → cancel immediately - no overage charge")}`, async () => {
-	const customerId = "cancel-cons-imm-ent";
-
-	const consumableItem = items.consumableMessages({ includedUsage: 100 });
-	const pro = products.pro({
-		id: "pro",
-		items: [consumableItem],
-	});
-
-	const { autumnV1, ctx, entities } = await initScenario({
-		customerId,
-		setup: [
-			s.customer({ paymentMethod: "success" }),
-			s.products({ list: [pro] }),
-			s.entities({ count: 1, featureId: TestFeature.Users }),
-		],
-		actions: [s.attach({ productId: pro.id, entityIndex: 0 })],
-	});
-
-	const entityId = entities[0].id;
-
-	// Verify pro is active on entity
-	const entity = await autumnV1.entities.get(customerId, entityId);
-	await expectProductActive({
-		customer: entity,
-		productId: pro.id,
-	});
-
-	// Track 500 messages on entity (100 included, 400 overage)
-	// Note: This overage will NOT be charged when canceling immediately
-	await autumnV1.track({
-		customer_id: customerId,
-		entity_id: entityId,
-		feature_id: TestFeature.Messages,
-		value: 500,
-	});
-
-	// Preview cancel immediately
-	const cancelParams = {
-		customer_id: customerId,
-		entity_id: entityId,
-		product_id: pro.id,
-		cancel: "immediately" as const,
-	};
-	const preview = await autumnV1.subscriptions.previewUpdate(cancelParams);
-
-	// Final invoice = base refund only (-$20), no overage charged on cancel
-	expect(preview.total).toBe(-20);
-
-	// Execute cancel
-	await autumnV1.subscriptions.update(cancelParams);
-
-	// Verify pro is removed from entity
-	const entityAfterCancel = await autumnV1.entities.get(customerId, entityId);
-	await expectProductNotPresent({
-		customer: entityAfterCancel,
-		productId: pro.id,
-	});
-
-	// Verify no Stripe subscription exists
-	await expectNoStripeSubscription({
-		db: ctx.db,
-		customerId,
-		org: ctx.org,
-		env: ctx.env,
-	});
-
-	// Check customer invoices
-	const customerAfterCancel =
-		await autumnV1.customers.get<ApiCustomerV3>(customerId);
-
-	// Should have 2 invoices: initial ($20) + final (refund -$20)
-	expect(customerAfterCancel.invoices?.length).toBe(2);
-
-	// Verify final invoice matches preview (refund only)
-	expectCustomerInvoiceCorrect({
-		customer: customerAfterCancel,
-		count: 2,
-		latestTotal: preview.total,
-	});
-});
-
 // ═══════════════════════════════════════════════════════════════════════════════
 // TEST 3: Two entities, both overage, cancel end of cycle → advance
 // ═══════════════════════════════════════════════════════════════════════════════
@@ -236,8 +243,8 @@ test.concurrent(`${chalk.yellowBright("cancel consumable entity: track → cance
  * - Both entities' overage billed in final invoices
  * - Both products removed after cycle ends
  */
-test.concurrent(`${chalk.yellowBright("cancel consumable entity: two entities, both overage, cancel end of cycle")}`, async () => {
-	const customerId = "cancel-cons-2ent-eoc";
+test.concurrent(`${chalk.yellowBright("cancel end of cycle consumable: two entities, both overage → cancel → advance")}`, async () => {
+	const customerId = "cancel-eoc-cons-2ent";
 
 	const consumableItem = items.consumableMessages({ includedUsage: 100 });
 	const pro = products.pro({
@@ -379,8 +386,8 @@ test.concurrent(`${chalk.yellowBright("cancel consumable entity: two entities, b
  * - Entity 1's overage billed, product removed
  * - Entity 2 continues with subscription, renews normally
  */
-test.concurrent(`${chalk.yellowBright("cancel consumable entity: two entities, cancel one end of cycle, keep one active")}`, async () => {
-	const customerId = "cancel-cons-2ent-1eoc";
+test.concurrent(`${chalk.yellowBright("cancel end of cycle consumable: two entities, cancel one, keep one active")}`, async () => {
+	const customerId = "cancel-eoc-cons-2ent-1cancel";
 
 	const consumableItem = items.consumableMessages({ includedUsage: 100 });
 	const pro = products.pro({
@@ -485,7 +492,7 @@ test.concurrent(`${chalk.yellowBright("cancel consumable entity: two entities, c
 	// Check customer invoices
 	const customerFinal = await autumnV1.customers.get<ApiCustomerV3>(customerId);
 
-	// Should have 4 invoices:
+	// Should have 3 invoices:
 	// - 2 initial invoices ($20 each for entity attaches)
 	// - 1 final invoice for entity 1 overage ($30) + entity 2 overage ($10) + entity 2 renewal ($20) = $60
 	expectCustomerInvoiceCorrect({
@@ -496,193 +503,255 @@ test.concurrent(`${chalk.yellowBright("cancel consumable entity: two entities, c
 });
 
 // ═══════════════════════════════════════════════════════════════════════════════
-// TEST 5: Two entities, cancel one immediately, keep one active
+// TEST 5: Entity + Customer consumables - cancel customer end of cycle (no double billing)
 // ═══════════════════════════════════════════════════════════════════════════════
 
 /**
  * Scenario:
- * - Entity 1 and Entity 2 both have Pro with consumable messages
- * - Track usage into overage on both entities
- * - Cancel only Entity 1 immediately
- * - Keep Entity 2 active
+ * - Customer has customer-level Pro with consumable messages (uses Stripe meters)
+ * - Customer also has entity-level Pro with consumable messages (uses invoice line items)
+ * - Track overage on BOTH customer and entity
+ * - Cancel CUSTOMER-level product end of cycle (entity stays active)
+ * - Advance to next invoice
  *
  * Expected Result:
- * - Entity 1's final invoice: -$20 (base refund only, no overage charge)
- * - Entity 1 product removed immediately
- * - Entity 2 continues unaffected
+ * - Customer overage billed once (no double billing)
+ * - Entity overage billed once
+ * - Customer product removed, entity product renews
  */
-test.concurrent(`${chalk.yellowBright("cancel consumable entity: two entities, cancel one immediately, keep one active - no overage charge")}`, async () => {
-	const customerId = "cancel-cons-2ent-1imm";
+test.concurrent(`${chalk.yellowBright("cancel end of cycle consumable: entity + customer - cancel customer (no double billing)")}`, async () => {
+	const customerId = "cancel-eoc-cons-ent-cus";
 
-	const consumableItem = items.consumableMessages({ includedUsage: 100 });
-	const pro = products.pro({
-		id: "pro",
-		items: [consumableItem],
+	// Customer-level consumable messages (will use Stripe meters)
+	const customerConsumable = items.consumableMessages({ includedUsage: 100 });
+
+	// Entity-level consumable messages (will use invoice line items)
+	const entityConsumable = items.consumableMessages({
+		includedUsage: 100,
+		entityFeatureId: TestFeature.Users,
 	});
 
-	const { autumnV1, ctx, entities } = await initScenario({
+	// Two separate products - both $20 base
+	const customerPro = products.pro({
+		id: "customer-pro",
+		items: [customerConsumable],
+	});
+
+	const entityPro = products.pro({
+		id: "entity-pro",
+		items: [entityConsumable],
+	});
+
+	const { autumnV1, ctx, testClockId, entities } = await initScenario({
 		customerId,
 		setup: [
 			s.customer({ paymentMethod: "success" }),
-			s.products({ list: [pro] }),
-			s.entities({ count: 2, featureId: TestFeature.Users }),
+			s.products({ list: [customerPro, entityPro] }),
+			s.entities({ count: 1, featureId: TestFeature.Users }),
 		],
 		actions: [
-			s.attach({ productId: pro.id, entityIndex: 0 }),
-			s.attach({ productId: pro.id, entityIndex: 1 }),
+			s.attach({ productId: customerPro.id }), // Customer-level
+			s.attach({ productId: entityPro.id, entityIndex: 0, timeout: 4000 }), // Entity-level
+			s.track({ featureId: TestFeature.Messages, value: 300 }),
+			s.track({ featureId: TestFeature.Messages, value: 250 }),
+			s.updateSubscription({
+				productId: customerPro.id,
+				cancel: "end_of_cycle",
+			}),
 		],
 	});
 
-	const entity1Id = entities[0].id;
-	const entity2Id = entities[1].id;
+	const entityId = entities[0].id;
 
-	// Verify initial invoices: 2 invoices, $20 each for entity attaches
+	// Verify initial invoices: $20 for customer-pro + $20 for entity-pro = $40
 	const customerAfterAttach =
 		await autumnV1.customers.get<ApiCustomerV3>(customerId);
 	expectCustomerInvoiceCorrect({
 		customer: customerAfterAttach,
 		count: 2,
-		latestTotal: 20,
 	});
 
-	// Track usage on entity 1: 500 messages (400 overage)
-	// Note: This overage will NOT be charged when canceling immediately
-	await autumnV1.track({
-		customer_id: customerId,
-		entity_id: entity1Id,
-		feature_id: TestFeature.Messages,
-		value: 500,
-	});
-
-	// Track usage on entity 2: 150 messages (50 overage)
-	await autumnV1.track({
-		customer_id: customerId,
-		entity_id: entity2Id,
-		feature_id: TestFeature.Messages,
-		value: 150,
-	});
-
-	// Cancel only entity 1 immediately
-	await autumnV1.subscriptions.update({
-		customer_id: customerId,
-		entity_id: entity1Id,
-		product_id: pro.id,
-		cancel: "immediately",
-	});
-
-	// Verify entity 1 product removed immediately, entity 2 still active
-	const entity1AfterCancel = await autumnV1.entities.get(customerId, entity1Id);
-	const entity2AfterCancel = await autumnV1.entities.get(customerId, entity2Id);
-	await expectProductNotPresent({
-		customer: entity1AfterCancel,
-		productId: pro.id,
-	});
-	await expectProductActive({
-		customer: entity2AfterCancel,
-		productId: pro.id,
-	});
-
-	// Check customer invoices
-	const customerAfterCancel =
+	const customerAfterTrack =
 		await autumnV1.customers.get<ApiCustomerV3>(customerId);
 
-	// Should have 3 invoices:
-	// - 2 initial invoices ($20 each for entity attaches)
-	// - 1 final invoice for entity 1 refund (-$20, no overage charged on cancel)
-	expectCustomerInvoiceCorrect({
+	const entityAfterTrack = await autumnV1.entities.get(customerId, entityId);
+
+	expect(customerAfterTrack.features[TestFeature.Messages].balance).toBe(-350);
+
+	expect(entityAfterTrack.features[TestFeature.Messages].balance).toBe(-350);
+
+	// Verify customer product is canceling
+	const customerAfterCancel =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+	await expectProductCanceling({
 		customer: customerAfterCancel,
-		count: 3,
-		latestTotal: -20,
+		productId: customerPro.id,
 	});
 
-	// Verify entity 2 has the product and subscription exists
-	await expectSubToBeCorrect({
-		db: ctx.db,
+	// Advance to next invoice
+	const advancedTo = await advanceToNextInvoice({
+		stripeCli: ctx.stripeCli,
+		testClockId: testClockId!,
+	});
+
+	// Verify final state
+	const customerFinal = await autumnV1.customers.get<ApiCustomerV3>(customerId);
+
+	// Customer product should be removed
+	await expectProductNotPresent({
+		customer: customerFinal,
+		productId: customerPro.id,
+	});
+
+	// Entity product should still be active (not canceled)
+	const entityFinal = await autumnV1.entities.get(customerId, entityId);
+	await expectProductActive({
+		customer: entityFinal,
+		productId: entityPro.id,
+	});
+
+	expectCustomerFeatureCorrect({
+		customer: customerFinal,
+		featureId: TestFeature.Messages,
+		balance: 100,
+		resetsAt: addMonths(Date.now(), 2).getTime(),
+	});
+
+	const overageTotal = 35;
+	expectCustomerInvoiceCorrect({
+		customer: customerFinal,
+		count: 3, // 2 initial attaches + 1 overage invoice
+		latestTotal: overageTotal + 20, // 20 for one renewal.
+	});
+
+	// Verify line item billing periods are correct (now -> now + 1 month)
+	await expectStripeInvoiceLineItemPeriodCorrect({
 		customerId,
-		org: ctx.org,
-		env: ctx.env,
-		subCount: 1, // Entity 2's subscription should still exist
+		productId: entityPro.id,
+		periodStartMs: Date.now(),
+		periodEndMs: advancedTo,
 	});
 });
 
 // ═══════════════════════════════════════════════════════════════════════════════
-// TEST 6: Entity within included usage, cancel immediately (no overage)
+// TEST 6: Entity + Customer consumables - cancel BOTH end of cycle (no double billing)
 // ═══════════════════════════════════════════════════════════════════════════════
 
 /**
  * Scenario:
- * - Entity has Pro with consumable messages (100 included)
- * - Track 50 messages (within included usage, no overage)
- * - Cancel immediately
+ * - Customer has customer-level Pro with consumable messages (uses Stripe meters)
+ * - Customer also has entity-level Pro with consumable messages (uses invoice line items)
+ * - Track overage on BOTH customer and entity
+ * - Cancel BOTH products end of cycle
+ * - Advance to next invoice
  *
  * Expected Result:
- * - No overage invoice (usage within included)
- * - Only refund invoice for unused time (if applicable)
- * - Product removed immediately
+ * - Final invoice should only contain overages (no base prices)
+ * - Customer overage: $35 (350 * $0.10)
+ * - Entity overage: $35 (350 * $0.10)
+ * - Total final invoice: $35 (combined, no double billing)
  */
-test.concurrent(`${chalk.yellowBright("cancel consumable entity: within included usage, cancel immediately")}`, async () => {
-	const customerId = "cancel-cons-no-overage";
+test.concurrent(`${chalk.yellowBright("cancel end of cycle consumable: entity + customer - cancel both (no double billing)")}`, async () => {
+	const customerId = "cancel-eoc-cons-both";
 
-	const consumableItem = items.consumableMessages({ includedUsage: 100 });
-	const pro = products.pro({
-		id: "pro",
-		items: [consumableItem],
+	// Customer-level consumable messages (will use Stripe meters)
+	const customerConsumable = items.consumableMessages({ includedUsage: 100 });
+
+	// Entity-level consumable messages (will use invoice line items)
+	const entityConsumable = items.consumableMessages({
+		includedUsage: 100,
+		entityFeatureId: TestFeature.Users,
 	});
 
-	const { autumnV1, entities } = await initScenario({
+	// Two separate products - both $20 base
+	const customerPro = products.pro({
+		id: "customer-pro",
+		items: [customerConsumable],
+	});
+
+	const entityPro = products.pro({
+		id: "entity-pro",
+		items: [entityConsumable],
+	});
+
+	const { autumnV1, ctx, testClockId, entities } = await initScenario({
 		customerId,
 		setup: [
 			s.customer({ paymentMethod: "success" }),
-			s.products({ list: [pro] }),
+			s.products({ list: [customerPro, entityPro] }),
 			s.entities({ count: 1, featureId: TestFeature.Users }),
 		],
-		actions: [s.attach({ productId: pro.id, entityIndex: 0 })],
+		actions: [
+			s.attach({ productId: customerPro.id }), // Customer-level
+			s.attach({ productId: entityPro.id, entityIndex: 0, timeout: 4000 }), // Entity-level
+			s.track({ featureId: TestFeature.Messages, value: 300 }),
+			s.track({ featureId: TestFeature.Messages, value: 250 }),
+			s.updateSubscription({
+				productId: customerPro.id,
+				cancel: "end_of_cycle",
+			}),
+			s.updateSubscription({
+				entityIndex: 0,
+				productId: entityPro.id,
+				cancel: "end_of_cycle",
+			}),
+		],
 	});
 
 	const entityId = entities[0].id;
 
-	// Verify pro is active on entity
-	const entity = await autumnV1.entities.get(customerId, entityId);
-	await expectProductActive({
-		customer: entity,
-		productId: pro.id,
-	});
-
-	// Track 50 messages (within 100 included, no overage)
-	await autumnV1.track({
-		customer_id: customerId,
-		entity_id: entityId,
-		feature_id: TestFeature.Messages,
-		value: 50,
-	});
-
-	// Verify balance is correct (100 - 50 = 50)
+	const customerAfterTrack =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
 	const entityAfterTrack = await autumnV1.entities.get(customerId, entityId);
-	expect(entityAfterTrack.features[TestFeature.Messages].balance).toBe(50);
 
-	// Cancel immediately
-	await autumnV1.subscriptions.update({
-		customer_id: customerId,
-		entity_id: entityId,
-		product_id: pro.id,
-		cancel: "immediately",
-	});
+	// Customer and entity balance: 200 - 550 = -350
+	expect(customerAfterTrack.features[TestFeature.Messages].balance).toBe(-350);
+	expect(entityAfterTrack.features[TestFeature.Messages].balance).toBe(-350);
 
-	// Verify product removed
-	const entityAfterCancel = await autumnV1.entities.get(customerId, entityId);
-	await expectProductNotPresent({
-		customer: entityAfterCancel,
-		productId: pro.id,
-	});
-
-	// Check invoices - should have initial ($20) and possibly refund, but NO overage charge
+	// Verify both products are canceling
 	const customerAfterCancel =
 		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+	await expectProductCanceling({
+		customer: customerAfterCancel,
+		productId: customerPro.id,
+	});
 
-	// Verify the final invoice (if exists) is a refund (negative or zero), not an overage charge
-	if (customerAfterCancel.invoices && customerAfterCancel.invoices.length > 1) {
-		const finalInvoice = customerAfterCancel.invoices[0];
-		// Final invoice should be refund (negative) or small, not a large overage charge
-		expect(finalInvoice.total).toBeLessThanOrEqual(0);
-	}
+	const entityAfterCancel = await autumnV1.entities.get(customerId, entityId);
+	await expectProductCanceling({
+		customer: entityAfterCancel,
+		productId: entityPro.id,
+	});
+
+	// Advance to next invoice
+	const advancedTo = await advanceToNextInvoice({
+		stripeCli: ctx.stripeCli,
+		testClockId: testClockId!,
+	});
+
+	// Verify final state - both products should be removed
+	const customerFinal = await autumnV1.customers.get<ApiCustomerV3>(customerId);
+	await expectProductNotPresent({
+		customer: customerFinal,
+		productId: customerPro.id,
+	});
+
+	const entityFinal = await autumnV1.entities.get(customerId, entityId);
+	await expectProductNotPresent({
+		customer: entityFinal,
+		productId: entityPro.id,
+	});
+
+	expectCustomerInvoiceCorrect({
+		customer: customerFinal,
+		count: 3, // 2 initial attaches + 1 overage invoice
+		latestTotal: 35,
+	});
+
+	// Verify line item billing periods are correct (now -> now + 1 month)
+	await expectStripeInvoiceLineItemPeriodCorrect({
+		customerId,
+		productId: entityPro.id,
+		periodStartMs: Date.now(),
+		periodEndMs: advancedTo,
+	});
 });
diff --git a/server/tests/integration/billing/update-subscription/cancel/end-of-cycle/cancel-end-of-cycle-trial-entities.test.ts b/server/tests/integration/billing/update-subscription/cancel/end-of-cycle/cancel-end-of-cycle-trial-entities.test.ts
new file mode 100644
index 000000000..a52b2f66d
--- /dev/null
+++ b/server/tests/integration/billing/update-subscription/cancel/end-of-cycle/cancel-end-of-cycle-trial-entities.test.ts
@@ -0,0 +1,518 @@
+/**
+ * Cancel End-of-Cycle Trial Entities Tests
+ *
+ * Tests for canceling products with free trials at end of billing cycle
+ * in multi-entity scenarios with merged subscriptions.
+ */
+
+import { expect, test } from "bun:test";
+import { type ApiCustomerV3, ms } from "@autumn/shared";
+import {
+	expectProductActive,
+	expectProductCanceling,
+	expectProductNotPresent,
+	expectProductScheduled,
+} from "@tests/integration/billing/utils/expectCustomerProductCorrect";
+import {
+	expectProductNotTrialing,
+	expectProductTrialing,
+} from "@tests/integration/billing/utils/expectCustomerProductTrialing";
+import { expectSubToBeCorrect } from "@tests/merged/mergeUtils/expectSubCorrect";
+import { TestFeature } from "@tests/setup/v2Features";
+import { items } from "@tests/utils/fixtures/items";
+import { products } from "@tests/utils/fixtures/products";
+import { advanceToNextInvoice } from "@tests/utils/testAttachUtils/testAttachUtils";
+import { initScenario, s } from "@tests/utils/testInitUtils/initScenario";
+import chalk from "chalk";
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// TEST 1: Cancel one entity EOC, other still trialing
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Scenario:
+ * - Attach proTrial to entity 1 and entity 2 (merged subscription)
+ * - Cancel entity 1 at end of cycle
+ *
+ * Expected Result:
+ * - Entity 1's product should be canceling
+ * - Entity 2's product should still be trialing
+ * - Subscription should still be trialing (not canceled yet)
+ */
+test(`${chalk.yellowBright("cancel trial EOC entities: cancel one entity, other still trialing")}`, async () => {
+	const customerId = "cancel-trial-eoc-ent-one";
+
+	const messagesItem = items.monthlyMessages({ includedUsage: 100 });
+
+	const proTrial = products.proWithTrial({
+		id: "pro-trial",
+		items: [messagesItem],
+		trialDays: 7,
+	});
+
+	const { autumnV1, ctx, entities, advancedTo } = await initScenario({
+		customerId,
+		setup: [
+			s.customer({ paymentMethod: "success" }),
+			s.products({ list: [proTrial] }),
+			s.entities({ count: 2, featureId: TestFeature.Users }),
+		],
+		actions: [
+			s.attach({ productId: proTrial.id, entityIndex: 0 }),
+			s.attach({ productId: proTrial.id, entityIndex: 1 }),
+		],
+	});
+
+	const entity1Id = entities[0].id;
+	const entity2Id = entities[1].id;
+
+	// Verify both entities are trialing
+	const entity1AfterAttach = await autumnV1.entities.get(customerId, entity1Id);
+	const entity2AfterAttach = await autumnV1.entities.get(customerId, entity2Id);
+
+	await expectProductTrialing({
+		customer: entity1AfterAttach,
+		productId: proTrial.id,
+		trialEndsAt: advancedTo + ms.days(7),
+	});
+
+	await expectProductTrialing({
+		customer: entity2AfterAttach,
+		productId: proTrial.id,
+		trialEndsAt: advancedTo + ms.days(7),
+	});
+
+	// Cancel entity 1 at end of cycle
+	await autumnV1.subscriptions.update({
+		customer_id: customerId,
+		entity_id: entity1Id,
+		product_id: proTrial.id,
+		cancel: "end_of_cycle",
+	});
+
+	// Verify entity 1 is canceling
+	const entity1AfterCancel = await autumnV1.entities.get(customerId, entity1Id);
+	await expectProductCanceling({
+		customer: entity1AfterCancel,
+		productId: proTrial.id,
+	});
+
+	// Verify entity 2 is still trialing (not affected)
+	const entity2AfterCancel = await autumnV1.entities.get(customerId, entity2Id);
+	await expectProductTrialing({
+		customer: entity2AfterCancel,
+		productId: proTrial.id,
+	});
+
+	// Subscription should still be trialing (not fully canceled)
+	await expectSubToBeCorrect({
+		db: ctx.db,
+		customerId,
+		org: ctx.org,
+		env: ctx.env,
+		shouldBeTrialing: true,
+	});
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// TEST 2: Cancel both entities EOC
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Scenario:
+ * - Attach proTrial to entity 1 and entity 2 (merged subscription)
+ * - Cancel entity 1 at end of cycle
+ * - Cancel entity 2 at end of cycle
+ *
+ * Expected Result:
+ * - Both entities' products should be canceling
+ * - Subscription should be canceling
+ * - After advancing past trial end:
+ *   - Both products removed
+ *   - No subscription
+ */
+test(`${chalk.yellowBright("cancel trial EOC entities: cancel both entities EOC")}`, async () => {
+	const customerId = "cancel-trial-eoc-ent-both";
+
+	const messagesItem = items.monthlyMessages({ includedUsage: 100 });
+
+	const proTrial = products.proWithTrial({
+		id: "pro-trial",
+		items: [messagesItem],
+		trialDays: 7,
+	});
+
+	const { autumnV1, ctx, testClockId, entities } = await initScenario({
+		customerId,
+		setup: [
+			s.customer({ paymentMethod: "success" }),
+			s.products({ list: [proTrial] }),
+			s.entities({ count: 2, featureId: TestFeature.Users }),
+		],
+		actions: [
+			s.attach({ productId: proTrial.id, entityIndex: 0 }),
+			s.attach({ productId: proTrial.id, entityIndex: 1 }),
+		],
+	});
+
+	const entity1Id = entities[0].id;
+	const entity2Id = entities[1].id;
+
+	// Verify both entities are trialing
+	const entity1AfterAttach = await autumnV1.entities.get(customerId, entity1Id);
+	const entity2AfterAttach = await autumnV1.entities.get(customerId, entity2Id);
+
+	await expectProductTrialing({
+		customer: entity1AfterAttach,
+		productId: proTrial.id,
+	});
+
+	await expectProductTrialing({
+		customer: entity2AfterAttach,
+		productId: proTrial.id,
+	});
+
+	// Cancel entity 1 at end of cycle
+	await autumnV1.subscriptions.update({
+		customer_id: customerId,
+		entity_id: entity1Id,
+		product_id: proTrial.id,
+		cancel: "end_of_cycle",
+	});
+
+	// Cancel entity 2 at end of cycle
+	await autumnV1.subscriptions.update({
+		customer_id: customerId,
+		entity_id: entity2Id,
+		product_id: proTrial.id,
+		cancel: "end_of_cycle",
+	});
+
+	// Verify both entities are canceling
+	const entity1AfterCancel = await autumnV1.entities.get(customerId, entity1Id);
+	const entity2AfterCancel = await autumnV1.entities.get(customerId, entity2Id);
+
+	await expectProductCanceling({
+		customer: entity1AfterCancel,
+		productId: proTrial.id,
+	});
+
+	await expectProductCanceling({
+		customer: entity2AfterCancel,
+		productId: proTrial.id,
+	});
+
+	// Subscription should be canceling and trialing
+	await expectSubToBeCorrect({
+		db: ctx.db,
+		customerId,
+		org: ctx.org,
+		env: ctx.env,
+		shouldBeTrialing: true,
+		shouldBeCanceled: true,
+	});
+
+	// Advance past trial end
+	await advanceToNextInvoice({
+		stripeCli: ctx.stripeCli,
+		testClockId: testClockId!,
+	});
+
+	// Verify both entities' products are removed
+	const entity1AfterAdvance = await autumnV1.entities.get(
+		customerId,
+		entity1Id,
+	);
+	const entity2AfterAdvance = await autumnV1.entities.get(
+		customerId,
+		entity2Id,
+	);
+
+	await expectProductNotPresent({
+		customer: entity1AfterAdvance,
+		productId: proTrial.id,
+	});
+
+	await expectProductNotPresent({
+		customer: entity2AfterAdvance,
+		productId: proTrial.id,
+	});
+
+	// No subscription should exist
+	await expectSubToBeCorrect({
+		db: ctx.db,
+		customerId,
+		org: ctx.org,
+		env: ctx.env,
+		subCount: 0,
+	});
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// TEST 3: Cancel one entity, attach pro to other (next cycle)
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Scenario:
+ * - Attach premiumTrial to entity 1 and entity 2
+ * - Cancel entity 1 at end of cycle
+ * - Attach pro to entity 2 (downgrade - scheduled for next cycle)
+ *
+ * Expected Result:
+ * - Entity 1's premium should be canceling
+ * - Entity 2's premium should be canceling with pro scheduled
+ * - After advancing past trial end:
+ *   - Entity 1's product is removed
+ *   - Entity 2 is on pro (active)
+ */
+test(`${chalk.yellowBright("cancel trial EOC entities: cancel one, attach pro to other (next cycle)")}`, async () => {
+	const customerId = "cancel-trial-eoc-ent-downgrade";
+
+	const messagesItem = items.monthlyMessages({ includedUsage: 100 });
+
+	const premiumTrial = products.premiumWithTrial({
+		id: "premium-trial",
+		items: [messagesItem],
+		trialDays: 7,
+	});
+
+	const pro = products.pro({
+		id: "pro",
+		items: [messagesItem],
+	});
+
+	const { autumnV1, ctx, testClockId, entities } = await initScenario({
+		customerId,
+		setup: [
+			s.customer({ paymentMethod: "success" }),
+			s.products({ list: [premiumTrial, pro] }),
+			s.entities({ count: 2, featureId: TestFeature.Users }),
+		],
+		actions: [
+			s.attach({ productId: premiumTrial.id, entityIndex: 0 }),
+			s.attach({ productId: premiumTrial.id, entityIndex: 1 }),
+		],
+	});
+
+	const entity1Id = entities[0].id;
+	const entity2Id = entities[1].id;
+
+	// Verify both entities are trialing on premium
+	const entity1AfterAttach = await autumnV1.entities.get(customerId, entity1Id);
+	const entity2AfterAttach = await autumnV1.entities.get(customerId, entity2Id);
+
+	await expectProductTrialing({
+		customer: entity1AfterAttach,
+		productId: premiumTrial.id,
+	});
+
+	await expectProductTrialing({
+		customer: entity2AfterAttach,
+		productId: premiumTrial.id,
+	});
+
+	// Cancel entity 1 at end of cycle
+	await autumnV1.subscriptions.update({
+		customer_id: customerId,
+		entity_id: entity1Id,
+		product_id: premiumTrial.id,
+		cancel: "end_of_cycle",
+	});
+
+	// Attach pro to entity 2 (downgrade - scheduled)
+	await autumnV1.attach({
+		customer_id: customerId,
+		entity_id: entity2Id,
+		product_id: pro.id,
+	});
+
+	// Verify entity 1's premium is canceling
+	const entity1AfterCancel = await autumnV1.entities.get(customerId, entity1Id);
+	await expectProductCanceling({
+		customer: entity1AfterCancel,
+		productId: premiumTrial.id,
+	});
+
+	// Verify entity 2's premium is canceling and pro is scheduled
+	const entity2AfterDowngrade = await autumnV1.entities.get(
+		customerId,
+		entity2Id,
+	);
+	await expectProductCanceling({
+		customer: entity2AfterDowngrade,
+		productId: premiumTrial.id,
+	});
+	await expectProductScheduled({
+		customer: entity2AfterDowngrade,
+		productId: pro.id,
+	});
+
+	// Advance past trial end
+	await advanceToNextInvoice({
+		stripeCli: ctx.stripeCli,
+		testClockId: testClockId!,
+	});
+
+	// Verify entity 1's product is removed
+	const entity1AfterAdvance = await autumnV1.entities.get(
+		customerId,
+		entity1Id,
+	);
+	await expectProductNotPresent({
+		customer: entity1AfterAdvance,
+		productId: premiumTrial.id,
+	});
+
+	// Verify entity 2 is now on pro (active)
+	const entity2AfterAdvance = await autumnV1.entities.get(
+		customerId,
+		entity2Id,
+	);
+	await expectProductNotPresent({
+		customer: entity2AfterAdvance,
+		productId: premiumTrial.id,
+	});
+	await expectProductActive({
+		customer: entity2AfterAdvance,
+		productId: pro.id,
+	});
+
+	// Subscription should exist for entity 2's pro
+	await expectSubToBeCorrect({
+		db: ctx.db,
+		customerId,
+		org: ctx.org,
+		env: ctx.env,
+		subCount: 1,
+	});
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// TEST 4: Cancel entity 1, attach proTrial to entity 2 creates schedule
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Scenario:
+ * - Attach proTrial to entity 1
+ * - Cancel entity 1 at end of cycle
+ * - Attach proTrial to entity 2
+ *
+ * Expected Result:
+ * - Entity 1's product should be canceling
+ * - Entity 2's product should be trialing (merges with existing trialing sub)
+ * - After advancing past trial end:
+ *   - Entity 1's product is removed
+ *   - Entity 2 is on proTrial (active, no longer trialing - trial ended)
+ */
+test(`${chalk.yellowBright("cancel trial EOC entities: cancel entity 1, attach proTrial to entity 2")}`, async () => {
+	const customerId = "cancel-trial-eoc-ent-attach";
+
+	const messagesItem = items.monthlyMessages({ includedUsage: 100 });
+
+	const proTrial = products.proWithTrial({
+		id: "pro-trial",
+		items: [messagesItem],
+		trialDays: 7,
+	});
+
+	const { autumnV1, ctx, testClockId, entities, advancedTo } =
+		await initScenario({
+			customerId,
+			setup: [
+				s.customer({ paymentMethod: "success" }),
+				s.products({ list: [proTrial] }),
+				s.entities({ count: 2, featureId: TestFeature.Users }),
+			],
+			actions: [s.attach({ productId: proTrial.id, entityIndex: 0 })],
+		});
+
+	const entity1Id = entities[0].id;
+	const entity2Id = entities[1].id;
+
+	// Verify entity 1 is trialing
+	const entity1AfterAttach = await autumnV1.entities.get(customerId, entity1Id);
+	await expectProductTrialing({
+		customer: entity1AfterAttach,
+		productId: proTrial.id,
+		trialEndsAt: advancedTo + ms.days(7),
+	});
+
+	// Cancel entity 1 at end of cycle
+	await autumnV1.subscriptions.update({
+		customer_id: customerId,
+		entity_id: entity1Id,
+		product_id: proTrial.id,
+		cancel: "end_of_cycle",
+	});
+
+	// Verify entity 1 is canceling
+	const entity1AfterCancel = await autumnV1.entities.get(customerId, entity1Id);
+	await expectProductCanceling({
+		customer: entity1AfterCancel,
+		productId: proTrial.id,
+	});
+
+	// Attach proTrial to entity 2
+	await autumnV1.attach({
+		customer_id: customerId,
+		entity_id: entity2Id,
+		product_id: proTrial.id,
+	});
+
+	// Verify entity 2 is trialing (merged with existing subscription)
+	const entity2AfterAttach = await autumnV1.entities.get(customerId, entity2Id);
+	await expectProductTrialing({
+		customer: entity2AfterAttach,
+		productId: proTrial.id,
+		trialEndsAt: advancedTo + ms.days(7),
+	});
+
+	// Advance past trial end
+	await advanceToNextInvoice({
+		stripeCli: ctx.stripeCli,
+		testClockId: testClockId!,
+	});
+
+	// Verify entity 1's product is removed
+	const entity1AfterAdvance = await autumnV1.entities.get(
+		customerId,
+		entity1Id,
+	);
+	await expectProductNotPresent({
+		customer: entity1AfterAdvance,
+		productId: proTrial.id,
+	});
+
+	// Verify entity 2 is active (trial ended, now paying)
+	const entity2AfterAdvance = await autumnV1.entities.get(
+		customerId,
+		entity2Id,
+	);
+	await expectProductActive({
+		customer: entity2AfterAdvance,
+		productId: proTrial.id,
+	});
+
+	// Not trialing anymore (trial ended)
+	await expectProductNotTrialing({
+		customer: entity2AfterAdvance,
+		productId: proTrial.id,
+	});
+
+	// Subscription should exist for entity 2
+	await expectSubToBeCorrect({
+		db: ctx.db,
+		customerId,
+		org: ctx.org,
+		env: ctx.env,
+		subCount: 1,
+	});
+
+	// Should have invoice for entity 2's subscription after trial
+	const customerAfterAdvance =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+	const invoices = customerAfterAdvance.invoices ?? [];
+	const paidInvoice = invoices.find((inv) => inv.total > 0);
+	expect(paidInvoice).toBeDefined();
+	expect(paidInvoice?.total).toBe(20); // Pro price
+});
diff --git a/server/tests/integration/billing/update-subscription/cancel/end-of-cycle/cancel-end-of-cycle-trial.test.ts b/server/tests/integration/billing/update-subscription/cancel/end-of-cycle/cancel-end-of-cycle-trial.test.ts
new file mode 100644
index 000000000..6ea2c3719
--- /dev/null
+++ b/server/tests/integration/billing/update-subscription/cancel/end-of-cycle/cancel-end-of-cycle-trial.test.ts
@@ -0,0 +1,455 @@
+/**
+ * Cancel End-of-Cycle Trial Tests
+ *
+ * Tests for canceling products with free trials at end of billing cycle.
+ * Verifies trial cancellation behavior, preview responses, and invoice handling.
+ */
+
+import { expect, test } from "bun:test";
+import { type ApiCustomerV3, ms } from "@autumn/shared";
+import { expectCustomerInvoiceCorrect } from "@tests/integration/billing/utils/expectCustomerInvoiceCorrect";
+import {
+	expectCustomerProducts,
+	expectProductCanceling,
+	expectProductNotPresent,
+	expectProductScheduled,
+} from "@tests/integration/billing/utils/expectCustomerProductCorrect";
+import { expectProductTrialing } from "@tests/integration/billing/utils/expectCustomerProductTrialing";
+import { expectPreviewNextCycleCorrect } from "@tests/integration/billing/utils/expectPreviewNextCycleCorrect";
+import { TestFeature } from "@tests/setup/v2Features";
+import { items } from "@tests/utils/fixtures/items";
+import { products } from "@tests/utils/fixtures/products";
+import { advanceTestClock } from "@tests/utils/stripeUtils";
+import { advanceToNextInvoice } from "@tests/utils/testAttachUtils/testAttachUtils";
+import { initScenario, s } from "@tests/utils/testInitUtils/initScenario";
+import chalk from "chalk";
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// TEST 1: Basic cancel trial EOC - preview.next_cycle null, no invoice after advance
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Scenario:
+ * - User attaches proWithTrial (7-day trial)
+ * - User cancels at end of cycle
+ *
+ * Expected Result:
+ * - Preview should have next_cycle as null/undefined (canceling, no next cycle)
+ * - Product should be canceling but still trialing
+ * - After advancing past trial end:
+ *   - Product is not present
+ *   - No invoice created (was free during trial)
+ */
+test(`${chalk.yellowBright("cancel trial EOC: basic cancel, preview.next_cycle null, no invoice after advance")}`, async () => {
+	const customerId = "cancel-trial-eoc-basic";
+
+	const messagesItem = items.monthlyMessages({ includedUsage: 100 });
+
+	const proTrial = products.proWithTrial({
+		id: "pro-trial",
+		items: [messagesItem],
+		trialDays: 7,
+	});
+
+	const { autumnV1, ctx, testClockId, advancedTo } = await initScenario({
+		customerId,
+		setup: [
+			s.customer({ paymentMethod: "success" }),
+			s.products({ list: [proTrial] }),
+		],
+		actions: [s.attach({ productId: proTrial.id })],
+	});
+
+	// Verify product is trialing
+	const customerAfterAttach =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+
+	await expectProductTrialing({
+		customer: customerAfterAttach,
+		productId: proTrial.id,
+		trialEndsAt: advancedTo + ms.days(7),
+	});
+
+	// Initial invoice should be $0 (trial)
+	expectCustomerInvoiceCorrect({
+		customer: customerAfterAttach,
+		count: 1,
+		latestTotal: 0,
+	});
+
+	// Preview the cancel
+	const cancelParams = {
+		customer_id: customerId,
+		product_id: proTrial.id,
+		cancel: "end_of_cycle" as const,
+	};
+
+	const preview = await autumnV1.subscriptions.previewUpdate(cancelParams);
+
+	// Preview total should be $0 (no charge for canceling during trial)
+	expect(preview.total).toBe(0);
+
+	// next_cycle should be null/undefined since we're canceling
+	expectPreviewNextCycleCorrect({
+		preview,
+		expectDefined: false,
+	});
+
+	// Execute the cancel
+	await autumnV1.subscriptions.update(cancelParams);
+
+	// Verify product is canceling but still trialing
+	const customerAfterCancel =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+
+	await expectProductCanceling({
+		customer: customerAfterCancel,
+		productId: proTrial.id,
+	});
+
+	// Should still be trialing (status can be both canceling and trialing)
+	await expectProductTrialing({
+		customer: customerAfterCancel,
+		productId: proTrial.id,
+	});
+
+	// Advance past trial end
+	await advanceTestClock({
+		stripeCli: ctx.stripeCli,
+		testClockId: testClockId!,
+		advanceTo: advancedTo + ms.days(10),
+	});
+
+	// Verify product is removed
+	const customerAfterAdvance =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+
+	await expectProductNotPresent({
+		customer: customerAfterAdvance,
+		productId: proTrial.id,
+	});
+
+	// Should still only have 1 invoice (the initial $0 trial invoice)
+	// No new invoice created because product was canceled during trial
+	expectCustomerInvoiceCorrect({
+		customer: customerAfterAdvance,
+		count: 1,
+		latestTotal: 0,
+	});
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// TEST 2: Cancel trial EOC with consumable messages - no overage invoice
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Scenario:
+ * - User attaches proWithTrial with consumable messages (100 included)
+ * - User tracks 500 messages (400 overage)
+ * - User cancels at end of cycle
+ *
+ * Expected Result:
+ * - After advancing past trial end:
+ *   - Product is removed
+ *   - No overage invoice (usage was free during trial)
+ *   - Stripe doesn't create an extra invoice when trial ends
+ */
+
+test(`${chalk.yellowBright("cancel trial EOC: with consumable messages, no overage invoice")}`, async () => {
+	const customerId = "cancel-trial-eoc-consumable";
+
+	const consumableItem = items.consumableMessages({ includedUsage: 100 });
+
+	const proTrial = products.proWithTrial({
+		id: "pro-trial",
+		items: [consumableItem],
+		trialDays: 7,
+	});
+
+	const { autumnV1, ctx, testClockId } = await initScenario({
+		customerId,
+		setup: [
+			s.customer({ paymentMethod: "success" }),
+			s.products({ list: [proTrial] }),
+		],
+		actions: [s.attach({ productId: proTrial.id })],
+	});
+
+	// Verify product is trialing
+	const customerAfterAttach =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+
+	await expectProductTrialing({
+		customer: customerAfterAttach,
+		productId: proTrial.id,
+	});
+
+	// Track 500 messages (100 included, 400 overage = $40 if billed)
+	await autumnV1.track({
+		customer_id: customerId,
+		feature_id: TestFeature.Messages,
+		value: 500,
+	});
+
+	// Verify usage was tracked
+	const customerAfterTrack =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+	expect(customerAfterTrack.features[TestFeature.Messages].balance).toBe(-400);
+
+	// Cancel at end of cycle
+	await autumnV1.subscriptions.update({
+		customer_id: customerId,
+		product_id: proTrial.id,
+		cancel: "end_of_cycle",
+	});
+
+	// Verify product is canceling
+	const customerAfterCancel =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+
+	await expectProductCanceling({
+		customer: customerAfterCancel,
+		productId: proTrial.id,
+	});
+
+	// Initial invoice count
+	const initialInvoiceCount = customerAfterCancel.invoices?.length ?? 0;
+
+	// Advance past trial end
+	await advanceToNextInvoice({
+		stripeCli: ctx.stripeCli,
+		testClockId: testClockId!,
+	});
+
+	// Verify product is removed
+	const customerAfterAdvance =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+
+	await expectProductNotPresent({
+		customer: customerAfterAdvance,
+		productId: proTrial.id,
+	});
+
+	// No new invoice should be created - usage was free during trial
+	// Invoice count should be same or only have $0 invoices
+	const finalInvoiceCount = customerAfterAdvance.invoices?.length ?? 0;
+	const latestInvoice = customerAfterAdvance.invoices?.[0];
+
+	// Either no new invoice, or if there is one, it should be $0
+	if (finalInvoiceCount > initialInvoiceCount) {
+		expect(latestInvoice?.total).toBe(0);
+	}
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// TEST 3: Cancel premium trial with pro scheduled - scheduled is removed
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Scenario:
+ * - User attaches premiumTrial ($50/mo, 7-day trial)
+ * - User attaches pro ($20/mo) - scheduled to start at trial end (downgrade)
+ * - User cancels premium at end of cycle
+ *
+ * Expected Result:
+ * - Pro scheduled should be automatically removed
+ * - After advancing past trial end:
+ *   - Neither premium nor pro is present
+ *   - No invoice created
+ */
+test(`${chalk.yellowBright("cancel trial EOC: premium trial with pro scheduled, cancel removes scheduled")}`, async () => {
+	const customerId = "cancel-trial-eoc-scheduled";
+
+	const messagesItem = items.monthlyMessages({ includedUsage: 100 });
+
+	const premiumTrial = products.premiumWithTrial({
+		id: "premium-trial",
+		items: [messagesItem],
+		trialDays: 7,
+	});
+
+	const pro = products.pro({
+		id: "pro",
+		items: [messagesItem],
+	});
+
+	const { autumnV1, ctx, testClockId } = await initScenario({
+		customerId,
+		setup: [
+			s.customer({ paymentMethod: "success" }),
+			s.products({ list: [premiumTrial, pro] }),
+		],
+		actions: [s.attach({ productId: premiumTrial.id })],
+	});
+
+	// Verify premium is trialing
+	const customerAfterAttach =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+
+	await expectProductTrialing({
+		customer: customerAfterAttach,
+		productId: premiumTrial.id,
+	});
+
+	// Attach pro (downgrade - should be scheduled at trial end)
+	await autumnV1.attach({
+		customer_id: customerId,
+		product_id: pro.id,
+	});
+
+	// Verify premium is canceling and pro is scheduled
+	const customerAfterDowngrade =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+
+	await expectProductCanceling({
+		customer: customerAfterDowngrade,
+		productId: premiumTrial.id,
+	});
+
+	await expectProductScheduled({
+		customer: customerAfterDowngrade,
+		productId: pro.id,
+	});
+
+	// Cancel premium at end of cycle
+	await autumnV1.subscriptions.update({
+		customer_id: customerId,
+		product_id: premiumTrial.id,
+		cancel: "end_of_cycle",
+	});
+
+	// Verify pro scheduled is removed
+	const customerAfterCancel =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+
+	// Premium should still be canceling
+	await expectProductCanceling({
+		customer: customerAfterCancel,
+		productId: premiumTrial.id,
+	});
+
+	// Pro should no longer be scheduled (removed)
+	await expectProductNotPresent({
+		customer: customerAfterCancel,
+		productId: pro.id,
+	});
+
+	// Advance past trial end
+	await advanceToNextInvoice({
+		stripeCli: ctx.stripeCli,
+		testClockId: testClockId!,
+	});
+
+	// Verify both products are removed
+	const customerAfterAdvance =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+
+	await expectProductNotPresent({
+		customer: customerAfterAdvance,
+		productId: premiumTrial.id,
+	});
+
+	await expectProductNotPresent({
+		customer: customerAfterAdvance,
+		productId: pro.id,
+	});
+
+	// No paid invoice should be created (only $0 trial invoices)
+	const invoices = customerAfterAdvance.invoices ?? [];
+	for (const invoice of invoices) {
+		expect(invoice.total).toBe(0);
+	}
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// TEST 4: Cancel trial EOC with free default - free scheduled
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Scenario:
+ * - Free default product exists
+ * - User attaches proWithTrial (7-day trial)
+ * - User cancels at end of cycle
+ *
+ * Expected Result:
+ * - Pro should be canceling
+ * - Free default should be scheduled
+ * - After advancing past trial end:
+ *   - Free is active
+ *   - Pro is not present
+ *   - No paid invoice created
+ */
+test(`${chalk.yellowBright("cancel trial EOC: with free default, free scheduled")}`, async () => {
+	const customerId = "cancel-trial-eoc-free-default";
+
+	const messagesItem = items.monthlyMessages({ includedUsage: 100 });
+
+	const free = products.base({
+		id: "free",
+		items: [messagesItem],
+		isDefault: true,
+	});
+
+	const proTrial = products.proWithTrial({
+		id: "pro-trial",
+		items: [messagesItem],
+		trialDays: 7,
+	});
+
+	const { autumnV1, ctx, testClockId } = await initScenario({
+		customerId,
+		setup: [
+			s.customer({ paymentMethod: "success" }),
+			s.products({ list: [free, proTrial] }),
+		],
+		actions: [s.attach({ productId: proTrial.id })],
+	});
+
+	// Verify pro is trialing
+	const customerAfterAttach =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+
+	await expectProductTrialing({
+		customer: customerAfterAttach,
+		productId: proTrial.id,
+	});
+
+	// Cancel at end of cycle
+	await autumnV1.subscriptions.update({
+		customer_id: customerId,
+		product_id: proTrial.id,
+		cancel: "end_of_cycle",
+	});
+
+	// Verify pro is canceling and free is scheduled
+	const customerAfterCancel =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+
+	await expectCustomerProducts({
+		customer: customerAfterCancel,
+		canceling: [proTrial.id],
+		scheduled: [free.id],
+	});
+
+	// Advance past trial end
+	await advanceToNextInvoice({
+		stripeCli: ctx.stripeCli,
+		testClockId: testClockId!,
+	});
+
+	// Verify free is active and pro is removed
+	const customerAfterAdvance =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+
+	await expectCustomerProducts({
+		customer: customerAfterAdvance,
+		active: [free.id],
+		notPresent: [proTrial.id],
+	});
+
+	// No paid invoice should be created
+	const invoices = customerAfterAdvance.invoices ?? [];
+	for (const invoice of invoices) {
+		expect(invoice.total).toBe(0);
+	}
+});
diff --git a/server/tests/integration/billing/update-subscription/cancel/cancel-end-of-cycle.test.ts b/server/tests/integration/billing/update-subscription/cancel/end-of-cycle/cancel-end-of-cycle.test.ts
similarity index 100%
rename from server/tests/integration/billing/update-subscription/cancel/cancel-end-of-cycle.test.ts
rename to server/tests/integration/billing/update-subscription/cancel/end-of-cycle/cancel-end-of-cycle.test.ts
diff --git a/server/tests/integration/billing/update-subscription/cancel/immediately/cancel-immediately-addon.test.ts b/server/tests/integration/billing/update-subscription/cancel/immediately/cancel-immediately-addon.test.ts
new file mode 100644
index 000000000..00d6b1d79
--- /dev/null
+++ b/server/tests/integration/billing/update-subscription/cancel/immediately/cancel-immediately-addon.test.ts
@@ -0,0 +1,675 @@
+/**
+ * Cancel Add-On Immediately Tests
+ *
+ * Tests for canceling add-on products immediately using `cancel: 'immediately'`.
+ * Add-ons are products with `isAddOn: true` that attach alongside base products.
+ *
+ * Key behaviors:
+ * - Add-on is removed immediately
+ * - Base product (pro/premium) remains active
+ * - Refund invoice created for unused time on paid add-ons
+ * - Usage overage is NOT charged when canceling immediately
+ */
+
+import { test } from "bun:test";
+import type { ApiCustomerV3 } from "@autumn/shared";
+import { expectCustomerInvoiceCorrect } from "@tests/integration/billing/utils/expectCustomerInvoiceCorrect";
+import {
+	expectCustomerProducts,
+	expectProductCanceling,
+} from "@tests/integration/billing/utils/expectCustomerProductCorrect";
+import { TestFeature } from "@tests/setup/v2Features";
+import { items } from "@tests/utils/fixtures/items";
+import { products } from "@tests/utils/fixtures/products";
+import { initScenario, s } from "@tests/utils/testInitUtils/initScenario";
+import chalk from "chalk";
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// TEST 1: Basic immediate cancel - refund issued
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Scenario:
+ * - Attach pro ($20/mo) + recurring add-on ($20/mo)
+ * - Cancel add-on immediately
+ *
+ * Expected Result:
+ * - Add-on is removed
+ * - Pro remains active
+ * - Refund invoice (-$20) created for add-on
+ * - No additional invoices after timeout
+ */
+test.concurrent(`${chalk.yellowBright("cancel addon immediately: basic refund")}`, async () => {
+	const customerId = "cancel-addon-imm-1";
+
+	const messagesItem = items.monthlyMessages({ includedUsage: 100 });
+
+	const pro = products.pro({ items: [messagesItem] });
+	const recurringAddon = products.recurringAddOn({
+		id: "recurring-addon",
+		items: [messagesItem],
+	});
+
+	const { autumnV1 } = await initScenario({
+		customerId,
+		setup: [
+			s.customer({ paymentMethod: "success" }),
+			s.products({ list: [pro, recurringAddon] }),
+		],
+		actions: [
+			s.attach({ productId: pro.id }),
+			s.attach({ productId: recurringAddon.id }),
+		],
+	});
+
+	// Verify both products are active
+	const customerBefore =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+	await expectCustomerProducts({
+		customer: customerBefore,
+		active: [pro.id, recurringAddon.id],
+	});
+
+	// Should have 2 invoices (pro attach + addon attach)
+	expectCustomerInvoiceCorrect({
+		customer: customerBefore,
+		count: 2,
+	});
+
+	// Cancel add-on immediately
+	await autumnV1.subscriptions.update({
+		customer_id: customerId,
+		product_id: recurringAddon.id,
+		cancel: "immediately",
+	});
+
+	// Wait for async invoice processing
+	await new Promise((resolve) => setTimeout(resolve, 3000));
+
+	// Verify add-on removed, pro still active
+	const customerAfter = await autumnV1.customers.get<ApiCustomerV3>(customerId);
+	await expectCustomerProducts({
+		customer: customerAfter,
+		active: [pro.id],
+		notPresent: [recurringAddon.id],
+	});
+
+	// Verify refund invoice (-$20) and no extra invoices
+	expectCustomerInvoiceCorrect({
+		customer: customerAfter,
+		count: 3, // pro attach + addon attach + addon refund
+		latestTotal: -20,
+	});
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// TEST 2: Cancel with usage overage - usage NOT charged
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Scenario:
+ * - Attach pro (free base) + usage add-on ($20/mo base + $0.10/msg overage)
+ * - Track 1000 messages (all overage since includedUsage: 0)
+ * - Cancel usage add-on immediately
+ *
+ * Expected Result:
+ * - Add-on is removed
+ * - Pro remains active
+ * - Only refund invoice (-$20), usage is NOT charged
+ */
+test.concurrent(`${chalk.yellowBright("cancel addon immediately: usage overage not charged")}`, async () => {
+	const customerId = "cancel-addon-imm-2";
+
+	const messagesItem = items.monthlyMessages({ includedUsage: 100 });
+
+	const pro = products.base({
+		id: "pro",
+		items: [messagesItem],
+	});
+
+	// Usage add-on: $20 base + consumable messages
+	const usageAddon = products.base({
+		id: "usage-addon",
+		isAddOn: true,
+		items: [
+			items.monthlyPrice({ price: 20 }),
+			items.consumableMessages({ includedUsage: 0 }),
+		],
+	});
+
+	const { autumnV1 } = await initScenario({
+		customerId,
+		setup: [
+			s.customer({ paymentMethod: "success" }),
+			s.products({ list: [pro, usageAddon] }),
+		],
+		actions: [
+			s.attach({ productId: pro.id }),
+			s.attach({ productId: usageAddon.id }),
+		],
+	});
+
+	// Track 1000 messages (all overage)
+	await autumnV1.track({
+		customer_id: customerId,
+		feature_id: TestFeature.Messages,
+		value: 1000,
+	});
+
+	// Wait for track to process
+	await new Promise((resolve) => setTimeout(resolve, 2000));
+
+	// Cancel usage add-on immediately
+	await autumnV1.subscriptions.update({
+		customer_id: customerId,
+		product_id: usageAddon.id,
+		cancel: "immediately",
+	});
+
+	// Wait for async invoice processing
+	await new Promise((resolve) => setTimeout(resolve, 3000));
+
+	// Verify add-on removed, pro still active
+	const customerAfter = await autumnV1.customers.get<ApiCustomerV3>(customerId);
+	await expectCustomerProducts({
+		customer: customerAfter,
+		active: [pro.id],
+		notPresent: [usageAddon.id],
+	});
+
+	// Verify only refund invoice (-$20), NO usage charge
+	// Invoices: addon attach ($20) + addon refund (-$20)
+	expectCustomerInvoiceCorrect({
+		customer: customerAfter,
+		count: 2,
+		latestTotal: -20,
+	});
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// TEST 3: Cancel free add-on - premium unaffected
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Scenario:
+ * - Attach premium ($30/mo) + free add-on (no base price)
+ * - Cancel free add-on immediately
+ *
+ * Expected Result:
+ * - Free add-on is removed
+ * - Premium remains active
+ * - No new invoices (add-on was free)
+ */
+test.concurrent(`${chalk.yellowBright("cancel addon immediately: free addon cancel")}`, async () => {
+	const customerId = "cancel-addon-imm-3";
+
+	const messagesItem = items.monthlyMessages({ includedUsage: 100 });
+
+	const premium = products.base({
+		id: "premium",
+		items: [messagesItem, items.monthlyPrice({ price: 30 })],
+	});
+
+	const freeAddon = products.base({
+		id: "free-addon",
+		isAddOn: true,
+		items: [messagesItem],
+	});
+
+	const { autumnV1 } = await initScenario({
+		customerId,
+		setup: [
+			s.customer({ paymentMethod: "success" }),
+			s.products({ list: [premium, freeAddon] }),
+		],
+		actions: [
+			s.attach({ productId: premium.id }),
+			s.attach({ productId: freeAddon.id }),
+		],
+	});
+
+	// Verify both products active, 1 invoice (premium only)
+	const customerBefore =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+	await expectCustomerProducts({
+		customer: customerBefore,
+		active: [premium.id, freeAddon.id],
+	});
+	expectCustomerInvoiceCorrect({
+		customer: customerBefore,
+		count: 1, // Only premium attach (free addon has no invoice)
+		latestTotal: 30,
+	});
+
+	// Cancel free add-on immediately
+	await autumnV1.subscriptions.update({
+		customer_id: customerId,
+		product_id: freeAddon.id,
+		cancel: "immediately",
+	});
+
+	// Wait for processing
+	await new Promise((resolve) => setTimeout(resolve, 3000));
+
+	// Verify free add-on removed, premium still active
+	const customerAfter = await autumnV1.customers.get<ApiCustomerV3>(customerId);
+	await expectCustomerProducts({
+		customer: customerAfter,
+		active: [premium.id],
+		notPresent: [freeAddon.id],
+	});
+
+	// No new invoices (free add-on has no refund)
+	expectCustomerInvoiceCorrect({
+		customer: customerAfter,
+		count: 1,
+		latestTotal: 30,
+	});
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// TEST 4: Cancel with scheduled downgrade - scheduled preserved then activates
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Scenario:
+ * - Attach premium ($30/mo) + recurring add-on ($20/mo)
+ * - Downgrade premium -> pro ($20/mo) (schedules pro for end of cycle)
+ * - Cancel add-on immediately
+ * - Advance test clock to next cycle
+ *
+ * Expected Result:
+ * - After cancel: premium active, pro scheduled, add-on gone
+ * - After advance: pro active, premium gone, add-on gone
+ */
+test.concurrent(`${chalk.yellowBright("cancel addon immediately: with scheduled downgrade")}`, async () => {
+	const customerId = "cancel-addon-imm-4";
+
+	const messagesItem = items.monthlyMessages({ includedUsage: 100 });
+
+	// Premium and pro in same group (default group)
+	const premium = products.base({
+		id: "premium",
+		items: [messagesItem, items.monthlyPrice({ price: 30 })],
+	});
+
+	const pro = products.pro({ items: [messagesItem] }); // $20/mo
+
+	const recurringAddon = products.recurringAddOn({
+		id: "recurring-addon",
+		items: [messagesItem],
+	});
+
+	const { autumnV1 } = await initScenario({
+		customerId,
+		setup: [
+			s.customer({ paymentMethod: "success" }),
+			s.products({ list: [premium, pro, recurringAddon] }),
+		],
+		actions: [
+			s.attach({ productId: premium.id }),
+			s.attach({ productId: recurringAddon.id }),
+			s.attach({ productId: pro.id }), // Schedules downgrade
+		],
+	});
+
+	// Verify: premium active, pro scheduled, addon active
+	const customerBefore =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+	await expectCustomerProducts({
+		customer: customerBefore,
+		active: [premium.id, recurringAddon.id],
+		scheduled: [pro.id],
+	});
+
+	// Cancel add-on immediately
+	await autumnV1.subscriptions.update({
+		customer_id: customerId,
+		product_id: recurringAddon.id,
+		cancel: "immediately",
+	});
+
+	// Verify: premium active, pro still scheduled, addon gone
+	const customerAfterCancel =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+	await expectCustomerProducts({
+		customer: customerAfterCancel,
+		active: [premium.id],
+		scheduled: [pro.id],
+		notPresent: [recurringAddon.id],
+	});
+
+	// Advance test clock to next cycle
+	await initScenario({
+		customerId,
+		setup: [],
+		actions: [s.advanceTestClock({ toNextInvoice: true })],
+	});
+
+	// Wait for webhooks
+	await new Promise((resolve) => setTimeout(resolve, 3000));
+
+	// Verify: pro active, premium gone, addon gone
+	const customerAfterAdvance =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+	await expectCustomerProducts({
+		customer: customerAfterAdvance,
+		active: [pro.id],
+		notPresent: [premium.id, recurringAddon.id],
+	});
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// TEST 5: Cancel entity product - entity's base product unaffected
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Scenario:
+ * - Create entity
+ * - Attach pro ($20/mo) to entity
+ * - Attach recurring add-on ($20/mo) to entity
+ * - Cancel add-on immediately (with entity_id)
+ *
+ * Expected Result:
+ * - Entity's pro still active
+ * - Add-on removed from entity
+ */
+test.concurrent(`${chalk.yellowBright("cancel addon immediately: entity product cancel")}`, async () => {
+	const customerId = "cancel-addon-imm-5";
+
+	const messagesItem = items.monthlyMessages({ includedUsage: 100 });
+
+	const pro = products.pro({ items: [messagesItem] });
+	const recurringAddon = products.recurringAddOn({
+		id: "recurring-addon",
+		items: [messagesItem],
+	});
+
+	const { autumnV1, entities } = await initScenario({
+		customerId,
+		setup: [
+			s.customer({ paymentMethod: "success" }),
+			s.products({ list: [pro, recurringAddon] }),
+			s.entities({ count: 1, featureId: TestFeature.Users }),
+		],
+		actions: [
+			s.attach({ productId: pro.id, entityIndex: 0 }),
+			s.attach({ productId: recurringAddon.id, entityIndex: 0 }),
+		],
+	});
+
+	// Verify both products attached to entity
+	const entityBefore = await autumnV1.entities.get(customerId, entities[0].id);
+	await expectCustomerProducts({
+		customer: entityBefore,
+		active: [pro.id, recurringAddon.id],
+	});
+
+	// Cancel add-on immediately for entity
+	await autumnV1.subscriptions.update({
+		customer_id: customerId,
+		entity_id: entities[0].id,
+		product_id: recurringAddon.id,
+		cancel: "immediately",
+	});
+
+	// Wait for processing
+	await new Promise((resolve) => setTimeout(resolve, 3000));
+
+	// Verify entity's pro still active, addon removed
+	const entityAfter = await autumnV1.entities.get(customerId, entities[0].id);
+	await expectCustomerProducts({
+		customer: entityAfter,
+		active: [pro.id],
+		notPresent: [recurringAddon.id],
+	});
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// TEST 6: Cancel both pro and add-on - only free default remains
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Scenario:
+ * - Attach pro ($20/mo) + recurring add-on ($20/mo)
+ * - Free default product exists
+ * - Cancel pro at end of cycle
+ * - Cancel add-on immediately
+ * - Advance test clock
+ *
+ * Expected Result:
+ * - After cancels: pro canceling, addon removed
+ * - After advance: only free default product remains
+ */
+test.concurrent(`${chalk.yellowBright("cancel addon immediately: cancel both pro and addon")}`, async () => {
+	const customerId = "cancel-addon-imm-6";
+
+	const messagesItem = items.monthlyMessages({ includedUsage: 100 });
+
+	const free = products.base({
+		id: "free",
+		items: [messagesItem],
+		isDefault: true,
+	});
+
+	const pro = products.pro({ items: [messagesItem] });
+	const recurringAddon = products.recurringAddOn({
+		id: "recurring-addon",
+		items: [messagesItem],
+	});
+
+	const { autumnV1 } = await initScenario({
+		customerId,
+		setup: [
+			s.customer({ paymentMethod: "success" }),
+			s.products({ list: [free, pro, recurringAddon] }),
+		],
+		actions: [
+			s.attach({ productId: pro.id }),
+			s.attach({ productId: recurringAddon.id }),
+		],
+	});
+
+	// Verify both products active
+	const customerBefore =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+	await expectCustomerProducts({
+		customer: customerBefore,
+		active: [pro.id, recurringAddon.id],
+	});
+
+	// Cancel pro at end of cycle
+	await autumnV1.subscriptions.update({
+		customer_id: customerId,
+		product_id: pro.id,
+		cancel: "end_of_cycle",
+	});
+
+	// Cancel add-on immediately
+	await autumnV1.subscriptions.update({
+		customer_id: customerId,
+		product_id: recurringAddon.id,
+		cancel: "immediately",
+	});
+
+	// Verify: pro canceling, addon removed
+	const customerAfterCancel =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+	await expectProductCanceling({
+		customer: customerAfterCancel,
+		productId: pro.id,
+	});
+	await expectCustomerProducts({
+		customer: customerAfterCancel,
+		notPresent: [recurringAddon.id],
+	});
+
+	// Advance test clock
+	await initScenario({
+		customerId,
+		setup: [],
+		actions: [s.advanceTestClock({ toNextInvoice: true })],
+	});
+
+	// Wait for webhooks
+	await new Promise((resolve) => setTimeout(resolve, 3000));
+
+	// Verify: only free default remains
+	const customerAfterAdvance =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+	await expectCustomerProducts({
+		customer: customerAfterAdvance,
+		active: [free.id],
+		notPresent: [pro.id, recurringAddon.id],
+	});
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// TEST 7: Multiple add-ons - cancel one, other remains
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Scenario:
+ * - Attach recurring add-on ($20/mo) + pro add-on ($20/mo)
+ * - Cancel pro add-on immediately
+ *
+ * Expected Result:
+ * - Recurring add-on still active
+ * - Pro add-on removed
+ * - Refund invoice (-$20) for pro add-on
+ */
+test.concurrent(`${chalk.yellowBright("cancel addon immediately: multiple addons cancel one")}`, async () => {
+	const customerId = "cancel-addon-imm-7";
+
+	const messagesItem = items.monthlyMessages({ includedUsage: 100 });
+
+	const recurringAddon = products.recurringAddOn({
+		id: "recurring-addon",
+		items: [messagesItem],
+	});
+
+	const proAddon = products.recurringAddOn({
+		id: "pro-addon",
+		items: [items.monthlyMessages({ includedUsage: 200 })],
+	});
+
+	const { autumnV1 } = await initScenario({
+		customerId,
+		setup: [
+			s.customer({ paymentMethod: "success" }),
+			s.products({ list: [recurringAddon, proAddon] }),
+		],
+		actions: [
+			s.attach({ productId: recurringAddon.id }),
+			s.attach({ productId: proAddon.id }),
+		],
+	});
+
+	// Verify both add-ons active
+	const customerBefore =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+	await expectCustomerProducts({
+		customer: customerBefore,
+		active: [recurringAddon.id, proAddon.id],
+	});
+
+	// Should have 2 invoices (both add-ons attach)
+	expectCustomerInvoiceCorrect({
+		customer: customerBefore,
+		count: 2,
+	});
+
+	// Cancel pro add-on immediately
+	await autumnV1.subscriptions.update({
+		customer_id: customerId,
+		product_id: proAddon.id,
+		cancel: "immediately",
+	});
+
+	// Wait for processing
+	await new Promise((resolve) => setTimeout(resolve, 3000));
+
+	// Verify recurring addon still active, pro addon removed
+	const customerAfter = await autumnV1.customers.get<ApiCustomerV3>(customerId);
+	await expectCustomerProducts({
+		customer: customerAfter,
+		active: [recurringAddon.id],
+		notPresent: [proAddon.id],
+	});
+
+	// Verify refund invoice (-$20)
+	expectCustomerInvoiceCorrect({
+		customer: customerAfter,
+		count: 3, // recurring attach + pro attach + pro refund
+		latestTotal: -20,
+	});
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// TEST 8: One-time add-on cancel - other add-on remains
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Scenario:
+ * - Attach one-time add-on (oneOffMessages) + pro add-on ($20/mo)
+ * - Cancel one-time add-on immediately
+ *
+ * Expected Result:
+ * - One-time add-on removed
+ * - Pro add-on still active
+ */
+test.concurrent(`${chalk.yellowBright("cancel addon immediately: one-time addon cancel")}`, async () => {
+	const customerId = "cancel-addon-imm-8";
+
+	const oneTimeAddon = products.base({
+		id: "one-time-addon",
+		isAddOn: true,
+		items: [items.oneOffMessages({ price: 20, billingUnits: 100 })],
+	});
+
+	const proAddon = products.recurringAddOn({
+		id: "pro-addon",
+		items: [items.monthlyMessages({ includedUsage: 100 })],
+	});
+
+	const { autumnV1 } = await initScenario({
+		customerId,
+		setup: [
+			s.customer({ paymentMethod: "success" }),
+			s.products({ list: [oneTimeAddon, proAddon] }),
+		],
+		actions: [
+			s.attach({
+				productId: oneTimeAddon.id,
+				options: [{ feature_id: TestFeature.Messages, quantity: 100 }],
+			}),
+			s.attach({ productId: proAddon.id }),
+		],
+	});
+
+	// Verify both add-ons active
+	const customerBefore =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+	await expectCustomerProducts({
+		customer: customerBefore,
+		active: [oneTimeAddon.id, proAddon.id],
+	});
+
+	// Cancel one-time add-on immediately
+	await autumnV1.subscriptions.update({
+		customer_id: customerId,
+		product_id: oneTimeAddon.id,
+		cancel: "immediately",
+	});
+
+	// Wait for processing
+	await new Promise((resolve) => setTimeout(resolve, 3000));
+
+	// Verify one-time addon removed, pro addon still active
+	const customerAfter = await autumnV1.customers.get<ApiCustomerV3>(customerId);
+	await expectCustomerProducts({
+		customer: customerAfter,
+		active: [proAddon.id],
+		notPresent: [oneTimeAddon.id],
+	});
+});
diff --git a/server/tests/integration/billing/update-subscription/cancel/cancel-immediately-billing.test.ts b/server/tests/integration/billing/update-subscription/cancel/immediately/cancel-immediately-billing.test.ts
similarity index 100%
rename from server/tests/integration/billing/update-subscription/cancel/cancel-immediately-billing.test.ts
rename to server/tests/integration/billing/update-subscription/cancel/immediately/cancel-immediately-billing.test.ts
diff --git a/server/tests/integration/billing/update-subscription/cancel/cancel-consumable.test.ts b/server/tests/integration/billing/update-subscription/cancel/immediately/cancel-immediately-consumable.test.ts
similarity index 50%
rename from server/tests/integration/billing/update-subscription/cancel/cancel-consumable.test.ts
rename to server/tests/integration/billing/update-subscription/cancel/immediately/cancel-immediately-consumable.test.ts
index 2251d3d4b..8982b2593 100644
--- a/server/tests/integration/billing/update-subscription/cancel/cancel-consumable.test.ts
+++ b/server/tests/integration/billing/update-subscription/cancel/immediately/cancel-immediately-consumable.test.ts
@@ -1,276 +1,35 @@
 /**
- * Cancel Consumable Tests (Customer-Level)
+ * Cancel Immediately Consumable Tests
  *
- * Tests for canceling customer-level products with consumable/arrear items (pay-per-use overage).
- * Consumable items create a final invoice at end of cycle for any overage usage.
+ * Tests for canceling products with consumable/arrear items immediately.
+ * Key behavior: When canceling immediately, arrear overages are NOT charged.
  *
  * Key behaviors:
- * - Overage usage is billed at cycle end (arrear pricing)
- * - Cancel end of cycle: overage billed in final invoice when cycle ends naturally
- * - Cancel immediately: NO overage billed - only base price refund (arrear overages not charged on cancel)
- * - Default update subscription behavior does NOT charge for arrear overages
+ * - Cancel immediately: NO overage billed (arrear overages not charged on immediate cancel)
+ * - Only base price refund is issued
+ * - Both customer-level and entity-level consumables are covered
  *
- * For entity-level tests, see cancel-consumable-entities.test.ts
+ * For end-of-cycle cancel tests (where overage IS charged), see:
+ * - cancel/end-of-cycle/cancel-end-of-cycle-consumable.test.ts
  */
 
 import { expect, test } from "bun:test";
 import type { ApiCustomerV3 } from "@autumn/shared";
-import { calculateExpectedInvoiceAmount } from "@tests/integration/billing/utils/calculateExpectedInvoiceAmount";
 import { expectCustomerInvoiceCorrect } from "@tests/integration/billing/utils/expectCustomerInvoiceCorrect";
 import {
 	expectProductActive,
-	expectProductCanceling,
 	expectProductNotPresent,
 } from "@tests/integration/billing/utils/expectCustomerProductCorrect";
 import { expectNoStripeSubscription } from "@tests/integration/billing/utils/expectNoStripeSubscription";
+import { expectSubToBeCorrect } from "@tests/merged/mergeUtils/expectSubCorrect";
 import { TestFeature } from "@tests/setup/v2Features";
 import { items } from "@tests/utils/fixtures/items";
 import { products } from "@tests/utils/fixtures/products";
-import { advanceToNextInvoice } from "@tests/utils/testAttachUtils/testAttachUtils";
 import { initScenario, s } from "@tests/utils/testInitUtils/initScenario";
-import { advanceTestClock } from "@tests/utils/stripeUtils";
-import { addDays } from "date-fns";
 import chalk from "chalk";
 
 // ═══════════════════════════════════════════════════════════════════════════════
-// TEST 1: Attach → track overage → advance days → cancel immediately (no overage in invoice)
-// ═══════════════════════════════════════════════════════════════════════════════
-
-/**
- * Scenario:
- * - Customer has Pro with consumable messages (100 included, $0.10/unit overage)
- * - Track 500 messages (400 overage)
- * - Advance test clock a couple of days (mid-cycle)
- * - Cancel immediately
- *
- * Expected Result:
- * - Initial invoice: $20 (pro base price)
- * - Final invoice: prorated refund only (NO overage charge)
- * - handleInvoiceCreated is NOT triggered for usage/consumable prices on immediate cancel
- * - Product removed immediately
- *
- * This test verifies that the invoice.created webhook handler does NOT add
- * arrear/consumable usage charges when canceling immediately mid-cycle.
- */
-test.concurrent(`${chalk.yellowBright("cancel consumable: attach → track overage → advance days → cancel immediately (no overage in invoice)")}`, async () => {
-	const customerId = "cancel-cons-adv-imm";
-
-	const consumableItem = items.consumableMessages({ includedUsage: 100 });
-	const pro = products.pro({
-		id: "pro",
-		items: [consumableItem],
-	});
-
-	const { autumnV1Beta, ctx, testClockId } = await initScenario({
-		customerId,
-		setup: [
-			s.customer({ paymentMethod: "success" }),
-			s.products({ list: [pro] }),
-		],
-		actions: [s.attach({ productId: pro.id })],
-	});
-
-	// Verify pro is active
-	const customerAfterAttach =
-		await autumnV1Beta.customers.get<ApiCustomerV3>(customerId);
-	await expectProductActive({
-		customer: customerAfterAttach,
-		productId: pro.id,
-	});
-
-	// Initial attach invoice: $20 base price
-	expectCustomerInvoiceCorrect({
-		customer: customerAfterAttach,
-		count: 1,
-		latestTotal: 20,
-	});
-
-	// Track 500 messages (100 included, 400 overage)
-	// Note: This overage will NOT be charged when canceling immediately
-	await autumnV1Beta.track({
-		customer_id: customerId,
-		feature_id: TestFeature.Messages,
-		value: 500,
-	});
-
-	// Verify usage was tracked (400 overage = balance should be -400)
-	const customerAfterTrack =
-		await autumnV1Beta.customers.get<ApiCustomerV3>(customerId);
-	expect(customerAfterTrack.features[TestFeature.Messages].balance).toBe(-400);
-
-	// Advance test clock 5 days mid-cycle
-	await advanceTestClock({
-		stripeCli: ctx.stripeCli,
-		testClockId: testClockId!,
-		advanceTo: addDays(new Date(), 5).getTime(),
-		waitForSeconds: 10,
-	});
-
-	// Preview cancel immediately
-	const cancelParams = {
-		customer_id: customerId,
-		product_id: pro.id,
-		cancel: "immediately" as const,
-	};
-	const preview = await autumnV1Beta.subscriptions.previewUpdate(cancelParams);
-
-	// Final invoice should be a prorated refund only (negative), NO overage
-	// After 5 days of a ~30 day cycle, refund is roughly (25/30) * $20 ≈ -$16.67
-	// The key assertion: invoice should be NEGATIVE (refund only, no overage charge)
-	expect(preview.total).toBeLessThan(0);
-
-	// Execute cancel
-	await autumnV1Beta.subscriptions.update(cancelParams);
-
-	// Verify pro is removed
-	const customerAfterCancel =
-		await autumnV1Beta.customers.get<ApiCustomerV3>(customerId);
-	await expectProductNotPresent({
-		customer: customerAfterCancel,
-		productId: pro.id,
-	});
-
-	// Verify no Stripe subscription exists
-	await expectNoStripeSubscription({
-		db: ctx.db,
-		customerId,
-		org: ctx.org,
-		env: ctx.env,
-	});
-
-	// Should have 2 invoices: initial ($20) + final (refund, negative)
-	expect(customerAfterCancel.invoices?.length).toBe(2);
-
-	// Final invoice should match preview (negative = refund only, no overage)
-	const finalInvoice = customerAfterCancel.invoices?.[0];
-	expect(finalInvoice?.total).toBe(preview.total);
-	expect(finalInvoice?.total).toBeLessThan(0);
-
-	// Calculate what overage WOULD have been if charged: 400 * $0.10 = $40
-	// If overage was incorrectly included, total would be: $40 - refund ≈ $23+
-	// By asserting total < 0, we confirm overage is NOT in the invoice
-	const overageIfCharged = calculateExpectedInvoiceAmount({
-		items: pro.items,
-		usage: [{ featureId: TestFeature.Messages, value: 500 }],
-		options: { includeFixed: false, onlyArrear: true },
-	});
-	expect(overageIfCharged).toBe(40);
-
-	// The final invoice should be much less than the overage amount
-	// (in fact, it should be negative since it's just a refund)
-	expect(finalInvoice?.total).toBeLessThan(overageIfCharged);
-});
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// TEST 2: Track → cancel end of cycle → advance (customer-level)
-// ═══════════════════════════════════════════════════════════════════════════════
-
-/**
- * Scenario:
- * - Customer has Pro with consumable messages (100 included, $0.10/unit overage)
- * - Track 500 messages (400 overage)
- * - Cancel end of cycle
- * - Advance to next invoice
- *
- * Expected Result:
- * - Initial invoice: $20 (pro base price)
- * - Final invoice: $40 (400 overage * $0.10)
- * - Product removed after cycle ends
- *
- * Migrated from: cancel2.test.ts
- */
-test.concurrent(`${chalk.yellowBright("cancel consumable: track → cancel end of cycle → advance")}`, async () => {
-	const customerId = "cancel-cons-eoc-cus";
-
-	const consumableItem = items.consumableMessages({ includedUsage: 100 });
-	const pro = products.pro({
-		id: "pro",
-		items: [consumableItem],
-	});
-
-	const { autumnV1Beta, ctx, testClockId } = await initScenario({
-		customerId,
-		setup: [
-			s.customer({ paymentMethod: "success" }),
-			s.products({ list: [pro] }),
-		],
-		actions: [s.attach({ productId: pro.id })],
-	});
-
-	// Verify pro is active
-	const customerAfterAttach =
-		await autumnV1Beta.customers.get<ApiCustomerV3>(customerId);
-	await expectProductActive({
-		customer: customerAfterAttach,
-		productId: pro.id,
-	});
-
-	// Initial attach invoice: $20 base price
-	expectCustomerInvoiceCorrect({
-		customer: customerAfterAttach,
-		count: 1,
-		latestTotal: 20,
-	});
-
-	// Track 500 messages (100 included, 400 overage)
-	await autumnV1Beta.track({
-		customer_id: customerId,
-		feature_id: TestFeature.Messages,
-		value: 500,
-	});
-
-	// Cancel end of cycle
-	await autumnV1Beta.subscriptions.update({
-		customer_id: customerId,
-		product_id: pro.id,
-		cancel: "end_of_cycle",
-	});
-
-	// Verify pro is canceling
-	const customerAfterCancel =
-		await autumnV1Beta.customers.get<ApiCustomerV3>(customerId);
-	await expectProductCanceling({
-		customer: customerAfterCancel,
-		productId: pro.id,
-	});
-
-	// Advance to next invoice
-	await advanceToNextInvoice({
-		stripeCli: ctx.stripeCli,
-		testClockId: testClockId!,
-	});
-
-	// Calculate expected overage amount using new synchronous utility
-	// 500 total usage - 100 included = 400 overage * $0.10 = $40
-	const expectedOverage = calculateExpectedInvoiceAmount({
-		items: pro.items,
-		usage: [{ featureId: TestFeature.Messages, value: 500 }],
-		options: { includeFixed: false, onlyArrear: true },
-	});
-
-	expect(expectedOverage).toBe(40);
-
-	// Verify final state
-	const customerAfterAdvance =
-		await autumnV1Beta.customers.get<ApiCustomerV3>(customerId);
-
-	// Product should be removed
-	await expectProductNotPresent({
-		customer: customerAfterAdvance,
-		productId: pro.id,
-	});
-
-	// Should have 2 invoices: initial ($20) + final overage ($40)
-	expectCustomerInvoiceCorrect({
-		customer: customerAfterAdvance,
-		count: 2,
-		latestTotal: expectedOverage,
-		latestInvoiceProductId: pro.id,
-	});
-});
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// TEST 3: Track → cancel immediately (customer-level) - no overage charge
+// TEST 2: Track → cancel immediately (customer-level) - no overage charge
 // ═══════════════════════════════════════════════════════════════════════════════
 
 /**
@@ -284,8 +43,8 @@ test.concurrent(`${chalk.yellowBright("cancel consumable: track → cancel end o
  * - Final invoice: -$20 (base refund only, no overage - arrear overages not charged on cancel)
  * - Product removed immediately
  */
-test.concurrent(`${chalk.yellowBright("cancel consumable: track → cancel immediately - no overage charge")}`, async () => {
-	const customerId = "cancel-cons-imm-cus";
+test.concurrent(`${chalk.yellowBright("cancel immediately consumable: customer - track overage → cancel immediately (no charges)")}`, async () => {
+	const customerId = "cancel-imm-cons-cus";
 
 	const consumableItem = items.consumableMessages({ includedUsage: 100 });
 	const pro = products.pro({
@@ -367,23 +126,22 @@ test.concurrent(`${chalk.yellowBright("cancel consumable: track → cancel immed
 });
 
 // ═══════════════════════════════════════════════════════════════════════════════
-// TEST 4: Track → cancel immediately with failed payment
+// TEST 3: Track → cancel immediately (entity) - no overage charge
 // ═══════════════════════════════════════════════════════════════════════════════
 
 /**
  * Scenario:
- * - Customer has Pro with consumable messages
- * - Track usage into overage
- * - Switch to failing payment method
- * - Cancel immediately
+ * - Entity has Pro with consumable messages (100 included, $0.10/unit overage)
+ * - Track 500 messages on entity (400 overage)
+ * - Cancel entity's product immediately
  *
  * Expected Result:
- * - Final invoice: refund only (-$20), no overage charged on cancel
- * - Since it's a refund (credit), no payment attempt needed
- * - Product still removed
+ * - Initial invoice: $20 (pro base price)
+ * - Final invoice: -$20 (base refund only, no overage - arrear overages not charged on cancel)
+ * - Entity product removed immediately
  */
-test.concurrent(`${chalk.yellowBright("cancel consumable: track → cancel immediately with failed payment - refund only")}`, async () => {
-	const customerId = "cancel-cons-fail-pay";
+test.concurrent(`${chalk.yellowBright("cancel immediately consumable: entity - track overage → cancel immediately (no charges)")}`, async () => {
+	const customerId = "cancel-imm-cons-ent";
 
 	const consumableItem = items.consumableMessages({ includedUsage: 100 });
 	const pro = products.pro({
@@ -391,56 +149,267 @@ test.concurrent(`${chalk.yellowBright("cancel consumable: track → cancel immed
 		items: [consumableItem],
 	});
 
-	const { autumnV1 } = await initScenario({
+	const { autumnV1, ctx, entities } = await initScenario({
 		customerId,
 		setup: [
 			s.customer({ paymentMethod: "success" }),
 			s.products({ list: [pro] }),
+			s.entities({ count: 1, featureId: TestFeature.Users }),
 		],
-		actions: [
-			s.attach({ productId: pro.id }),
-			s.attachPaymentMethod({ type: "fail" }), // Switch to failing card
-		],
+		actions: [s.attach({ productId: pro.id, entityIndex: 0 })],
 	});
 
-	// Verify pro is active
-	const customerAfterAttach =
-		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+	const entityId = entities[0].id;
+
+	// Verify pro is active on entity
+	const entity = await autumnV1.entities.get(customerId, entityId);
 	await expectProductActive({
-		customer: customerAfterAttach,
+		customer: entity,
 		productId: pro.id,
 	});
 
-	// Track 1000 messages (900 overage)
+	// Track 500 messages on entity (100 included, 400 overage)
 	// Note: This overage will NOT be charged when canceling immediately
 	await autumnV1.track({
 		customer_id: customerId,
+		entity_id: entityId,
 		feature_id: TestFeature.Messages,
-		value: 1000,
+		value: 500,
 	});
 
-	// Cancel immediately (with failing payment method)
+	// Preview cancel immediately
+	const cancelParams = {
+		customer_id: customerId,
+		entity_id: entityId,
+		product_id: pro.id,
+		cancel: "immediately" as const,
+	};
+	const preview = await autumnV1.subscriptions.previewUpdate(cancelParams);
+
+	// Final invoice = base refund only (-$20), no overage charged on cancel
+	expect(preview.total).toBe(-20);
+
+	// Execute cancel
+	await autumnV1.subscriptions.update(cancelParams);
+
+	// Verify pro is removed from entity
+	const entityAfterCancel = await autumnV1.entities.get(customerId, entityId);
+	await expectProductNotPresent({
+		customer: entityAfterCancel,
+		productId: pro.id,
+	});
+
+	// Verify no Stripe subscription exists
+	await expectNoStripeSubscription({
+		db: ctx.db,
+		customerId,
+		org: ctx.org,
+		env: ctx.env,
+	});
+
+	// Check customer invoices
+	const customerAfterCancel =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+
+	// Should have 2 invoices: initial ($20) + final (refund -$20)
+	expect(customerAfterCancel.invoices?.length).toBe(2);
+
+	// Verify final invoice matches preview (refund only)
+	expectCustomerInvoiceCorrect({
+		customer: customerAfterCancel,
+		count: 2,
+		latestTotal: preview.total,
+	});
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// TEST 4: Two entities, cancel one immediately, keep one active - no overage charge
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Scenario:
+ * - Entity 1 and Entity 2 both have Pro with consumable messages
+ * - Track usage into overage on both entities
+ * - Cancel only Entity 1 immediately
+ * - Keep Entity 2 active
+ *
+ * Expected Result:
+ * - Entity 1's final invoice: -$20 (base refund only, no overage charge)
+ * - Entity 1 product removed immediately
+ * - Entity 2 continues unaffected
+ */
+test.concurrent(`${chalk.yellowBright("cancel immediately consumable: two entities, cancel one, keep one active")}`, async () => {
+	const customerId = "cancel-imm-cons-2ent-1cancel";
+
+	const consumableItem = items.consumableMessages({ includedUsage: 100 });
+	const pro = products.pro({
+		id: "pro",
+		items: [consumableItem],
+	});
+
+	const { autumnV1, ctx, entities } = await initScenario({
+		customerId,
+		setup: [
+			s.customer({ paymentMethod: "success" }),
+			s.products({ list: [pro] }),
+			s.entities({ count: 2, featureId: TestFeature.Users }),
+		],
+		actions: [
+			s.attach({ productId: pro.id, entityIndex: 0 }),
+			s.attach({ productId: pro.id, entityIndex: 1 }),
+		],
+	});
+
+	const entity1Id = entities[0].id;
+	const entity2Id = entities[1].id;
+
+	// Verify initial invoices: 2 invoices, $20 each for entity attaches
+	const customerAfterAttach =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+	expectCustomerInvoiceCorrect({
+		customer: customerAfterAttach,
+		count: 2,
+		latestTotal: 20,
+	});
+
+	// Track usage on entity 1: 500 messages (400 overage)
+	// Note: This overage will NOT be charged when canceling immediately
+	await autumnV1.track({
+		customer_id: customerId,
+		entity_id: entity1Id,
+		feature_id: TestFeature.Messages,
+		value: 500,
+	});
+
+	// Track usage on entity 2: 150 messages (50 overage)
+	await autumnV1.track({
+		customer_id: customerId,
+		entity_id: entity2Id,
+		feature_id: TestFeature.Messages,
+		value: 150,
+	});
+
+	// Cancel only entity 1 immediately
 	await autumnV1.subscriptions.update({
 		customer_id: customerId,
+		entity_id: entity1Id,
 		product_id: pro.id,
 		cancel: "immediately",
 	});
 
-	// Verify product is removed
-	const customerAfterCancel =
-		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+	// Verify entity 1 product removed immediately, entity 2 still active
+	const entity1AfterCancel = await autumnV1.entities.get(customerId, entity1Id);
+	const entity2AfterCancel = await autumnV1.entities.get(customerId, entity2Id);
 	await expectProductNotPresent({
-		customer: customerAfterCancel,
+		customer: entity1AfterCancel,
+		productId: pro.id,
+	});
+	await expectProductActive({
+		customer: entity2AfterCancel,
 		productId: pro.id,
 	});
 
-	// Verify invoice was created
-	expect(customerAfterCancel.invoices?.length).toBeGreaterThanOrEqual(2);
+	// Check customer invoices
+	const customerAfterCancel =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
 
-	// Find the final invoice (most recent)
-	const finalInvoice = customerAfterCancel.invoices?.[0];
+	// Should have 3 invoices:
+	// - 2 initial invoices ($20 each for entity attaches)
+	// - 1 final invoice for entity 1 refund (-$20, no overage charged on cancel)
+	expectCustomerInvoiceCorrect({
+		customer: customerAfterCancel,
+		count: 3,
+		latestTotal: -20,
+	});
 
-	// Final invoice should be a refund (-$20), no overage charged on cancel
-	// Refunds/credits don't require payment, so status should be 'paid' (applied as credit)
-	expect(finalInvoice?.total).toBe(-20);
+	// Verify entity 2 has the product and subscription exists
+	await expectSubToBeCorrect({
+		db: ctx.db,
+		customerId,
+		org: ctx.org,
+		env: ctx.env,
+		subCount: 1, // Entity 2's subscription should still exist
+	});
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// TEST 5: Entity within included usage, cancel immediately (no overage)
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Scenario:
+ * - Entity has Pro with consumable messages (100 included)
+ * - Track 50 messages (within included usage, no overage)
+ * - Cancel immediately
+ *
+ * Expected Result:
+ * - No overage invoice (usage within included)
+ * - Only refund invoice for unused time (if applicable)
+ * - Product removed immediately
+ */
+test.concurrent(`${chalk.yellowBright("cancel immediately consumable: entity - within included usage → cancel")}`, async () => {
+	const customerId = "cancel-imm-cons-no-overage";
+
+	const consumableItem = items.consumableMessages({ includedUsage: 100 });
+	const pro = products.pro({
+		id: "pro",
+		items: [consumableItem],
+	});
+
+	const { autumnV1, entities } = await initScenario({
+		customerId,
+		setup: [
+			s.customer({ paymentMethod: "success" }),
+			s.products({ list: [pro] }),
+			s.entities({ count: 1, featureId: TestFeature.Users }),
+		],
+		actions: [s.attach({ productId: pro.id, entityIndex: 0 })],
+	});
+
+	const entityId = entities[0].id;
+
+	// Verify pro is active on entity
+	const entity = await autumnV1.entities.get(customerId, entityId);
+	await expectProductActive({
+		customer: entity,
+		productId: pro.id,
+	});
+
+	// Track 50 messages (within 100 included, no overage)
+	await autumnV1.track({
+		customer_id: customerId,
+		entity_id: entityId,
+		feature_id: TestFeature.Messages,
+		value: 50,
+	});
+
+	// Verify balance is correct (100 - 50 = 50)
+	const entityAfterTrack = await autumnV1.entities.get(customerId, entityId);
+	expect(entityAfterTrack.features[TestFeature.Messages].balance).toBe(50);
+
+	// Cancel immediately
+	await autumnV1.subscriptions.update({
+		customer_id: customerId,
+		entity_id: entityId,
+		product_id: pro.id,
+		cancel: "immediately",
+	});
+
+	// Verify product removed
+	const entityAfterCancel = await autumnV1.entities.get(customerId, entityId);
+	await expectProductNotPresent({
+		customer: entityAfterCancel,
+		productId: pro.id,
+	});
+
+	// Check invoices - should have initial ($20) and possibly refund, but NO overage charge
+	const customerAfterCancel =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+
+	// Verify the final invoice (if exists) is a refund (negative or zero), not an overage charge
+	if (customerAfterCancel.invoices && customerAfterCancel.invoices.length > 1) {
+		const finalInvoice = customerAfterCancel.invoices[0];
+		// Final invoice should be refund (negative) or small, not a large overage charge
+		expect(finalInvoice.total).toBeLessThanOrEqual(0);
+	}
 });
diff --git a/server/tests/integration/billing/update-subscription/cancel/immediately/cancel-immediately-trial-entities.test.ts b/server/tests/integration/billing/update-subscription/cancel/immediately/cancel-immediately-trial-entities.test.ts
new file mode 100644
index 000000000..b5b4cba8d
--- /dev/null
+++ b/server/tests/integration/billing/update-subscription/cancel/immediately/cancel-immediately-trial-entities.test.ts
@@ -0,0 +1,410 @@
+/**
+ * Cancel Trial Immediately Entity Tests
+ *
+ * Tests for canceling trial products immediately in multi-entity (merged subscription) scenarios.
+ * These tests verify behavior when multiple entities share a subscription during trial.
+ *
+ * Key behaviors:
+ * - Canceling one entity doesn't affect others on the same merged subscription
+ * - Subscription remains trialing as long as at least one entity is trialing
+ * - Mixed cancel patterns (EOC + immediately) work correctly
+ */
+
+import { expect, test } from "bun:test";
+import { type ApiCustomerV3, CusProductStatus } from "@autumn/shared";
+import {
+	expectCustomerProducts,
+	expectProductNotPresent,
+} from "@tests/integration/billing/utils/expectCustomerProductCorrect";
+import { expectProductTrialing } from "@tests/integration/billing/utils/expectCustomerProductTrialing";
+import { expectSubToBeCorrect } from "@tests/merged/mergeUtils/expectSubCorrect";
+import { TestFeature } from "@tests/setup/v2Features";
+import { items } from "@tests/utils/fixtures/items";
+import { products } from "@tests/utils/fixtures/products";
+import { initScenario, s } from "@tests/utils/testInitUtils/initScenario";
+import chalk from "chalk";
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// TEST 1: Cancel one entity immediately - other entity still trialing
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Scenario (from mergedTrial4.test.ts):
+ * - Create 2 entities
+ * - Attach proWithTrial to entity 1
+ * - Attach proWithTrial to entity 2 (merged subscription)
+ * - Cancel entity 2's trial immediately
+ *
+ * Expected Result:
+ * - Entity 2's product is removed
+ * - Entity 1's product is still trialing
+ * - Stripe subscription is still trialing (entity 1 remains)
+ */
+test(`${chalk.yellowBright("cancel trial immediately entity: one entity, other still trialing")}`, async () => {
+	const customerId = "cancel-trial-imm-entity-1";
+
+	const messagesItem = items.monthlyMessages({ includedUsage: 100 });
+
+	const proTrial = products.proWithTrial({
+		id: "pro-trial",
+		items: [messagesItem],
+		trialDays: 7,
+	});
+
+	const { autumnV1, ctx, entities } = await initScenario({
+		customerId,
+		setup: [
+			s.customer({ paymentMethod: "success" }),
+			s.products({ list: [proTrial] }),
+			s.entities({ count: 2, featureId: TestFeature.Users }),
+		],
+		actions: [
+			s.attach({ productId: proTrial.id, entityIndex: 0 }),
+			s.attach({ productId: proTrial.id, entityIndex: 1 }),
+		],
+	});
+
+	// Verify both entities are trialing
+	const entity1Before = await autumnV1.entities.get(customerId, entities[0].id);
+	const entity2Before = await autumnV1.entities.get(customerId, entities[1].id);
+
+	await expectProductTrialing({
+		customer: entity1Before,
+		productId: proTrial.id,
+	});
+
+	await expectProductTrialing({
+		customer: entity2Before,
+		productId: proTrial.id,
+	});
+
+	// Cancel entity 2's trial immediately
+	await autumnV1.subscriptions.update({
+		customer_id: customerId,
+		entity_id: entities[1].id,
+		product_id: proTrial.id,
+		cancel: "immediately",
+	});
+
+	// Wait for processing
+	await new Promise((resolve) => setTimeout(resolve, 2000));
+
+	// Verify entity 2's product is removed
+	const entity2After = await autumnV1.entities.get(customerId, entities[1].id);
+	await expectProductNotPresent({
+		customer: entity2After,
+		productId: proTrial.id,
+	});
+
+	// Verify entity 1's product is still trialing
+	const entity1After = await autumnV1.entities.get(customerId, entities[0].id);
+	await expectProductTrialing({
+		customer: entity1After,
+		productId: proTrial.id,
+	});
+
+	// Verify subscription is still trialing
+	await expectSubToBeCorrect({
+		db: ctx.db,
+		customerId,
+		org: ctx.org,
+		env: ctx.env,
+		shouldBeTrialing: true,
+	});
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// TEST 2: Cancel both entities immediately - subscription canceled
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Scenario:
+ * - Create 2 entities
+ * - Attach proWithTrial to entity 1
+ * - Attach proWithTrial to entity 2 (merged subscription)
+ * - Cancel entity 1 immediately
+ * - Cancel entity 2 immediately
+ *
+ * Expected Result:
+ * - Both products are removed
+ * - Stripe subscription is canceled (no entities remain)
+ */
+test(`${chalk.yellowBright("cancel trial immediately entity: both entities, subscription canceled")}`, async () => {
+	const customerId = "cancel-trial-imm-entity-2";
+
+	const messagesItem = items.monthlyMessages({ includedUsage: 100 });
+
+	const proTrial = products.proWithTrial({
+		id: "pro-trial",
+		items: [messagesItem],
+		trialDays: 7,
+	});
+
+	const { autumnV1, ctx, entities } = await initScenario({
+		customerId,
+		setup: [
+			s.customer({ paymentMethod: "success" }),
+			s.products({ list: [proTrial] }),
+			s.entities({ count: 2, featureId: TestFeature.Users }),
+		],
+		actions: [
+			s.attach({ productId: proTrial.id, entityIndex: 0 }),
+			s.attach({ productId: proTrial.id, entityIndex: 1 }),
+		],
+	});
+
+	// Cancel entity 1 immediately
+	await autumnV1.subscriptions.update({
+		customer_id: customerId,
+		entity_id: entities[0].id,
+		product_id: proTrial.id,
+		cancel: "immediately",
+	});
+
+	// Wait for processing
+	await new Promise((resolve) => setTimeout(resolve, 2000));
+
+	// Verify entity 1's product is removed, entity 2 still trialing
+	const entity1After = await autumnV1.entities.get(customerId, entities[0].id);
+	await expectProductNotPresent({
+		customer: entity1After,
+		productId: proTrial.id,
+	});
+
+	const entity2Mid = await autumnV1.entities.get(customerId, entities[1].id);
+	await expectProductTrialing({
+		customer: entity2Mid,
+		productId: proTrial.id,
+	});
+
+	// Cancel entity 2 immediately
+	await autumnV1.subscriptions.update({
+		customer_id: customerId,
+		entity_id: entities[1].id,
+		product_id: proTrial.id,
+		cancel: "immediately",
+	});
+
+	// Wait for processing
+	await new Promise((resolve) => setTimeout(resolve, 2000));
+
+	// Verify entity 2's product is also removed
+	const entity2After = await autumnV1.entities.get(customerId, entities[1].id);
+	await expectProductNotPresent({
+		customer: entity2After,
+		productId: proTrial.id,
+	});
+
+	// Verify subscription is canceled
+	await expectSubToBeCorrect({
+		db: ctx.db,
+		customerId,
+		org: ctx.org,
+		env: ctx.env,
+		shouldBeCanceled: true,
+	});
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// TEST 3: Mixed cancel - EOC then immediately on 3 entities
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Scenario (from mergedTrial5.test.ts):
+ * - Create 3 entities
+ * - Attach proWithTrial to all 3 entities (merged subscription)
+ * - Cancel entity 2 at end of cycle
+ * - Cancel entity 3 immediately
+ * - Cancel entity 1 at end of cycle
+ *
+ * Expected Result:
+ * - Entity 3 is removed immediately
+ * - Entities 1 and 2 are canceling but still trialing
+ * - Subscription is trialing but scheduled to cancel
+ */
+test(`${chalk.yellowBright("cancel trial immediately entity: mixed EOC + immediately on 3 entities")}`, async () => {
+	const customerId = "cancel-trial-imm-entity-3";
+
+	const messagesItem = items.monthlyMessages({ includedUsage: 100 });
+
+	const proTrial = products.proWithTrial({
+		id: "pro-trial",
+		items: [messagesItem],
+		trialDays: 7,
+	});
+
+	const { autumnV1, ctx, entities } = await initScenario({
+		customerId,
+		setup: [
+			s.customer({ paymentMethod: "success" }),
+			s.products({ list: [proTrial] }),
+			s.entities({ count: 3, featureId: TestFeature.Users }),
+		],
+		actions: [
+			s.attach({ productId: proTrial.id, entityIndex: 0 }),
+			s.attach({ productId: proTrial.id, entityIndex: 1 }),
+			s.attach({ productId: proTrial.id, entityIndex: 2 }),
+		],
+	});
+
+	// Verify all 3 entities are trialing
+	for (let i = 0; i < 3; i++) {
+		const entity = await autumnV1.entities.get(customerId, entities[i].id);
+		await expectProductTrialing({
+			customer: entity,
+			productId: proTrial.id,
+		});
+	}
+
+	// Cancel entity 2 at end of cycle
+	await autumnV1.subscriptions.update({
+		customer_id: customerId,
+		entity_id: entities[1].id,
+		product_id: proTrial.id,
+		cancel: "end_of_cycle",
+	});
+
+	// Verify subscription still trialing
+	await expectSubToBeCorrect({
+		db: ctx.db,
+		customerId,
+		org: ctx.org,
+		env: ctx.env,
+		shouldBeTrialing: true,
+	});
+
+	// Cancel entity 3 immediately
+	await autumnV1.subscriptions.update({
+		customer_id: customerId,
+		entity_id: entities[2].id,
+		product_id: proTrial.id,
+		cancel: "immediately",
+	});
+
+	// Wait for processing
+	await new Promise((resolve) => setTimeout(resolve, 2000));
+
+	// Verify entity 3 is removed
+	const entity3After = await autumnV1.entities.get(customerId, entities[2].id);
+	await expectProductNotPresent({
+		customer: entity3After,
+		productId: proTrial.id,
+	});
+
+	// Verify subscription still trialing (entities 1 and 2 remain)
+	await expectSubToBeCorrect({
+		db: ctx.db,
+		customerId,
+		org: ctx.org,
+		env: ctx.env,
+		shouldBeTrialing: true,
+	});
+
+	// Cancel entity 1 at end of cycle
+	await autumnV1.subscriptions.update({
+		customer_id: customerId,
+		entity_id: entities[0].id,
+		product_id: proTrial.id,
+		cancel: "end_of_cycle",
+	});
+
+	// Verify subscription is trialing but canceled (all remaining entities are EOC canceling)
+	await expectSubToBeCorrect({
+		db: ctx.db,
+		customerId,
+		org: ctx.org,
+		env: ctx.env,
+		shouldBeTrialing: true,
+		shouldBeCanceled: true,
+	});
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// TEST 4: Cancel immediately then re-attach on same entity
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Scenario:
+ * - Create 1 entity
+ * - Attach proWithTrial to entity
+ * - Cancel immediately
+ * - Re-attach proWithTrial to same entity
+ *
+ * Expected Result:
+ * - After cancel: product removed
+ * - After re-attach: product active (not trialing - trial already used)
+ * - Full price invoice created
+ */
+test(`${chalk.yellowBright("cancel trial immediately entity: cancel then re-attach same entity")}`, async () => {
+	const customerId = "cancel-trial-imm-entity-4";
+
+	const messagesItem = items.monthlyMessages({ includedUsage: 100 });
+
+	const proTrial = products.proWithTrial({
+		id: "pro-trial",
+		items: [messagesItem],
+		trialDays: 7,
+	});
+
+	const { autumnV1, entities } = await initScenario({
+		customerId,
+		setup: [
+			s.customer({ paymentMethod: "success" }),
+			s.products({ list: [proTrial] }),
+			s.entities({ count: 1, featureId: TestFeature.Users }),
+		],
+		actions: [s.attach({ productId: proTrial.id, entityIndex: 0 })],
+	});
+
+	// Verify entity is trialing
+	const entityBefore = await autumnV1.entities.get(customerId, entities[0].id);
+	await expectProductTrialing({
+		customer: entityBefore,
+		productId: proTrial.id,
+	});
+
+	// Cancel immediately
+	await autumnV1.subscriptions.update({
+		customer_id: customerId,
+		entity_id: entities[0].id,
+		product_id: proTrial.id,
+		cancel: "immediately",
+	});
+
+	// Wait for processing
+	await new Promise((resolve) => setTimeout(resolve, 2000));
+
+	// Verify product is removed
+	const entityAfterCancel = await autumnV1.entities.get(
+		customerId,
+		entities[0].id,
+	);
+	await expectProductNotPresent({
+		customer: entityAfterCancel,
+		productId: proTrial.id,
+	});
+
+	// Re-attach proWithTrial
+	await autumnV1.attach({
+		customer_id: customerId,
+		entity_id: entities[0].id,
+		product_id: proTrial.id,
+	});
+
+	// Verify product is ACTIVE (not trialing - trial already used)
+	const entityAfterReattach = await autumnV1.entities.get(
+		customerId,
+		entities[0].id,
+	);
+
+	const product = entityAfterReattach.products.find(
+		(p) => p.id === proTrial.id,
+	);
+	expect(product).toBeDefined();
+	expect(product?.status).toBe(CusProductStatus.Active);
+
+	// Customer should have 2 invoices: $0 (trial) + $20 (full price)
+	const customer = await autumnV1.customers.get<ApiCustomerV3>(customerId);
+	expect(customer.invoices?.length).toBe(2);
+	expect(customer.invoices?.[0].total).toBe(20); // Latest is full price
+});
diff --git a/server/tests/integration/billing/update-subscription/cancel/immediately/cancel-immediately-trial.test.ts b/server/tests/integration/billing/update-subscription/cancel/immediately/cancel-immediately-trial.test.ts
new file mode 100644
index 000000000..4fdcd6cdc
--- /dev/null
+++ b/server/tests/integration/billing/update-subscription/cancel/immediately/cancel-immediately-trial.test.ts
@@ -0,0 +1,456 @@
+/**
+ * Cancel Trial Immediately Tests
+ *
+ * Tests for canceling products with free trials immediately using `cancel: 'immediately'`.
+ * Verifies immediate cancellation behavior, invoice handling, and re-attachment flows.
+ *
+ * Key behaviors:
+ * - Product is removed immediately
+ * - No refund invoice (trial is free)
+ * - Re-attaching after cancel may or may not grant another trial (depends on config)
+ */
+
+import { expect, test } from "bun:test";
+import { type ApiCustomerV3, CusProductStatus, ms } from "@autumn/shared";
+import { expectCustomerInvoiceCorrect } from "@tests/integration/billing/utils/expectCustomerInvoiceCorrect";
+import {
+	expectCustomerProducts,
+	expectProductNotPresent,
+} from "@tests/integration/billing/utils/expectCustomerProductCorrect";
+import { expectProductTrialing } from "@tests/integration/billing/utils/expectCustomerProductTrialing";
+import { expectNoStripeSubscription } from "@tests/integration/billing/utils/expectNoStripeSubscription";
+import { TestFeature } from "@tests/setup/v2Features";
+import { items } from "@tests/utils/fixtures/items";
+import { products } from "@tests/utils/fixtures/products";
+import { initScenario, s } from "@tests/utils/testInitUtils/initScenario";
+import chalk from "chalk";
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// TEST 1: Basic cancel trial immediately
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Scenario:
+ * - User attaches proWithTrial (7-day trial)
+ * - User cancels immediately
+ *
+ * Expected Result:
+ * - Product is removed immediately
+ * - No Stripe subscription (canceled)
+ * - No new invoices (trial was free)
+ */
+test(`${chalk.yellowBright("cancel trial immediately: basic cancel")}`, async () => {
+	const customerId = "cancel-trial-imm-basic";
+
+	const messagesItem = items.monthlyMessages({ includedUsage: 100 });
+
+	const proTrial = products.proWithTrial({
+		id: "pro-trial",
+		items: [messagesItem],
+		trialDays: 7,
+	});
+
+	const { autumnV1, ctx, advancedTo } = await initScenario({
+		customerId,
+		setup: [
+			s.customer({ paymentMethod: "success" }),
+			s.products({ list: [proTrial] }),
+		],
+		actions: [s.attach({ productId: proTrial.id })],
+	});
+
+	// Verify product is trialing
+	const customerAfterAttach =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+
+	await expectProductTrialing({
+		customer: customerAfterAttach,
+		productId: proTrial.id,
+		trialEndsAt: advancedTo + ms.days(7),
+	});
+
+	// Initial invoice should be $0 (trial)
+	expectCustomerInvoiceCorrect({
+		customer: customerAfterAttach,
+		count: 1,
+		latestTotal: 0,
+	});
+
+	// Preview the cancel - should be $0 (no charge for canceling during trial)
+	const cancelParams = {
+		customer_id: customerId,
+		product_id: proTrial.id,
+		cancel: "immediately" as const,
+	};
+	const preview = await autumnV1.subscriptions.previewUpdate(cancelParams);
+	expect(preview.total).toBe(0);
+
+	// Execute the cancel
+	await autumnV1.subscriptions.update(cancelParams);
+
+	// Verify product is removed
+	const customerAfterCancel =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+
+	await expectProductNotPresent({
+		customer: customerAfterCancel,
+		productId: proTrial.id,
+	});
+
+	// No new invoices (trial was free)
+	expectCustomerInvoiceCorrect({
+		customer: customerAfterCancel,
+		count: 1,
+		latestTotal: 0,
+	});
+
+	// Verify no Stripe subscription exists (canceled)
+	await expectNoStripeSubscription({
+		db: ctx.db,
+		customerId,
+		org: ctx.org,
+		env: ctx.env,
+	});
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// TEST 2: Cancel trial immediately with free default - free becomes active
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Scenario:
+ * - Free default product exists
+ * - User attaches proWithTrial (7-day trial)
+ * - User cancels immediately
+ *
+ * Expected Result:
+ * - Pro is removed immediately
+ * - Free default becomes active immediately
+ * - No paid invoices
+ */
+test(`${chalk.yellowBright("cancel trial immediately: with free default")}`, async () => {
+	const customerId = "cancel-trial-imm-default";
+
+	const messagesItem = items.monthlyMessages({ includedUsage: 100 });
+
+	const free = products.base({
+		id: "free",
+		items: [messagesItem],
+		isDefault: true,
+	});
+
+	const proTrial = products.proWithTrial({
+		id: "pro-trial",
+		items: [messagesItem],
+		trialDays: 7,
+	});
+
+	const { autumnV1 } = await initScenario({
+		customerId,
+		setup: [
+			s.customer({ paymentMethod: "success" }),
+			s.products({ list: [free, proTrial] }),
+		],
+		actions: [s.attach({ productId: proTrial.id })],
+	});
+
+	// Verify product is trialing
+	const customerAfterAttach =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+
+	await expectProductTrialing({
+		customer: customerAfterAttach,
+		productId: proTrial.id,
+	});
+
+	// Cancel immediately
+	await autumnV1.subscriptions.update({
+		customer_id: customerId,
+		product_id: proTrial.id,
+		cancel: "immediately",
+	});
+
+	// Verify pro is removed and free is active
+	const customerAfterCancel =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+
+	await expectCustomerProducts({
+		customer: customerAfterCancel,
+		active: [free.id],
+		notPresent: [proTrial.id],
+	});
+
+	// No paid invoices
+	for (const invoice of customerAfterCancel.invoices ?? []) {
+		expect(invoice.total).toBe(0);
+	}
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// TEST 3: Cancel trial immediately then re-attach (renewal flow)
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Scenario (from basic7.test.ts):
+ * - User attaches proWithTrial (7-day trial, unique_fingerprint: true)
+ * - User cancels immediately
+ * - User re-attaches proWithTrial
+ *
+ * Expected Result:
+ * - First attach: trialing, $0 invoice
+ * - After cancel: no product
+ * - Re-attach: NO duplicate trial, should charge full price immediately
+ *
+ * Note: This tests the `unique_fingerprint` behavior - customer already used trial
+ */
+test(`${chalk.yellowBright("cancel trial immediately: re-attach charges full price (no duplicate trial)")}`, async () => {
+	const customerId = "cancel-trial-imm-reattach";
+
+	const messagesItem = items.monthlyMessages({ includedUsage: 100 });
+
+	const proTrial = products.proWithTrial({
+		id: "pro-trial",
+		items: [messagesItem],
+		trialDays: 7,
+	});
+
+	const { autumnV1 } = await initScenario({
+		customerId,
+		setup: [
+			s.customer({ paymentMethod: "success" }),
+			s.products({ list: [proTrial] }),
+		],
+		actions: [s.attach({ productId: proTrial.id })],
+	});
+
+	// Verify product is trialing
+	const customerAfterAttach =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+
+	await expectProductTrialing({
+		customer: customerAfterAttach,
+		productId: proTrial.id,
+	});
+
+	// Initial invoice should be $0 (trial)
+	expectCustomerInvoiceCorrect({
+		customer: customerAfterAttach,
+		count: 1,
+		latestTotal: 0,
+	});
+
+	// Cancel immediately
+	await autumnV1.subscriptions.update({
+		customer_id: customerId,
+		product_id: proTrial.id,
+		cancel: "immediately",
+	});
+
+	// Verify product is removed
+	const customerAfterCancel =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+
+	await expectProductNotPresent({
+		customer: customerAfterCancel,
+		productId: proTrial.id,
+	});
+
+	// Re-attach the product
+	await autumnV1.attach({
+		customer_id: customerId,
+		product_id: proTrial.id,
+	});
+
+	// Verify product is now ACTIVE (not trialing) - customer already used trial
+	const customerAfterReattach =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+
+	// Should NOT be trialing - should be active
+	const product = customerAfterReattach.products.find(
+		(p) => p.id === proTrial.id,
+	);
+	expect(product).toBeDefined();
+	expect(product?.status).toBe(CusProductStatus.Active);
+
+	// Should have 2 invoices: $0 (trial) + $20 (full price)
+	expectCustomerInvoiceCorrect({
+		customer: customerAfterReattach,
+		count: 2,
+		latestTotal: 20, // Pro base price
+	});
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// TEST 4: Cancel trial immediately with scheduled downgrade - scheduled removed
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Scenario:
+ * - User attaches premiumTrial ($50/mo, 7-day trial)
+ * - User attaches pro ($20/mo) - scheduled for end of trial (downgrade)
+ * - User cancels premium immediately
+ *
+ * Expected Result:
+ * - Premium is removed immediately
+ * - Pro scheduled is also removed (no base product anymore)
+ * - No products attached (unless free default exists)
+ */
+test(`${chalk.yellowBright("cancel trial immediately: with scheduled downgrade, both removed")}`, async () => {
+	const customerId = "cancel-trial-imm-scheduled";
+
+	const messagesItem = items.monthlyMessages({ includedUsage: 100 });
+
+	const premiumTrial = products.premiumWithTrial({
+		id: "premium-trial",
+		items: [messagesItem],
+		trialDays: 7,
+	});
+
+	const pro = products.pro({
+		id: "pro",
+		items: [messagesItem],
+	});
+
+	const { autumnV1, ctx } = await initScenario({
+		customerId,
+		setup: [
+			s.customer({ paymentMethod: "success" }),
+			s.products({ list: [premiumTrial, pro] }),
+		],
+		actions: [s.attach({ productId: premiumTrial.id })],
+	});
+
+	// Verify premium is trialing
+	const customerAfterAttach =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+
+	await expectProductTrialing({
+		customer: customerAfterAttach,
+		productId: premiumTrial.id,
+	});
+
+	// Attach pro (downgrade - scheduled for trial end)
+	await autumnV1.attach({
+		customer_id: customerId,
+		product_id: pro.id,
+	});
+
+	// Verify premium is canceling, pro is scheduled
+	const customerAfterDowngrade =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+
+	await expectCustomerProducts({
+		customer: customerAfterDowngrade,
+		canceling: [premiumTrial.id],
+		scheduled: [pro.id],
+	});
+
+	// Cancel premium immediately
+	await autumnV1.subscriptions.update({
+		customer_id: customerId,
+		product_id: premiumTrial.id,
+		cancel: "immediately",
+	});
+
+	// Verify both products are removed
+	const customerAfterCancel =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+
+	await expectCustomerProducts({
+		customer: customerAfterCancel,
+		notPresent: [premiumTrial.id, pro.id],
+	});
+
+	expect(customerAfterCancel.products.length).toBe(0);
+
+	// Verify no Stripe subscription exists
+	await expectNoStripeSubscription({
+		db: ctx.db,
+		customerId,
+		org: ctx.org,
+		env: ctx.env,
+	});
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// TEST 5: Cancel trial immediately with consumable messages - no overage
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Scenario:
+ * - User attaches proWithTrial with consumable messages
+ * - User tracks 500 messages (400 overage)
+ * - User cancels immediately
+ *
+ * Expected Result:
+ * - Product is removed immediately
+ * - NO overage invoice (usage was free during trial)
+ * - Only the initial $0 trial invoice exists
+ */
+test(`${chalk.yellowBright("cancel trial immediately: with consumable usage, no overage charged")}`, async () => {
+	const customerId = "cancel-trial-imm-consumable";
+
+	const consumableItem = items.consumableMessages({ includedUsage: 100 });
+
+	const proTrial = products.proWithTrial({
+		id: "pro-trial",
+		items: [consumableItem],
+		trialDays: 7,
+	});
+
+	const { autumnV1 } = await initScenario({
+		customerId,
+		setup: [
+			s.customer({ paymentMethod: "success" }),
+			s.products({ list: [proTrial] }),
+		],
+		actions: [s.attach({ productId: proTrial.id })],
+	});
+
+	// Verify product is trialing
+	const customerAfterAttach =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+
+	await expectProductTrialing({
+		customer: customerAfterAttach,
+		productId: proTrial.id,
+	});
+
+	// Track 500 messages (100 included, 400 overage = $40 if billed)
+	await autumnV1.track({
+		customer_id: customerId,
+		feature_id: TestFeature.Messages,
+		value: 500,
+	});
+
+	// Verify usage was tracked
+	const customerAfterTrack =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+	expect(customerAfterTrack.features[TestFeature.Messages].balance).toBe(-400);
+
+	// Cancel immediately
+	await autumnV1.subscriptions.update({
+		customer_id: customerId,
+		product_id: proTrial.id,
+		cancel: "immediately",
+	});
+
+	// Wait for any async processing
+	await new Promise((resolve) => setTimeout(resolve, 2000));
+
+	// Verify product is removed
+	const customerAfterCancel =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+
+	await expectProductNotPresent({
+		customer: customerAfterCancel,
+		productId: proTrial.id,
+	});
+
+	// Should only have the initial $0 trial invoice - NO overage invoice
+	expectCustomerInvoiceCorrect({
+		customer: customerAfterCancel,
+		count: 1,
+		latestTotal: 0,
+	});
+});
diff --git a/server/tests/integration/billing/update-subscription/cancel/cancel-immediately.test.ts b/server/tests/integration/billing/update-subscription/cancel/immediately/cancel-immediately.test.ts
similarity index 100%
rename from server/tests/integration/billing/update-subscription/cancel/cancel-immediately.test.ts
rename to server/tests/integration/billing/update-subscription/cancel/immediately/cancel-immediately.test.ts
diff --git a/server/tests/integration/billing/update-subscription/custom-plan/update-while-trialing.test.ts b/server/tests/integration/billing/update-subscription/custom-plan/update-while-trialing.test.ts
new file mode 100644
index 000000000..a1233b4e2
--- /dev/null
+++ b/server/tests/integration/billing/update-subscription/custom-plan/update-while-trialing.test.ts
@@ -0,0 +1,296 @@
+import { expect, test } from "bun:test";
+import { type ApiCustomerV3, ms } from "@autumn/shared";
+import { expectCustomerFeatureCorrect } from "@tests/integration/billing/utils/expectCustomerFeatureCorrect";
+import { expectCustomerInvoiceCorrect } from "@tests/integration/billing/utils/expectCustomerInvoiceCorrect";
+import { expectProductTrialing } from "@tests/integration/billing/utils/expectCustomerProductTrialing";
+import { expectPreviewNextCycleCorrect } from "@tests/integration/billing/utils/expectPreviewNextCycleCorrect";
+import { expectSubToBeCorrect } from "@tests/merged/mergeUtils/expectSubCorrect";
+import { TestFeature } from "@tests/setup/v2Features.js";
+import { items } from "@tests/utils/fixtures/items.js";
+import { products } from "@tests/utils/fixtures/products.js";
+import { initScenario, s } from "@tests/utils/testInitUtils/initScenario.js";
+import chalk from "chalk";
+
+/**
+ * Update While Trialing Tests
+ *
+ * Tests for scenarios where a customer updates their plan while in a trial period,
+ * adding new item types (consumable, allocated, prepaid).
+ */
+
+// 1. Pro with trial -> add consumable messages mid-trial
+test.concurrent(`${chalk.yellowBright("trial-update: add consumable messages while trialing")}`, async () => {
+	const messagesItem = items.monthlyMessages({ includedUsage: 100 });
+
+	const proTrial = products.proWithTrial({
+		items: [messagesItem],
+		id: "pro-trial",
+		trialDays: 14,
+	});
+
+	const { customerId, autumnV1, ctx, advancedTo } = await initScenario({
+		customerId: "trial-update-consumable",
+		setup: [
+			s.customer({ testClock: true, paymentMethod: "success" }),
+			s.products({ list: [proTrial] }),
+		],
+		actions: [s.attach({ productId: proTrial.id })],
+	});
+
+	// Verify initially trialing
+	const customerBefore =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+	await expectProductTrialing({
+		customer: customerBefore,
+		productId: proTrial.id,
+	});
+
+	// Add consumable messages to the plan while trialing
+	const consumableMessagesItem = items.consumableMessages({
+		includedUsage: 50,
+	});
+	const priceItem = items.monthlyPrice();
+
+	const updateParams = {
+		customer_id: customerId,
+		product_id: proTrial.id,
+		items: [consumableMessagesItem, priceItem],
+	};
+
+	const preview = await autumnV1.subscriptions.previewUpdate(updateParams);
+
+	// Should be 0 during trial (consumable doesn't charge upfront)
+	expect(preview.total).toEqual(0);
+
+	// next_cycle should align with existing trial (~9 days remaining from 14-day trial after 5 days advanced)
+	expectPreviewNextCycleCorrect({
+		preview,
+		startsAt: advancedTo + ms.days(14),
+		total: priceItem.price!,
+	});
+
+	await autumnV1.subscriptions.update(updateParams);
+
+	const customer = await autumnV1.customers.get<ApiCustomerV3>(customerId);
+
+	// Trial should be preserved
+	await expectProductTrialing({
+		customer,
+		productId: proTrial.id,
+	});
+
+	// Original messages feature should be unchanged
+	expectCustomerFeatureCorrect({
+		customer,
+		featureId: TestFeature.Messages,
+		includedUsage: consumableMessagesItem.included_usage,
+		balance: consumableMessagesItem.included_usage,
+		usage: 0,
+	});
+
+	// No charge during trial
+	expectCustomerInvoiceCorrect({
+		customer,
+		count: 1, // Just the $0 trial invoice
+		latestTotal: 0,
+	});
+
+	await expectSubToBeCorrect({
+		db: ctx.db,
+		customerId,
+		org: ctx.org,
+		env: ctx.env,
+	});
+});
+
+// 2. Free -> add allocated users while trialing
+test.concurrent(`${chalk.yellowBright("trial-update: free to allocated users while trialing")}`, async () => {
+	const usersItem = items.monthlyUsers({ includedUsage: 5 });
+	const monthlyPriceItem = items.monthlyPrice();
+
+	const proTrial = products.base({
+		items: [usersItem, monthlyPriceItem],
+		id: "free-trial",
+		trialDays: 14,
+	});
+
+	const { customerId, autumnV1, ctx, advancedTo } = await initScenario({
+		customerId: "trial-update-allocated",
+		setup: [
+			s.customer({ testClock: true, paymentMethod: "success" }),
+			s.products({ list: [proTrial] }),
+		],
+		actions: [
+			s.attach({ productId: proTrial.id }),
+			s.advanceTestClock({ days: 3 }),
+		],
+	});
+
+	// Track some users before update
+	const usersUsage = 3;
+	await autumnV1.track(
+		{
+			customer_id: customerId,
+			feature_id: TestFeature.Users,
+			value: usersUsage,
+		},
+		{ timeout: 2000 },
+	);
+
+	// Verify initially trialing
+	const customerBefore =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+	await expectProductTrialing({
+		customer: customerBefore,
+		productId: proTrial.id,
+	});
+
+	// Update to add allocated users (prorated seats) and a price
+	const allocatedUsersItem = items.allocatedUsers({ includedUsage: 0 });
+
+	const updateParams = {
+		customer_id: customerId,
+		product_id: proTrial.id,
+		items: [allocatedUsersItem, monthlyPriceItem],
+	};
+
+	const preview = await autumnV1.subscriptions.previewUpdate(updateParams);
+
+	// Should be 0 during trial
+	expect(preview.total).toEqual(0);
+
+	// next_cycle should align with existing trial (~11 days remaining)
+	expectPreviewNextCycleCorrect({
+		preview,
+		startsAt: advancedTo + ms.days(11),
+		total: monthlyPriceItem.price! + 30, // base price + 3 allocated users * $10
+	});
+
+	await autumnV1.subscriptions.update(updateParams, {
+		timeout: 2000,
+	});
+
+	const customer = await autumnV1.customers.get<ApiCustomerV3>(customerId);
+
+	// Trial should be preserved
+	await expectProductTrialing({
+		customer,
+		productId: proTrial.id,
+	});
+
+	// Users feature should reflect the allocated seats
+	// Balance = included (2) + quantity (5) - usage (3) = 4
+	expectCustomerFeatureCorrect({
+		customer,
+		featureId: TestFeature.Users,
+		includedUsage: allocatedUsersItem.included_usage,
+		balance: -usersUsage,
+		usage: usersUsage,
+	});
+
+	// No charge during trial
+	expectCustomerInvoiceCorrect({
+		customer,
+		count: 1, // Just the $0 trial invoice
+		latestTotal: 0,
+	});
+
+	await expectSubToBeCorrect({
+		db: ctx.db,
+		customerId,
+		org: ctx.org,
+		env: ctx.env,
+	});
+});
+
+// 3. Pro with trial -> add prepaid messages mid-trial
+test.concurrent(`${chalk.yellowBright("trial-update: add prepaid messages while trialing")}`, async () => {
+	const messagesItem = items.monthlyMessages({ includedUsage: 100 });
+
+	const proTrial = products.proWithTrial({
+		items: [messagesItem],
+		id: "pro-trial",
+		trialDays: 14,
+	});
+
+	const { customerId, autumnV1, ctx, advancedTo } = await initScenario({
+		customerId: "trial-update-prepaid",
+		setup: [
+			s.customer({ testClock: true, paymentMethod: "success" }),
+			s.products({ list: [proTrial] }),
+		],
+		actions: [
+			s.attach({ productId: proTrial.id }),
+			s.advanceTestClock({ days: 7 }),
+		],
+	});
+
+	// Verify initially trialing
+	const customerBefore =
+		await autumnV1.customers.get<ApiCustomerV3>(customerId);
+	await expectProductTrialing({
+		customer: customerBefore,
+		productId: proTrial.id,
+	});
+
+	// Add prepaid messages (purchase units upfront)
+	const prepaidMessagesItem = items.prepaidMessages({
+		includedUsage: 0,
+		billingUnits: 100,
+		price: 10,
+	});
+	const priceItem = items.monthlyPrice();
+
+	const updateParams = {
+		customer_id: customerId,
+		product_id: proTrial.id,
+		items: [prepaidMessagesItem, priceItem],
+		options: [{ feature_id: TestFeature.Messages, quantity: 200 }], // Purchase 200 units (2 packs)
+	};
+
+	const preview = await autumnV1.subscriptions.previewUpdate(updateParams);
+
+	// Prepaid should charge upfront even during trial: 2 packs * $10 = $20
+	expect(preview.total).toEqual(0);
+
+	// next_cycle should align with existing trial (~7 days remaining)
+	expectPreviewNextCycleCorrect({
+		preview,
+		startsAt: advancedTo + ms.days(7),
+		total: priceItem.price! + 20, // base price + prepaid renewal
+	});
+
+	await autumnV1.subscriptions.update(updateParams, { timeout: 2000 });
+
+	const customer = await autumnV1.customers.get<ApiCustomerV3>(customerId);
+
+	// Trial should be preserved
+	await expectProductTrialing({
+		customer,
+		productId: proTrial.id,
+	});
+
+	// Messages feature should have original included usage + prepaid quantity
+	// Balance = included (100) + prepaid (200) = 300
+	expectCustomerFeatureCorrect({
+		customer,
+		featureId: TestFeature.Messages,
+		includedUsage: 200,
+		balance: 200,
+		usage: 0,
+	});
+
+	// Invoice should have the prepaid charge
+	expectCustomerInvoiceCorrect({
+		customer,
+		count: 2, // $0 trial invoice + $20 prepaid charge
+		latestTotal: 0,
+	});
+
+	await expectSubToBeCorrect({
+		db: ctx.db,
+		customerId,
+		org: ctx.org,
+		env: ctx.env,
+	});
+});
diff --git a/server/tests/integration/billing/update-subscription/errors/cancel-errors.test.ts b/server/tests/integration/billing/update-subscription/errors/cancel-errors.test.ts
index 5a86dfcaf..2b6d2ced2 100644
--- a/server/tests/integration/billing/update-subscription/errors/cancel-errors.test.ts
+++ b/server/tests/integration/billing/update-subscription/errors/cancel-errors.test.ts
@@ -5,7 +5,7 @@
  */
 
 import { expect, test } from "bun:test";
-import { type ApiCustomerV3, ErrCode } from "@autumn/shared";
+import { type ApiCustomerV3, ErrCode, FreeTrialDuration } from "@autumn/shared";
 import {
 	expectProductCanceling,
 	expectProductNotPresent,
@@ -283,3 +283,137 @@ test.concurrent(`${chalk.yellowBright("error: cancel immediately with items")}`,
 		},
 	});
 });
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// TEST 6: Cannot cancel free product with end_of_cycle
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Scenario:
+ * - User has a free product (no subscription)
+ * - User tries to cancel with end_of_cycle
+ *
+ * Expected Result:
+ * - Should return an error - free products can only be canceled immediately
+ */
+test.concurrent(`${chalk.yellowBright("error: cannot cancel free product with end_of_cycle")}`, async () => {
+	const customerId = "err-cancel-free-eoc";
+
+	const messagesItem = items.monthlyMessages({ includedUsage: 100 });
+
+	const free = products.base({
+		id: "free",
+		items: [messagesItem],
+		isDefault: true,
+	});
+
+	const { autumnV1 } = await initScenario({
+		customerId,
+		setup: [s.customer({}), s.products({ list: [free] })],
+		actions: [s.attach({ productId: free.id })],
+	});
+
+	// Try to cancel free product with end_of_cycle - should fail
+	await expectAutumnError({
+		func: async () => {
+			await autumnV1.subscriptions.update({
+				customer_id: customerId,
+				product_id: free.id,
+				cancel: "end_of_cycle",
+			});
+		},
+	});
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// TEST 7: Cannot cancel one-time product with end_of_cycle
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Scenario:
+ * - User has a one-time product (no recurring subscription)
+ * - User tries to cancel with end_of_cycle
+ *
+ * Expected Result:
+ * - Should return an error - one-time products can only be canceled immediately
+ */
+test.concurrent(`${chalk.yellowBright("error: cannot cancel one-time product with end_of_cycle")}`, async () => {
+	const customerId = "err-cancel-onetime-eoc";
+
+	const messagesItem = items.monthlyMessages({ includedUsage: 100 });
+
+	const oneTime = products.oneOff({
+		id: "onetime",
+		items: [messagesItem],
+	});
+
+	const { autumnV1 } = await initScenario({
+		customerId,
+		setup: [
+			s.customer({ paymentMethod: "success" }),
+			s.products({ list: [oneTime] }),
+		],
+		actions: [s.attach({ productId: oneTime.id })],
+	});
+
+	// Try to cancel one-time product with end_of_cycle - should fail
+	await expectAutumnError({
+		func: async () => {
+			await autumnV1.subscriptions.update({
+				customer_id: customerId,
+				product_id: oneTime.id,
+				cancel: "end_of_cycle",
+			});
+		},
+	});
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// TEST 8: Cannot pass free_trial when cancel is end_of_cycle
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Scenario:
+ * - User is on Pro with trial
+ * - User tries to cancel at end of cycle while also passing free_trial
+ *
+ * Expected Result:
+ * - Should return an error - cannot combine cancel: 'end_of_cycle' with free_trial
+ */
+test.concurrent(`${chalk.yellowBright("error: cannot pass free_trial when cancel is end_of_cycle")}`, async () => {
+	const customerId = "err-cancel-eoc-with-trial";
+
+	const messagesItem = items.monthlyMessages({ includedUsage: 100 });
+
+	const proTrial = products.proWithTrial({
+		id: "pro-trial",
+		items: [messagesItem],
+		trialDays: 7,
+	});
+
+	const { autumnV1 } = await initScenario({
+		customerId,
+		setup: [
+			s.customer({ paymentMethod: "success" }),
+			s.products({ list: [proTrial] }),
+		],
+		actions: [s.attach({ productId: proTrial.id })],
+	});
+
+	// Try to cancel end_of_cycle while also passing free_trial - should fail
+	await expectAutumnError({
+		func: async () => {
+			await autumnV1.subscriptions.update({
+				customer_id: customerId,
+				product_id: proTrial.id,
+				cancel: "end_of_cycle",
+				free_trial: {
+					length: 14,
+					duration: FreeTrialDuration.Day,
+					card_required: true,
+					unique_fingerprint: false,
+				},
+			});
+		},
+	});
+});
diff --git a/server/tests/integration/billing/update-subscription/update-quantity/decrease-quantity.test.ts b/server/tests/integration/billing/update-subscription/update-quantity/decrease-quantity.test.ts
index e08a2c8aa..686d5cda3 100644
--- a/server/tests/integration/billing/update-subscription/update-quantity/decrease-quantity.test.ts
+++ b/server/tests/integration/billing/update-subscription/update-quantity/decrease-quantity.test.ts
@@ -14,72 +14,65 @@ import chalk from "chalk";
  * - Basic single-feature downgrade (20 → 5 units)
  */
 
-test.concurrent(
-	`${chalk.yellowBright("update-quantity: downgrade 20 to 5 units")}`,
-	async () => {
-		const customerId = "dec-qty-basic-downgrade";
-		const billingUnits = 12;
-		const pricePerUnit = 8;
+test.concurrent(`${chalk.yellowBright("update-quantity: downgrade 20 to 5 units")}`, async () => {
+	const customerId = "dec-qty-basic-downgrade";
+	const billingUnits = 12;
+	const pricePerUnit = 8;
 
-		const prepaidItem = items.prepaid({
-			featureId: TestFeature.Messages,
-			billingUnits,
-			price: pricePerUnit,
-		});
+	const prepaidItem = items.prepaid({
+		featureId: TestFeature.Messages,
+		billingUnits,
+		price: pricePerUnit,
+	});
 
-		const product = products.base({
-			id: "prepaid",
-			items: [prepaidItem],
-		});
+	const product = products.base({
+		id: "prepaid",
+		items: [prepaidItem],
+	});
 
-		const { autumnV1 } = await initScenario({
-			customerId,
-			setup: [
-				s.customer({ paymentMethod: "success" }),
-				s.products({ list: [product] }),
-			],
-			actions: [
-				s.attach({
-					productId: product.id,
-					options: [
-						{ feature_id: TestFeature.Messages, quantity: 20 * billingUnits },
-					],
-				}),
-			],
-		});
+	const { autumnV1 } = await initScenario({
+		customerId,
+		setup: [
+			s.customer({ paymentMethod: "success" }),
+			s.products({ list: [product] }),
+		],
+		actions: [
+			s.attach({
+				productId: product.id,
+				options: [
+					{ feature_id: TestFeature.Messages, quantity: 20 * billingUnits },
+				],
+			}),
+		],
+	});
 
-		// Preview the downgrade
-		const preview = await autumnV1.subscriptions.previewUpdate({
-			customer_id: customerId,
-			product_id: product.id,
-			options: [
-				{ feature_id: TestFeature.Messages, quantity: 5 * billingUnits },
-			],
-		});
+	// Preview the downgrade
+	const preview = await autumnV1.subscriptions.previewUpdate({
+		customer_id: customerId,
+		product_id: product.id,
+		options: [{ feature_id: TestFeature.Messages, quantity: 5 * billingUnits }],
+	});
 
-		// Verify preview total matches expected (20 -> 5 = -15 units * $8)
-		expect(preview.total).toBe(-15 * pricePerUnit);
+	// Verify preview total matches expected (20 -> 5 = -15 units * $8)
+	expect(preview.total).toBe(-15 * pricePerUnit);
 
-		// Downgrade from 20 to 5 units
-		await autumnV1.subscriptions.update({
-			customer_id: customerId,
-			product_id: product.id,
-			options: [
-				{ feature_id: TestFeature.Messages, quantity: 5 * billingUnits },
-			],
-		});
+	// Downgrade from 20 to 5 units
+	await autumnV1.subscriptions.update({
+		customer_id: customerId,
+		product_id: product.id,
+		options: [{ feature_id: TestFeature.Messages, quantity: 5 * billingUnits }],
+	});
 
-		const customer = await autumnV1.customers.get<ApiCustomerV3>(customerId);
-		const feature = customer.features?.[TestFeature.Messages];
+	const customer = await autumnV1.customers.get<ApiCustomerV3>(customerId);
+	const feature = customer.features?.[TestFeature.Messages];
 
-		// Should have 60 messages (5 units × 12 billing_units)
-		expect(feature?.balance).toBe(60);
+	// Should have 60 messages (5 units × 12 billing_units)
+	expect(feature?.balance).toBe(60);
 
-		// Expect credit invoice for downgrade (20 -> 5 = -15 units * $8)
-		expectLatestInvoiceCorrect({
-			customer,
-			productId: product.id,
-			amount: -15 * pricePerUnit,
-		});
-	},
-);
+	// Expect credit invoice for downgrade (20 -> 5 = -15 units * $8)
+	expectLatestInvoiceCorrect({
+		customer,
+		productId: product.id,
+		amount: -15 * pricePerUnit,
+	});
+});
diff --git a/server/tests/integration/billing/update-subscription/update-quantity/entitlements-balance.test.ts b/server/tests/integration/billing/update-subscription/update-quantity/entitlements-balance.test.ts
index ec0f91277..953a9104b 100644
--- a/server/tests/integration/billing/update-subscription/update-quantity/entitlements-balance.test.ts
+++ b/server/tests/integration/billing/update-subscription/update-quantity/entitlements-balance.test.ts
@@ -18,150 +18,144 @@ const billingUnits = 12;
  * balance increment/decrement logic works correctly.
  */
 
-test.concurrent(
-	`${chalk.yellowBright("update-quantity: increment entitlement balance on upgrade")}`,
-	async () => {
-		const customerId = "ent-balance-upgrade";
+test.concurrent(`${chalk.yellowBright("update-quantity: increment entitlement balance on upgrade")}`, async () => {
+	const customerId = "ent-balance-upgrade";
 
-		const product = products.base({
-			id: "prepaid",
-			items: [
-				items.prepaid({
-					featureId: TestFeature.Messages,
-					billingUnits,
-				}),
-			],
-		});
+	const product = products.base({
+		id: "prepaid",
+		items: [
+			items.prepaid({
+				featureId: TestFeature.Messages,
+				billingUnits,
+			}),
+		],
+	});
 
-		const { autumnV1 } = await initScenario({
-			customerId,
-			setup: [
-				s.customer({ paymentMethod: "success" }),
-				s.products({ list: [product] }),
-			],
-			actions: [
-				s.attach({
-					productId: product.id,
-					options: [
-						{ feature_id: TestFeature.Messages, quantity: 10 * billingUnits },
-					],
-				}),
-			],
-		});
+	const { autumnV1 } = await initScenario({
+		customerId,
+		setup: [
+			s.customer({ paymentMethod: "success" }),
+			s.products({ list: [product] }),
+		],
+		actions: [
+			s.attach({
+				productId: product.id,
+				options: [
+					{ feature_id: TestFeature.Messages, quantity: 10 * billingUnits },
+				],
+			}),
+		],
+	});
 
-		const beforeUpdate = await CusService.getFull({
-			db: ctx.db,
-			idOrInternalId: customerId,
-			orgId: ctx.org.id,
-			env: ctx.env,
-		});
+	const beforeUpdate = await CusService.getFull({
+		db: ctx.db,
+		idOrInternalId: customerId,
+		orgId: ctx.org.id,
+		env: ctx.env,
+	});
 
-		const customerProduct = beforeUpdate.customer_products.find(
-			(cp) => cp.product.id === product.id,
-		);
-		const beforeEntitlement = customerProduct?.customer_entitlements.find(
-			(ent) => ent.entitlement.feature_id === TestFeature.Messages,
-		);
-		const beforeBalance = beforeEntitlement?.balance || 0;
+	const customerProduct = beforeUpdate.customer_products.find(
+		(cp) => cp.product.id === product.id,
+	);
+	const beforeEntitlement = customerProduct?.customer_entitlements.find(
+		(ent) => ent.entitlement.feature_id === TestFeature.Messages,
+	);
+	const beforeBalance = beforeEntitlement?.balance || 0;
 
-		await autumnV1.subscriptions.update({
-			customer_id: customerId,
-			product_id: product.id,
-			options: [
-				{ feature_id: TestFeature.Messages, quantity: 15 * billingUnits },
-			],
-		});
+	await autumnV1.subscriptions.update({
+		customer_id: customerId,
+		product_id: product.id,
+		options: [
+			{ feature_id: TestFeature.Messages, quantity: 15 * billingUnits },
+		],
+	});
 
-		const afterUpdate = await CusService.getFull({
-			db: ctx.db,
-			idOrInternalId: customerId,
-			orgId: ctx.org.id,
-			env: ctx.env,
-		});
+	const afterUpdate = await CusService.getFull({
+		db: ctx.db,
+		idOrInternalId: customerId,
+		orgId: ctx.org.id,
+		env: ctx.env,
+	});
 
-		const afterCustomerProduct = afterUpdate.customer_products.find(
-			(cp) => cp.product.id === product.id,
-		);
-		const afterEntitlement = afterCustomerProduct?.customer_entitlements.find(
-			(ent) => ent.entitlement.feature_id === TestFeature.Messages,
-		);
-		const afterBalance = afterEntitlement?.balance || 0;
+	const afterCustomerProduct = afterUpdate.customer_products.find(
+		(cp) => cp.product.id === product.id,
+	);
+	const afterEntitlement = afterCustomerProduct?.customer_entitlements.find(
+		(ent) => ent.entitlement.feature_id === TestFeature.Messages,
+	);
+	const afterBalance = afterEntitlement?.balance || 0;
 
-		// +5 units × 12 billing_units = +60 messages
-		expect(afterBalance).toBe(beforeBalance + 60);
-	},
-);
+	// +5 units × 12 billing_units = +60 messages
+	expect(afterBalance).toBe(beforeBalance + 60);
+});
 
-test.concurrent(
-	`${chalk.yellowBright("update-quantity: decrement entitlement balance on downgrade")}`,
-	async () => {
-		const customerId = "ent-balance-downgrade";
+test.concurrent(`${chalk.yellowBright("update-quantity: decrement entitlement balance on downgrade")}`, async () => {
+	const customerId = "ent-balance-downgrade";
 
-		const product = products.base({
-			id: "prepaid",
-			items: [
-				items.prepaid({
-					featureId: TestFeature.Messages,
-					billingUnits,
-				}),
-			],
-		});
+	const product = products.base({
+		id: "prepaid",
+		items: [
+			items.prepaid({
+				featureId: TestFeature.Messages,
+				billingUnits,
+			}),
+		],
+	});
 
-		const { autumnV1 } = await initScenario({
-			customerId,
-			setup: [
-				s.customer({ paymentMethod: "success" }),
-				s.products({ list: [product] }),
-			],
-			actions: [
-				s.attach({
-					productId: product.id,
-					options: [
-						{ feature_id: TestFeature.Messages, quantity: 15 * billingUnits },
-					],
-				}),
-			],
-		});
+	const { autumnV1 } = await initScenario({
+		customerId,
+		setup: [
+			s.customer({ paymentMethod: "success" }),
+			s.products({ list: [product] }),
+		],
+		actions: [
+			s.attach({
+				productId: product.id,
+				options: [
+					{ feature_id: TestFeature.Messages, quantity: 15 * billingUnits },
+				],
+			}),
+		],
+	});
 
-		const beforeUpdate = await CusService.getFull({
-			db: ctx.db,
-			idOrInternalId: customerId,
-			orgId: ctx.org.id,
-			env: ctx.env,
-		});
+	const beforeUpdate = await CusService.getFull({
+		db: ctx.db,
+		idOrInternalId: customerId,
+		orgId: ctx.org.id,
+		env: ctx.env,
+	});
 
-		const customerProduct = beforeUpdate.customer_products.find(
-			(cp) => cp.product.id === product.id,
-		);
-		const beforeEntitlement = customerProduct?.customer_entitlements.find(
-			(ent) => ent.entitlement.feature_id === TestFeature.Messages,
-		);
-		const beforeBalance = beforeEntitlement?.balance || 0;
+	const customerProduct = beforeUpdate.customer_products.find(
+		(cp) => cp.product.id === product.id,
+	);
+	const beforeEntitlement = customerProduct?.customer_entitlements.find(
+		(ent) => ent.entitlement.feature_id === TestFeature.Messages,
+	);
+	const beforeBalance = beforeEntitlement?.balance || 0;
 
-		await autumnV1.subscriptions.update({
-			customer_id: customerId,
-			product_id: product.id,
-			options: [
-				{ feature_id: TestFeature.Messages, quantity: 10 * billingUnits },
-			],
-		});
+	await autumnV1.subscriptions.update({
+		customer_id: customerId,
+		product_id: product.id,
+		options: [
+			{ feature_id: TestFeature.Messages, quantity: 10 * billingUnits },
+		],
+	});
 
-		const afterUpdate = await CusService.getFull({
-			db: ctx.db,
-			idOrInternalId: customerId,
-			orgId: ctx.org.id,
-			env: ctx.env,
-		});
+	const afterUpdate = await CusService.getFull({
+		db: ctx.db,
+		idOrInternalId: customerId,
+		orgId: ctx.org.id,
+		env: ctx.env,
+	});
 
-		const afterCustomerProduct = afterUpdate.customer_products.find(
-			(cp) => cp.product.id === product.id,
-		);
-		const afterEntitlement = afterCustomerProduct?.customer_entitlements.find(
-			(ent) => ent.entitlement.feature_id === TestFeature.Messages,
-		);
-		const afterBalance = afterEntitlement?.balance || 0;
+	const afterCustomerProduct = afterUpdate.customer_products.find(
+		(cp) => cp.product.id === product.id,
+	);
+	const afterEntitlement = afterCustomerProduct?.customer_entitlements.find(
+		(ent) => ent.entitlement.feature_id === TestFeature.Messages,
+	);
+	const afterBalance = afterEntitlement?.balance || 0;
 
-		// -5 units × 12 billing_units = -60 messages
-		expect(afterBalance).toBe(beforeBalance - 60);
-	},
-);
+	// -5 units × 12 billing_units = -60 messages
+	expect(afterBalance).toBe(beforeBalance - 60);
+});
diff --git a/server/tests/integration/billing/utils/stripe/getSubscriptionId.ts b/server/tests/integration/billing/utils/stripe/getSubscriptionId.ts
new file mode 100644
index 000000000..f76b17b31
--- /dev/null
+++ b/server/tests/integration/billing/utils/stripe/getSubscriptionId.ts
@@ -0,0 +1,66 @@
+import type { AutumnContext } from "@/honoUtils/HonoEnv";
+import { CusService } from "@/internal/customers/CusService";
+
+/**
+ * Helper to get subscription ID for a customer product.
+ */
+export const getSubscriptionId = async ({
+	ctx,
+	customerId,
+	productId,
+}: {
+	ctx: AutumnContext;
+	customerId: string;
+	productId: string;
+}): Promise<string> => {
+	const fullCustomer = await CusService.getFull({
+		db: ctx.db,
+		idOrInternalId: customerId,
+		orgId: ctx.org.id,
+		env: ctx.env,
+	});
+
+	const customerProduct = fullCustomer.customer_products.find(
+		(cp) => cp.product.id === productId,
+	);
+
+	if (!customerProduct?.subscription_ids?.length) {
+		throw new Error(`No subscription found for product ${productId}`);
+	}
+
+	return customerProduct.subscription_ids[0];
+};
+
+/**
+ * Helper to get subscription ID for an entity's customer product.
+ */
+export const getEntitySubscriptionId = async ({
+	ctx,
+	customerId,
+	entityId,
+	productId,
+}: {
+	ctx: AutumnContext;
+	customerId: string;
+	entityId: string;
+	productId: string;
+}): Promise<string> => {
+	const fullCustomer = await CusService.getFull({
+		db: ctx.db,
+		idOrInternalId: customerId,
+		orgId: ctx.org.id,
+		env: ctx.env,
+	});
+
+	const customerProduct = fullCustomer.customer_products.find(
+		(cp) => cp.product.id === productId && cp.entity_id === entityId,
+	);
+
+	if (!customerProduct?.subscription_ids?.length) {
+		throw new Error(
+			`No subscription found for product ${productId} on entity ${entityId}`,
+		);
+	}
+
+	return customerProduct.subscription_ids[0];
+};
diff --git a/server/tests/merged/addOn/mergedAddOn3.test.ts b/server/tests/merged/addOn/mergedAddOn3.test.ts
deleted file mode 100644
index 83dc40c77..000000000
--- a/server/tests/merged/addOn/mergedAddOn3.test.ts
+++ /dev/null
@@ -1,195 +0,0 @@
-import { beforeAll, describe, expect, test } from "bun:test";
-import {
-	type AppEnv,
-	CusProductStatus,
-	LegacyVersion,
-	type Organization,
-} from "@autumn/shared";
-import { TestFeature } from "@tests/setup/v2Features.js";
-import { attachAndExpectCorrect } from "@tests/utils/expectUtils/expectAttach.js";
-import { expectProductAttached } from "@tests/utils/expectUtils/expectProductAttached.js";
-import ctx from "@tests/utils/testInitUtils/createTestContext.js";
-import chalk from "chalk";
-import type { Stripe } from "stripe";
-
-import type { DrizzleCli } from "@/db/initDrizzle.js";
-import { AutumnInt } from "@/external/autumn/autumnCli.js";
-import {
-	constructFeatureItem,
-	constructPrepaidItem,
-} from "@/utils/scriptUtils/constructItem.js";
-import {
-	constructProduct,
-	constructRawProduct,
-} from "@/utils/scriptUtils/createTestProducts.js";
-import { initCustomerV3 } from "@/utils/scriptUtils/testUtils/initCustomerV3.js";
-import { initProductsV0 } from "@/utils/scriptUtils/testUtils/initProductsV0.js";
-import { expectSubToBeCorrect } from "../mergeUtils/expectSubCorrect.js";
-
-const pro = constructProduct({
-	id: "pro",
-	items: [constructFeatureItem({ featureId: TestFeature.Credits })],
-	type: "pro",
-});
-
-const billingUnits = 100;
-const addOn = constructRawProduct({
-	id: "addOn",
-	items: [
-		constructPrepaidItem({
-			featureId: TestFeature.Credits,
-			billingUnits,
-			price: 10,
-		}),
-	],
-	isAddOn: true,
-});
-
-const ops = [
-	{
-		entityId: "1",
-		product: pro,
-		results: [{ product: pro, status: CusProductStatus.Active }],
-	},
-	// {
-	//   entityId: "2",
-	//   product: pro,
-	//   results: [{ product: pro, status: CusProductStatus.Active }],
-	// },
-	{
-		entityId: "1",
-		product: addOn,
-		results: [
-			{ product: pro, status: CusProductStatus.Active },
-			{ product: addOn, status: CusProductStatus.Active },
-		],
-		options: [
-			{
-				feature_id: TestFeature.Credits,
-				quantity: billingUnits * 3,
-			},
-		],
-		otherProducts: [pro],
-	},
-
-	// {
-	//   entityId: "2",
-	//   product: addOn,
-	//   results: [
-	//     { product: pro, status: CusProductStatus.Active },
-	//     { product: addOn, status: CusProductStatus.Active },
-	//   ],
-	//   options: [
-	//     {
-	//       feature_id: TestFeature.Credits,
-	//       quantity: billingUnits * 5,
-	//     },
-	//   ],
-	//   otherProducts: [pro],
-	// },
-];
-
-const testCase = "mergedAddOn3";
-describe(`${chalk.yellowBright("mergedAddOn3: testing add ons between multiple entities")}`, () => {
-	const customerId = testCase;
-	const autumn: AutumnInt = new AutumnInt({ version: LegacyVersion.v1_4 });
-
-	let stripeCli: Stripe;
-	let testClockId: string;
-	let curUnix: number;
-	let db: DrizzleCli;
-	let org: Organization;
-	let env: AppEnv;
-
-	beforeAll(async () => {
-		await initProductsV0({
-			ctx,
-			products: [pro, addOn],
-			prefix: testCase,
-			customerId,
-		});
-
-		const res = await initCustomerV3({
-			ctx,
-			customerId,
-			attachPm: "success",
-			withTestClock: true,
-		});
-
-		stripeCli = ctx.stripeCli;
-		db = ctx.db;
-		org = ctx.org;
-		env = ctx.env;
-		testClockId = res.testClockId!;
-	});
-
-	const entities = [
-		{
-			id: "1",
-			name: "Entity 1",
-			feature_id: TestFeature.Users,
-		},
-		{
-			id: "2",
-			name: "Entity 2",
-			feature_id: TestFeature.Users,
-		},
-	];
-
-	test("should run operations", async () => {
-		await autumn.entities.create(customerId, entities);
-
-		for (let index = 0; index < ops.length; index++) {
-			const op = ops[index];
-			await attachAndExpectCorrect({
-				autumn,
-				customerId,
-				product: op.product,
-				stripeCli,
-				db,
-				org,
-				env,
-				entities,
-				options: op.options,
-				otherProducts: op.otherProducts,
-				entityId: op.entityId,
-			});
-
-			for (const result of op.results) {
-				// const entity = await autumn.entities.get(customerId, op.entityId);
-				const cus = await autumn.customers.get(customerId);
-				expectProductAttached({
-					customer: cus,
-					product: result.product,
-					status: result.status,
-				});
-			}
-		}
-	});
-
-	test("should cancel add on product immediately", async () => {
-		await autumn.cancel({
-			customer_id: customerId,
-			product_id: addOn.id,
-			entity_id: "1",
-			cancel_immediately: true,
-		});
-
-		const customer = await autumn.customers.get(customerId);
-		expectProductAttached({
-			customer,
-			product: pro,
-			status: CusProductStatus.Active,
-		});
-
-		const products = customer.products.filter((p) => p.group === addOn.group);
-		expect(products.length).toBe(1);
-
-		await expectSubToBeCorrect({
-			customerId,
-			db,
-			org,
-			env,
-		});
-	});
-});
diff --git a/server/tests/merged/addOn/mergedAddOn4.test.ts b/server/tests/merged/addOn/mergedAddOn4.test.ts
deleted file mode 100644
index 8ed0a58f0..000000000
--- a/server/tests/merged/addOn/mergedAddOn4.test.ts
+++ /dev/null
@@ -1,196 +0,0 @@
-import { beforeAll, describe, expect, test } from "bun:test";
-import {
-	type AppEnv,
-	CusProductStatus,
-	LegacyVersion,
-	type Organization,
-} from "@autumn/shared";
-import { TestFeature } from "@tests/setup/v2Features.js";
-import { attachAndExpectCorrect } from "@tests/utils/expectUtils/expectAttach.js";
-import { expectProductAttached } from "@tests/utils/expectUtils/expectProductAttached.js";
-import ctx from "@tests/utils/testInitUtils/createTestContext.js";
-import chalk from "chalk";
-import type { Stripe } from "stripe";
-
-import type { DrizzleCli } from "@/db/initDrizzle.js";
-import { AutumnInt } from "@/external/autumn/autumnCli.js";
-import {
-	constructFeatureItem,
-	constructPrepaidItem,
-} from "@/utils/scriptUtils/constructItem.js";
-import {
-	constructProduct,
-	constructRawProduct,
-} from "@/utils/scriptUtils/createTestProducts.js";
-import { initCustomerV3 } from "@/utils/scriptUtils/testUtils/initCustomerV3.js";
-import { initProductsV0 } from "@/utils/scriptUtils/testUtils/initProductsV0.js";
-import { expectSubToBeCorrect } from "../mergeUtils/expectSubCorrect.js";
-
-const premium = constructProduct({
-	id: "premium",
-	items: [constructFeatureItem({ featureId: TestFeature.Credits })],
-	type: "premium",
-});
-
-const pro = constructProduct({
-	id: "pro",
-	items: [constructFeatureItem({ featureId: TestFeature.Credits })],
-	type: "pro",
-});
-
-const billingUnits = 100;
-const addOn = constructRawProduct({
-	id: "addOn",
-	items: [
-		constructPrepaidItem({
-			featureId: TestFeature.Credits,
-			billingUnits,
-			price: 10,
-		}),
-	],
-	isAddOn: true,
-});
-
-const ops = [
-	{
-		entityId: "1",
-		product: premium,
-		results: [{ product: premium, status: CusProductStatus.Active }],
-	},
-	{
-		entityId: "1",
-		product: addOn,
-		results: [
-			{ product: premium, status: CusProductStatus.Active },
-			{ product: addOn, status: CusProductStatus.Active },
-		],
-		options: [
-			{
-				feature_id: TestFeature.Credits,
-				quantity: billingUnits * 3,
-			},
-		],
-		otherProducts: [premium],
-	},
-
-	{
-		entityId: "1",
-		product: pro,
-		results: [
-			{ product: premium, status: CusProductStatus.Active },
-			{ product: addOn, status: CusProductStatus.Active },
-			{ product: pro, status: CusProductStatus.Scheduled },
-		],
-		otherProducts: [premium],
-	},
-];
-
-const testCase = "mergedAddOn4";
-describe(`${chalk.yellowBright("mergedAddOn4: testing cancelling add on immediately while there's scheduled product")}`, () => {
-	const customerId = testCase;
-	const autumn: AutumnInt = new AutumnInt({ version: LegacyVersion.v1_4 });
-
-	let stripeCli: Stripe;
-	let testClockId: string;
-	let curUnix: number;
-	let db: DrizzleCli;
-	let org: Organization;
-	let env: AppEnv;
-
-	beforeAll(async () => {
-		await initProductsV0({
-			ctx,
-			products: [pro, addOn, premium],
-			prefix: testCase,
-			customerId,
-		});
-
-		const res = await initCustomerV3({
-			ctx,
-			customerId,
-			attachPm: "success",
-			withTestClock: true,
-		});
-
-		stripeCli = ctx.stripeCli;
-		db = ctx.db;
-		org = ctx.org;
-		env = ctx.env;
-		testClockId = res.testClockId!;
-	});
-
-	const entities = [
-		{
-			id: "1",
-			name: "Entity 1",
-			feature_id: TestFeature.Users,
-		},
-		{
-			id: "2",
-			name: "Entity 2",
-			feature_id: TestFeature.Users,
-		},
-	];
-
-	test("should run operations", async () => {
-		await autumn.entities.create(customerId, entities);
-
-		for (let index = 0; index < ops.length; index++) {
-			const op = ops[index];
-			await attachAndExpectCorrect({
-				autumn,
-				customerId,
-				product: op.product,
-				stripeCli,
-				db,
-				org,
-				env,
-				entities,
-				options: op.options,
-				otherProducts: op.otherProducts,
-				entityId: op.entityId,
-			});
-
-			for (const result of op.results) {
-				// const entity = await autumn.entities.get(customerId, op.entityId);
-				const cus = await autumn.customers.get(customerId);
-				expectProductAttached({
-					customer: cus,
-					product: result.product,
-					status: result.status,
-				});
-			}
-		}
-	});
-
-	test("should cancel add on product immediately", async () => {
-		await autumn.cancel({
-			customer_id: customerId,
-			product_id: addOn.id,
-			entity_id: "1",
-			cancel_immediately: true,
-		});
-
-		const customer = await autumn.customers.get(customerId);
-		expectProductAttached({
-			customer,
-			product: pro,
-			status: CusProductStatus.Scheduled,
-		});
-		expectProductAttached({
-			customer,
-			product: premium,
-			status: CusProductStatus.Active,
-		});
-
-		const products = customer.products.filter((p) => p.group === addOn.group);
-		expect(products.length).toBe(2);
-
-		await expectSubToBeCorrect({
-			customerId,
-			db,
-			org,
-			env,
-		});
-	});
-});
diff --git a/server/tests/merged/addOn/mergedAddOn5.test.ts b/server/tests/merged/addOn/mergedAddOn5.test.ts
deleted file mode 100644
index fbb474709..000000000
--- a/server/tests/merged/addOn/mergedAddOn5.test.ts
+++ /dev/null
@@ -1,219 +0,0 @@
-import { beforeAll, describe, expect, test } from "bun:test";
-import {
-	type AppEnv,
-	CusProductStatus,
-	LegacyVersion,
-	type Organization,
-} from "@autumn/shared";
-import { TestFeature } from "@tests/setup/v2Features.js";
-import { attachAndExpectCorrect } from "@tests/utils/expectUtils/expectAttach.js";
-import { expectProductAttached } from "@tests/utils/expectUtils/expectProductAttached.js";
-import { advanceToNextInvoice } from "@tests/utils/testAttachUtils/testAttachUtils.js";
-import ctx from "@tests/utils/testInitUtils/createTestContext.js";
-import chalk from "chalk";
-import type { Stripe } from "stripe";
-import type { DrizzleCli } from "@/db/initDrizzle.js";
-import { AutumnInt } from "@/external/autumn/autumnCli.js";
-import {
-	constructFeatureItem,
-	constructPrepaidItem,
-} from "@/utils/scriptUtils/constructItem.js";
-import {
-	constructProduct,
-	constructRawProduct,
-} from "@/utils/scriptUtils/createTestProducts.js";
-import { initCustomerV3 } from "@/utils/scriptUtils/testUtils/initCustomerV3.js";
-import { initProductsV0 } from "@/utils/scriptUtils/testUtils/initProductsV0.js";
-import { expectSubToBeCorrect } from "../mergeUtils/expectSubCorrect.js";
-
-const premium = constructProduct({
-	id: "premium",
-	items: [constructFeatureItem({ featureId: TestFeature.Credits })],
-	type: "premium",
-});
-
-const pro = constructProduct({
-	id: "pro",
-	items: [constructFeatureItem({ featureId: TestFeature.Credits })],
-	type: "pro",
-});
-
-const billingUnits = 100;
-const addOn = constructRawProduct({
-	id: "addOn",
-	items: [
-		constructPrepaidItem({
-			featureId: TestFeature.Credits,
-			billingUnits,
-			price: 10,
-		}),
-	],
-	isAddOn: true,
-});
-
-const ops = [
-	{
-		entityId: "1",
-		product: premium,
-		results: [{ product: premium, status: CusProductStatus.Active }],
-	},
-	{
-		entityId: "1",
-		product: addOn,
-		results: [
-			{ product: premium, status: CusProductStatus.Active },
-			{ product: addOn, status: CusProductStatus.Active },
-		],
-		options: [
-			{
-				feature_id: TestFeature.Credits,
-				quantity: billingUnits * 3,
-			},
-		],
-		otherProducts: [premium],
-	},
-
-	{
-		entityId: "1",
-		product: pro,
-		results: [
-			{ product: premium, status: CusProductStatus.Active },
-			{ product: addOn, status: CusProductStatus.Active },
-			{ product: pro, status: CusProductStatus.Scheduled },
-		],
-		otherProducts: [premium],
-	},
-];
-
-const testCase = "mergedAddOn5";
-describe(`${chalk.yellowBright("mergedAddOn5: testing cancelling add on immediately while there's scheduled product")}`, () => {
-	const customerId = testCase;
-	const autumn: AutumnInt = new AutumnInt({ version: LegacyVersion.v1_4 });
-
-	let stripeCli: Stripe;
-	let testClockId: string;
-	let curUnix: number;
-	let db: DrizzleCli;
-	let org: Organization;
-	let env: AppEnv;
-
-	beforeAll(async () => {
-		await initProductsV0({
-			ctx,
-			products: [pro, addOn, premium],
-			prefix: testCase,
-			customerId,
-		});
-
-		const res = await initCustomerV3({
-			ctx,
-			customerId,
-			attachPm: "success",
-			withTestClock: true,
-		});
-
-		stripeCli = ctx.stripeCli;
-		db = ctx.db;
-		org = ctx.org;
-		env = ctx.env;
-		testClockId = res.testClockId!;
-	});
-
-	const entities = [
-		{
-			id: "1",
-			name: "Entity 1",
-			feature_id: TestFeature.Users,
-		},
-		{
-			id: "2",
-			name: "Entity 2",
-			feature_id: TestFeature.Users,
-		},
-	];
-
-	test("should run operations", async () => {
-		await autumn.entities.create(customerId, entities);
-
-		for (let index = 0; index < ops.length; index++) {
-			const op = ops[index];
-			await attachAndExpectCorrect({
-				autumn,
-				customerId,
-				product: op.product,
-				stripeCli,
-				db,
-				org,
-				env,
-				entities,
-				options: op.options,
-				otherProducts: op.otherProducts,
-				entityId: op.entityId,
-			});
-
-			for (const result of op.results) {
-				// const entity = await autumn.entities.get(customerId, op.entityId);
-				const cus = await autumn.customers.get(customerId);
-				expectProductAttached({
-					customer: cus,
-					product: result.product,
-					status: result.status,
-				});
-			}
-		}
-	});
-
-	test("should cancel add on product immediately", async () => {
-		await autumn.cancel({
-			customer_id: customerId,
-			product_id: addOn.id,
-			entity_id: "1",
-			cancel_immediately: true,
-		});
-
-		const customer = await autumn.customers.get(customerId);
-		expectProductAttached({
-			customer,
-			product: pro,
-			status: CusProductStatus.Scheduled,
-		});
-		expectProductAttached({
-			customer,
-			product: premium,
-		});
-
-		const products = customer.products.filter((p) => p.group === addOn.group);
-		expect(products.length).toBe(2);
-
-		await expectSubToBeCorrect({
-			customerId,
-			db,
-			org,
-			env,
-		});
-	});
-
-	test("should advance test clock and have correct products / sub", async () => {
-		await advanceToNextInvoice({
-			stripeCli,
-			testClockId,
-		});
-
-		const customer = await autumn.customers.get(customerId);
-		expectProductAttached({
-			customer,
-			product: pro,
-			status: CusProductStatus.Active,
-		});
-
-		const products = customer.products.filter((p) => p.group === addOn.group);
-		expect(products.length).toBe(1);
-
-		await expectSubToBeCorrect({
-			customerId,
-			db,
-			org,
-			env,
-		});
-	});
-});
diff --git a/server/tests/utils/fixtures/products.ts b/server/tests/utils/fixtures/products.ts
index 051542f5a..807e72955 100644
--- a/server/tests/utils/fixtures/products.ts
+++ b/server/tests/utils/fixtures/products.ts
@@ -130,6 +130,37 @@ const proWithTrial = ({
 		},
 	});
 
+/**
+ * Premium product with free trial - $50/month base price with configurable trial
+ * @param items - Product items (features)
+ * @param id - Product ID (default: "premium-trial")
+ * @param trialDays - Number of trial days (default: 7)
+ * @param cardRequired - Whether card is required for trial (default: true)
+ */
+const premiumWithTrial = ({
+	items,
+	id = "premium-trial",
+	trialDays = 7,
+	cardRequired = true,
+}: {
+	items: ProductItem[];
+	id?: string;
+	trialDays?: number;
+	cardRequired?: boolean;
+}): ProductV2 =>
+	constructProduct({
+		id,
+		items: [...items],
+		type: "premium",
+		isDefault: false,
+		freeTrial: {
+			length: trialDays,
+			duration: FreeTrialDuration.Day,
+			unique_fingerprint: false,
+			card_required: cardRequired,
+		},
+	});
+
 /**
  * Base (free) product with free trial - no base price, with configurable trial
  * @param items - Product items (features)
@@ -238,6 +269,7 @@ export const products = {
 	pro,
 	proAnnual,
 	proWithTrial,
+	premiumWithTrial,
 	oneOff,
 	recurringAddOn,
 } as const;
diff --git a/server/tests/utils/testInitUtils/initScenario.ts b/server/tests/utils/testInitUtils/initScenario.ts
index c3277b50e..8c7cbe01f 100644
--- a/server/tests/utils/testInitUtils/initScenario.ts
+++ b/server/tests/utils/testInitUtils/initScenario.ts
@@ -1,4 +1,4 @@
-import { ApiVersion, type ProductV2 } from "@autumn/shared";
+import { ApiVersion, type ProductItem, type ProductV2 } from "@autumn/shared";
 import type { CustomerData } from "autumn-js";
 import { addHours, addMonths } from "date-fns";
 import { AutumnInt } from "@/external/autumn/autumnCli.js";
@@ -77,6 +77,7 @@ type UpdateSubscriptionAction = {
 	productId: string;
 	entityIndex?: number;
 	cancel?: "end_of_cycle" | "immediately";
+	items?: ProductItem[];
 };
 
 type AdvanceToNextInvoiceAction = {
@@ -409,21 +410,25 @@ const track = ({
 };
 
 /**
- * Update a subscription (e.g., cancel end of cycle).
+ * Update a subscription (e.g., cancel end of cycle, add items).
  * @param productId - The product ID (without prefix)
  * @param entityIndex - Optional entity index (0-based) for entity-level subscription
  * @param cancel - Cancel mode: "end_of_cycle" or "immediately"
+ * @param items - Optional items to add/update on the subscription
  * @example s.updateSubscription({ productId: "pro", cancel: "end_of_cycle" }) // customer-level
  * @example s.updateSubscription({ productId: "pro", entityIndex: 0, cancel: "end_of_cycle" }) // entity-level
+ * @example s.updateSubscription({ productId: "pro", items: [consumableItem] }) // add items
  */
 const updateSubscription = ({
 	productId,
 	entityIndex,
 	cancel,
+	items,
 }: {
 	productId: string;
 	entityIndex?: number;
 	cancel?: "end_of_cycle" | "immediately";
+	items?: ProductItem[];
 }): ConfigFn => {
 	return (config) => ({
 		...config,
@@ -434,6 +439,7 @@ const updateSubscription = ({
 				productId,
 				entityIndex,
 				cancel,
+				items,
 			},
 		],
 	});
@@ -695,7 +701,7 @@ export async function initScenario({
 			customerData: config.customerData,
 			attachPm: config.attachPm,
 			withTestClock: config.testClock,
-			withDefault: config.withDefault,
+			withDefault: config.withDefault ?? false, // RIP
 			// Default group matches the product prefix (customerId) used in initProductsV0
 			defaultGroup: config.defaultGroup ?? customerId,
 			skipWebhooks: config.skipWebhooks,
@@ -895,6 +901,7 @@ export async function initScenario({
 				product_id: prefixedProductId,
 				entity_id: entityId,
 				cancel: action.cancel,
+				items: action.items,
 			});
 		} else if (action.type === "advanceToNextInvoice") {
 			if (!testClockId) {
diff --git a/shared/api/billing/updateSubscription/updateSubscriptionV0Params.ts b/shared/api/billing/updateSubscription/updateSubscriptionV0Params.ts
index f346372f9..ba688609e 100644
--- a/shared/api/billing/updateSubscription/updateSubscriptionV0Params.ts
+++ b/shared/api/billing/updateSubscription/updateSubscriptionV0Params.ts
@@ -83,6 +83,17 @@ export const UpdateSubscriptionV0ParamsSchema =
 				message:
 					"Cannot pass options, items, version, or free_trial when cancel is 'immediately'. Immediate cancellation only processes a prorated refund.",
 			},
+		)
+		.refine(
+			(data) => {
+				if (data.cancel !== "end_of_cycle") return true;
+
+				// Cannot pass free_trial when cancel is 'end_of_cycle'
+				return data.free_trial === undefined;
+			},
+			{
+				message: "Cannot pass free_trial when cancel is 'end_of_cycle'.",
+			},
 		);
 
 export type ExtUpdateSubscriptionV0Params = z.infer<