@ak--47/dungeon-master 1.8.0 → 1.8.1

package/docs/guides/1.8.1-upgrade-guide.md

@@ -0,0 +1,153 @@
+# 1.8.1 Upgrade Guide
+
+1.8.1 repairs funnel counting, lifecycle timing, and emitted identity. Existing
+configurations and call forms remain supported. No property renames or required
+configuration changes are introduced. `applySessionShape` adds optional dataset
+bounds; its existing unbounded calls retain their behavior.
+
+Generated timestamps, identities, and report counts can change from 1.8.0 because
+the previous output contained defects. Recheck saved story expectations rather
+than expecting byte-identical output across versions.
+
+## Update the dependency
+
+After 1.8.1 is published:
+
+```sh
+npm install @ak--47/dungeon-master@1.8.1
+```
+
+No additional runtime dependency is required. The package still requires Node.js
+20.20.0 or newer. This guide does not indicate that npm publication has occurred.
+
+## Funnel counts can change
+
+- An ordered funnel whose first and last steps match now finalizes its conversion
+  correctly. With reentry enabled, the closing event can also start the next
+  attempt. Without reentry, it still completes and does not create another attempt.
+- Ordinary completed histories consume events through the inclusive two-second
+  completion grace period. Those events do not become a second attempt. The
+  existing `graceperiod: false` option disables that wait.
+- Hold-property-constant session windows use session boundaries from the full
+  stream before property filtering. Unrelated activity can keep a session open.
+- First/last-touch segmentation merges properties across reached steps. A missing
+  property on the preferred step can fall back to another reached step. Explicit
+  step selection remains separate.
+
+`countMode: 'totals'` still defaults to `reentry: false`. Specify `reentry: true`
+when repeated histories are intended. This compatibility default differs from
+Mixpanel general totals. Do not change existing report options implicitly when
+comparing old and new results.
+
+## Lifecycle and identity output is corrected
+
+Retention entry follows adjusted creation, retries precede the final onboarding
+attempt, and usage follows onboarding completion. The engine reconciles its own
+identity fields against surviving auth events after filtering. Engine-created
+data-quality duplicates and world-event clones preserve identity provenance.
+
+Explicit hook identity overrides and the synthetic experiment identity exception
+remain supported. A later valid event carrying both IDs can provide identity
+mapping evidence; this is not restricted to the first funnel.
+
+Short windows retain partial output instead of introducing a required exception.
+Inspect the existing `result.warnings` collection for:
+
+| warning key | meaning |
+| --- | --- |
+| `lifecycle.firstFunnelClipped` | Configured timing cannot fit before dataset end; future steps are omitted without compressing TTC. |
+| `lifecycle.emptyPreAuthAttempt` | Auth is the first step, so a failed pre-auth attempt emits no rows. |
+| `lifecycle.strictAttemptBudget` | The strict event budget cannot retain every surviving attempt entry. |
+
+Configured suppression and hook filtering remain authoritative. The engine does
+not recreate intentionally removed events to satisfy an attempt count.
+
+## Bound session reshaping when the dataset end matters
+
+Calls without bounds retain legacy full-UTC-day placement. They cannot infer the
+dataset end from the last observed event and may still move events beyond it.
+Pass known bounds to prevent that clipping:
+
+```js
+import { applySessionShape } from '@ak--47/dungeon-master/hook-helpers';
+
+const hook = (records, type, meta) => {
+  if (type === 'everything') {
+    applySessionShape(records, meta.profile.distinct_id, {
+      sessionsPerWeek: 3,
+      eventsPerSession: 5,
+      sessionMinutes: 10,
+      datasetStart: meta.datasetStart,
+      datasetEnd: meta.datasetEnd,
+    });
+  }
+  return records;
+};
+```
+
+Bounds accept ISO strings, Unix seconds, or Unix milliseconds. Either explicit
+bound enables constrained placement; an omitted side uses the original UTC day
+edge. Invalid bounds or insufficient per-week session capacity throw `RangeError`
+before records are mutated. Two same-day sessions separated by more than thirty
+minutes cannot fit in a twenty-minute interval. Adjust the requested cadence or
+available window rather than swallowing that error.
+
+The helper retimes the same records. It does not add or drop events. Unbounded
+legacy requests remain nonthrowing, including overfull layouts where derived
+sessions can merge.
+
+## Path injection remains append-only
+
+`applyPathBias` selects the earliest chronological anchor and leaves original
+traffic intact. `share: 1` selects all eligible users for injection. Competing
+events can still interrupt the immediate branch, so it does not promise a 100%
+Flows branch share. Recheck the observed branch, not only the injected count.
+
+## Revalidate the story, not just the schema
+
+Run a pinned, seeded representative dungeon with ordinary standalone traffic and
+competing funnels. Compare counts using explicit report settings. For deterministic
+same-version comparisons, use `concurrency: 1` and strip only `insert_id`.
+
+The new alignment checks establish selected source-derived Mixpanel contracts.
+They do not execute Mixpanel's engine. Timezone/DST variants, list-valued HPC,
+project-specific session exclusions, all parameter combinations, and arbitrary
+hooks are not covered by a universal parity claim.
+
+The recorded sweep produced 17.08 million events across 594 dungeons within ten
+minutes. Its largest single dungeon had 281,751 events. Of 297 cells, 125 met their
+evidence criteria and 172 had insufficient eligible populations. Increasing total
+events is not a substitute for enough eligible users or converters.
+
+## Repository test workflows
+
+These commands require a repository checkout with development dependencies.
+The npm package ships this guide, but does not ship the test suites.
+
+```sh
+node tests/alignment/run.mjs
+node tests/alignment/run.mjs --sweep --timeout-ms=600000
+```
+
+Both commands use macOS OS-level network denial and a hard maximum of ten minutes.
+They fail closed on unsupported platforms. The editor's Testing panel is a separate
+workflow: one serial editor config discovers unit, integration, E2E, and alignment
+tests without global pruning. Direct-run engine scripts have opt-in tasks; their
+full-sweep E2E wrapper is visible but skipped by default. Editor runs do not provide
+an OS network sandbox. Use the named offline test tasks when network denial is
+required, especially for E2E tests that can perform external operations.
+
+`npm test` retains the default unit/integration/E2E suite and excludes alignment.
+Its global setup prunes local `data` and `tmp`; preserve artifacts before using it.
+The explicit `prune` task and default dungeon-run task retain their existing cleanup
+behavior. None of the new offline test tasks depend on them.
+
+## Before publishing
+
+Confirm package version and changelog are 1.8.1. Inspect `npm pack --dry-run --json`
+and rerun the relevant release checks. Publishing to npm is a separate operator
+action; neither test execution nor a Git commit publishes the package.
+
+See the [changelog](../../CHANGELOG.md), [hook reference](../../HOOKS.md), and
+[1.8.0 guide](1.8.0-upgrade-guide.md) for the unchanged standalone and warehouse
+metric APIs.

package/lib/generators/events.js

@@ -17,6 +17,8 @@ import { dataLogger as logger } from "../utils/logger.js";
 // Keys that must never be nulled by data quality gremlins
 const NULL_EXEMPT_KEYS = new Set(['event', 'time', 'insert_id', 'user_id', 'device_id', 'distinct_id', '_drop', '_anomaly', '_persona']);
 
+export const engineIdentity = Symbol('engineIdentity');
+
 
 /**
  * Creates a Mixpanel event with a flat shape
@@ -293,6 +295,9 @@ export async function makeEvent(
 
 	eventTemplate.insert_id = randomUUID();
 
+    const originalIdentity = { user_id: eventTemplate.user_id, device_id: eventTemplate.device_id };
+    Object.defineProperty(eventTemplate, engineIdentity, { value: originalIdentity, configurable: true });
+
     // Call hook if configured (hooks override everything — they are the final authority)
     const { hook } = config;
     if (hook) {
@@ -305,6 +310,7 @@ export async function makeEvent(
         });
         // If hook returns a modified event, use it; otherwise use original
         if (hookedEvent && typeof hookedEvent === 'object') {
+            Object.defineProperty(hookedEvent, engineIdentity, { value: originalIdentity, configurable: true });
             return hookedEvent;
         }
     }

package/lib/generators/funnels.js

@@ -331,6 +331,21 @@ export async function makeFunnel(context, funnel, user, firstEventTime, profile
 		dataQuality: featureCtx.dataQuality || context.config.dataQuality || null,
 		latestTime: Number.isFinite(featureCtx.latestTime) ? featureCtx.latestTime : undefined,
 	};
+	if (attemptInfo.isFirstFunnel && attemptInfo.isBorn && funnelEventsWithTiming.length) {
+		const spanMs = Math.max(0, ...funnelEventsWithTiming.map(event => event.relativeTimeMs || 0));
+		const latestStart = Math.min(funnelFeatureCtx.latestTime ?? context.FIXED_NOW, context.FIXED_NOW - spanMs / 1000);
+		if (firstEventTime > latestStart) {
+			context.addWarning({
+				key: 'lifecycle.firstFunnelClipped',
+				requested: spanMs,
+				applied: Math.max(0, (context.FIXED_NOW - firstEventTime) * 1000),
+				reason: 'First-funnel timing exceeds the remaining dataset window; emit the in-window prefix and omit future steps without compressing configured TTC.',
+				severity: 'warn',
+			});
+		}
+		funnelFeatureCtx.latestTime = Math.max(firstEventTime, latestStart);
+		if (featureCtx.pinFirstTime) funnelFeatureCtx.fixedTimeMs = firstEventTime * 1000;
+	}
 
 	// Pre-compute per-step stamping modes for execution order. For isFirstFunnel + isBorn
 	// runs, the first event in execution order whose config has `isAuthEvent: true` is

package/lib/hook-helpers/shape.js

@@ -114,6 +114,9 @@ export function applyLifecycleWave(events, uid, opts) {
  * For users where `hashFloat(uid) < share`, injects the `path` sequence —
  * each step cloned from the user's OWN existing event of that name — right
  * after the user's FIRST `anchor` occurrence, with tight monotonic gaps.
+ * This is append-only: original traffic is never moved or removed. Events
+ * already between the anchor and clones can interrupt the immediate branch.
+ * `share` selects injection recipients, not the measured Flows branch share.
  *
  * Why these rules (HOOKS.md §2.17): Flows' unique mode reads only the FIRST
  * flow per user, so the injection anchors on the first occurrence; gaps are
@@ -192,12 +195,23 @@ export function applyPathBias(events, uid, opts) {
  * Boundary guarantees (what makes derived sessions deterministic against
  * jitter — HOOKS.md §2.13): intra-session gaps stay well under Mixpanel's
  * 30-min timeout (even spacing capped at 20min + bounded jitter, worst case
- * <28min); inter-session gaps stay well over it (sessions land on distinct
- * days when possible; same-day sessions are centered in equal partitions of
- * the day, spaced ≥¼ partition — guaranteed >30min up to 8 sessions/day);
+ * <28min); with explicit bounds, inter-session gaps stay strictly over it (sessions land on distinct
+ * days when possible; same-day slots reserve at least 30min + 1ms between
+ * clusters, compressing their spans when necessary);
  * and no engineered session crosses UTC midnight (a day-boundary split would
  * cut it — `session_query.cpp` daySplit). Valid precisely because of P2.1:
  * session_ids are re-derived after the everything hook.
+ * With both bounds omitted, placement keeps the legacy full-UTC-day slots
+ * between the user's first and last active days. Overfull legacy requests
+ * still run, but their clusters can merge under the 30-minute timeout.
+ * Optional bounds are additive: supply known dataset limits to constrain
+ * placement; the helper cannot infer datasetEnd from a user's last event.
+ * An omitted side defaults to the corresponding full UTC day edge. Partial
+ * days compress clusters, including zero-span clusters. Only explicit-bound
+ * mode throws for insufficient per-week capacity, before any record changes.
+ * The helper never silently reduces the cluster target or drops events;
+ * legacy full-day placement can exceed an unknown dataset end and be clipped
+ * later by the engine. Pass metadata bounds to prevent that clipping.
  *
  * @param {Array<Object>} events - Full user event array (everything hook).
  * @param {string} uid - Unused for hashing here; kept for atom-signature
@@ -207,10 +221,15 @@ export function applyPathBias(events, uid, opts) {
  * @param {number} opts.sessionsPerWeek - Target clusters per week (≥1).
  * @param {number} opts.eventsPerSession - Target events per cluster (≥1).
  * @param {number} opts.sessionMinutes - Max cluster span in minutes.
+ * @param {string|number} [opts.datasetStart] - Inclusive lower bound (ISO,
+ *   unix seconds, or unix milliseconds); accepts meta.datasetStart directly.
+ * @param {string|number} [opts.datasetEnd] - Inclusive upper bound (same units);
+ *   accepts meta.datasetEnd directly.
+ * @throws {RangeError} Invalid explicit bounds or insufficient bounded 30-minute-session capacity.
  * @returns {Array<Object>} The SAME array, timestamps rewritten.
  */
 export function applySessionShape(events, uid, opts) {
-	const { sessionsPerWeek, eventsPerSession, sessionMinutes } = opts || {};
+	const { sessionsPerWeek, eventsPerSession, sessionMinutes, datasetStart, datasetEnd } = opts || {};
 	if (!Array.isArray(events) || !events.length) return events;
 	if (!isPos(sessionsPerWeek) || !isPos(eventsPerSession) || !isPos(sessionMinutes)) return events;
 
@@ -221,6 +240,13 @@ export function applySessionShape(events, uid, opts) {
 	const N = timed.length;
 	const firstMs = toMs(timed[0].time);
 	const lastMs = toMs(timed[N - 1].time);
+	const bounded = datasetStart !== undefined || datasetEnd !== undefined;
+	const lowerMs = datasetStart === undefined ? Math.floor(firstMs / DAY_MS) * DAY_MS : toMs(datasetStart);
+	const upperMs = datasetEnd === undefined ? (Math.floor(lastMs / DAY_MS) + 1) * DAY_MS - 1 : toMs(datasetEnd);
+	if (!Number.isFinite(lowerMs) || !Number.isFinite(upperMs) || lowerMs > upperMs ||
+		Math.abs(lowerMs) > 8.64e15 || Math.abs(upperMs) > 8.64e15) {
+		throw new RangeError('applySessionShape: invalid dataset bounds');
+	}
 	const weeks = Math.max(1, Math.ceil((lastMs - firstMs + 1) / WEEK_MS));
 	const numSessions = Math.max(1, Math.min(
 		Math.floor(sessionsPerWeek) * weeks,
@@ -235,6 +261,15 @@ export function applySessionShape(events, uid, opts) {
 	const chance = getChance();
 	const firstDay = Math.floor(firstMs / DAY_MS);
 	const lastDay = Math.floor(lastMs / DAY_MS);
+	const separationMs = 30 * MIN_MS + 1;
+	const perDayCount = new Map();
+	const dayBounds = day => [Math.ceil(Math.max(day * DAY_MS, lowerMs)),
+		Math.floor(Math.min((day + 1) * DAY_MS - 1, upperMs))];
+	const remainingCapacity = day => {
+		if (!bounded) return Infinity;
+		const [start, end] = dayBounds(day);
+		return (end >= start ? Math.floor((end - start) / separationMs) + 1 : 0) - (perDayCount.get(day) || 0);
+	};
 
 	// Pick one day per session, week by week: prefer the user's original
 	// active days in the week, fill from the rest of the week's days, and
@@ -251,22 +286,38 @@ export function applySessionShape(events, uid, opts) {
 			const t = toMs(ev.time);
 			if (t >= weekStartMs && t < weekStartMs + WEEK_MS) originalDays.add(Math.floor(t / DAY_MS));
 		}
-		const pool = [...originalDays].filter(d => d >= dayLo && d <= dayHi);
+		const pool = [...originalDays].filter(d => d >= dayLo && d <= dayHi && remainingCapacity(d) > 0);
 		const others = [];
-		for (let d = dayLo; d <= dayHi; d++) if (!originalDays.has(d)) others.push(d);
+		for (let d = dayLo; d <= dayHi; d++) if (!originalDays.has(d) && remainingCapacity(d) > 0) others.push(d);
 		const picked = chance.pickset(pool, Math.min(need, pool.length));
 		if (picked.length < need) picked.push(...chance.pickset(others, Math.min(need - picked.length, others.length)));
-		let i = 0;
-		while (picked.length < need) picked.push(picked[i++ % Math.max(1, picked.length)]); // reuse days: > days/week sessions
+		for (const day of picked) perDayCount.set(day, (perDayCount.get(day) || 0) + 1);
+		const candidates = [...pool, ...others];
+		while (picked.length < need) {
+			if (!bounded) {
+				let reuseIndex = 0;
+				while (picked.length < need) {
+					const day = picked[reuseIndex++ % Math.max(1, picked.length)];
+					picked.push(day);
+					perDayCount.set(day, (perDayCount.get(day) || 0) + 1);
+				}
+				break;
+			}
+			const available = candidates.filter(day => remainingCapacity(day) > 0);
+			if (!available.length) {
+				throw new RangeError(`applySessionShape: insufficient session capacity in week ${w + 1} for ${need} clusters`);
+			}
+			for (const day of available) {
+				picked.push(day);
+				perDayCount.set(day, (perDayCount.get(day) || 0) + 1);
+				if (picked.length === need) break;
+			}
+		}
 		picked.sort((a, b) => a - b);
 		sessionDays.push(...picked);
 	}
 
-	// Place sessions within days. Same-day sessions get equal partitions of
-	// the day; the session is centered in its partition with bounded jitter,
-	// which guarantees the inter-session and midnight invariants above.
-	const perDayCount = new Map();
-	for (const d of sessionDays) perDayCount.set(d, (perDayCount.get(d) || 0) + 1);
+	// Bound each day's slots and reserve the strict timeout gap between them.
 	const perDaySeen = new Map();
 	const sesMs = sessionMinutes * MIN_MS;
 
@@ -280,10 +331,15 @@ export function applySessionShape(events, uid, opts) {
 		const j = perDaySeen.get(day) || 0;
 		perDaySeen.set(day, j + 1);
 
-		const seg = DAY_MS / m;
-		const span = Math.min(sesMs, seg * 0.5);
-		const center = day * DAY_MS + j * seg + (seg - span) / 2;
-		const q = Math.floor((seg - span) / 4);
+		const [dayStart, dayEnd] = dayBounds(day);
+		const seg = (dayEnd - dayStart - (m - 1) * separationMs) / m;
+		const slotStart = Math.floor(dayStart + j * (seg + separationMs));
+		const slotEnd = Math.floor(dayStart + (j + 1) * seg + j * separationMs);
+		const slotWidth = bounded ? slotEnd - slotStart : DAY_MS / m;
+		const span = bounded ? Math.floor(Math.min(sesMs, slotWidth * 0.5)) : Math.min(sesMs, slotWidth * 0.5);
+		const center = bounded ? slotStart + Math.floor((slotWidth - span) / 2)
+			: day * DAY_MS + j * slotWidth + (slotWidth - span) / 2;
+		const q = Math.floor((slotWidth - span) / 4);
 		const start = center + (q > 0 ? chance.integer({ min: -q, max: q }) : 0);
 
 		if (size === 1) {

package/lib/orchestrators/user-loop.js

@@ -11,7 +11,7 @@ import pLimit from 'p-limit';
 import os from 'os';
 import * as u from "../utils/utils.js";
 import * as t from 'ak-tools';
-import { makeEvent } from "../generators/events.js";
+import { makeEvent, engineIdentity } from "../generators/events.js";
 import { makeFunnel } from "../generators/funnels.js";
 import { makeUserProfile } from "../generators/profiles.js";
 import { makeSCD } from "../generators/scd.js";
@@ -403,6 +403,8 @@ export async function userLoop(context) {
 			}
 
 			let userFirstEventTime;
+			let userUsageStartTime = context.FIXED_BEGIN;
+			const promisedAttemptEntries = new Set();
 
 			// ── v1.5 Active-day scheduling ──
 			// When `avgActiveDaysPerUser` is set, build a per-user day plan: a list
@@ -493,13 +495,9 @@ export async function userLoop(context) {
 				// Active-day mode: anchor the first funnel on a picked day so the user's
 				// signup lands within their planned active window. Legacy mode: anchor at
 				// adjustedCreated minus a noise offset.
-				let cursor;
-				if (dayPlan) {
-					const bounds = nextDayBounds();
-					cursor = bounds ? bounds.earliest : adjustedCreated.subtract(noise(), 'seconds').unix();
-				} else {
-					cursor = adjustedCreated.subtract(noise(), 'seconds').unix();
-				}
+				const lifecycleStart = Math.max(adjustedCreated.valueOf() / 1000, context.FIXED_BEGIN);
+				const firstDayBounds = dayPlan && !hasRetentionCurve ? nextDayBounds() : null;
+				let cursor = Math.max(lifecycleStart, firstDayBounds?.earliest ?? lifecycleStart);
 
 				// Resolve attempts plan. `attempts.{min,max}` count FAILED PRIORS; total
 				// passes = failedPriors + 1.  Validator coerced bounds; default both 0.
@@ -509,6 +507,7 @@ export async function userLoop(context) {
 				const failedPriors = (maxA > 0) ? chance.integer({ min: minA, max: maxA }) : 0;
 				const totalAttempts = failedPriors + 1;
 				let firstAttemptFirstEventTime = null;
+				if (failedPriors > 0) cursor = lifecycleStart;
 
 				for (let attemptNum = 1; attemptNum <= totalAttempts; attemptNum++) {
 					const isFinal = attemptNum === totalAttempts;
@@ -528,16 +527,23 @@ export async function userLoop(context) {
 						truncateBeforeAuth: !isFinal,
 						devicePool: userDevicePool,
 					};
+					const firstFeatureCtx = {
+						...featureCtx,
+						latestTime: firstDayBounds && failedPriors === 0 ? firstDayBounds.latest : context.FIXED_NOW,
+						pinFirstTime: hasRetentionCurve || failedPriors > 0,
+					};
 					const [data, converted, authMs] = await makeFunnel(
-						context, funnelToRun, user, cursor, profile, userSCD, persona, featureCtx, attemptMeta
+						context, funnelToRun, user, cursor, profile, userSCD, persona, firstFeatureCtx, attemptMeta
 					);
 					if (isFinal) userConverted = converted;
 					if (data && data.length) {
+						if (failedPriors > 0) promisedAttemptEntries.add(data[0].insert_id);
 						if (firstAttemptFirstEventTime === null) {
 							firstAttemptFirstEventTime = dayjs(data[0].time).unix();
 						}
 						// Advance the cursor for the next attempt by a small abandon-and-retry gap.
-						const lastTime = dayjs(data[data.length - 1].time).unix();
+						const lastTime = Math.max(...data.map(event => Date.parse(event.time))) / 1000;
+						userUsageStartTime = Math.max(userUsageStartTime, lastTime + 0.001);
 						cursor = lastTime + chance.integer({ min: 60, max: 30 * 60 }); // 1–30 min later
 						numEventsPreformed += data.length;
 						usersEvents = usersEvents.concat(data);
@@ -547,6 +553,13 @@ export async function userLoop(context) {
 						if (userAuthTimeMs === null) userAuthTimeMs = authMs;
 						userAuthed = true;
 					}
+					if (!isFinal && !data.length && config.events.find(event => event.event === firstFunnel.sequence[0])?.isAuthEvent) {
+						context.addWarning({
+							key: 'lifecycle.emptyPreAuthAttempt',
+							requested: 1, applied: 0, severity: 'warn',
+							reason: 'A failed prior has no pre-auth step because auth starts the funnel; the prior emits no rows and the final attempt still runs.',
+						});
+					}
 				}
 
 				userFirstEventTime = firstAttemptFirstEventTime !== null
@@ -614,6 +627,8 @@ export async function userLoop(context) {
 				// gets re-anchored to the picked day's start (subsequent funnel steps
 				// spill within `timeToConvert` hours; this is intentional).
 				const dayBounds = dayPlan ? nextDayBounds() : null;
+				const usageEarliest = Math.max(dayBounds?.earliest ?? userFirstEventTime, userUsageStartTime);
+				if (usageEarliest > (dayBounds?.latest ?? context.FIXED_NOW)) continue;
 				// Compute step1's `latestTime` so the funnel's relative span fits before
 				// FIXED_NOW. Without this, born-late users + long-ttc funnels generate
 				// large numbers of `_drop`'d events that consume budget cycles. The
@@ -639,7 +654,7 @@ export async function userLoop(context) {
 					const ttcSec = (currentFunnel.timeToConvert || 0) * 3600;
 					// Anchor cursor at picked day's start when active-day mode is on,
 					// otherwise pass userFirstEventTime (constant). NO cursor accumulation.
-					const funnelCursor = dayBounds ? dayBounds.earliest : userFirstEventTime;
+					const funnelCursor = usageEarliest;
 					// Constrain funnel step1's TimeSoup latestTime so the full funnel fits in
 					// window. Without this, late steps spill past FIXED_NOW and get `_drop`'d.
 					//
@@ -683,7 +698,7 @@ export async function userLoop(context) {
 					// — passing `true` here would pin every standalone event to the same
 					// `earliestTime`, which the now-deleted bunchIntoSessions used to paper
 					// over. With bunchIntoSessions removed, TimeSoup is the time source.
-					const standaloneEarliest = dayBounds ? dayBounds.earliest : userFirstEventTime;
+					const standaloneEarliest = usageEarliest;
 					// v1.5.1: pass `config.superProps` so standalone events get super-property
 					// stamping. Pre-1.5.1, standalone events received `{}` here, but the
 					// validator's auto-funnel (catch-all) consumed all non-strict events so
@@ -763,6 +778,8 @@ export async function userLoop(context) {
 					for (const ev of usersEvents) {
 						if (chance.bool({ likelihood: dataQuality.duplicateRate * 100 })) {
 							const dupe = { ...ev };
+							const identityDescriptor = Object.getOwnPropertyDescriptor(ev, engineIdentity);
+							if (identityDescriptor) Object.defineProperty(dupe, engineIdentity, identityDescriptor);
 							dupe.time = dayjs(ev.time).add(chance.integer({ min: 1, max: 60 }), 'seconds').toISOString();
 							dupe.insert_id = randomUUID();
 							dupes.push(dupe);
@@ -828,6 +845,13 @@ export async function userLoop(context) {
 				profile._drop = true;
 			}
 
+			const identityBeforeEverything = new Map(usersEvents.map(event => [event.insert_id, {
+				user_id: event.user_id, device_id: event.device_id,
+				original: event[engineIdentity],
+			}]));
+			const profileDropBeforeEverything = profile._drop;
+			let profileDropOverridden = false;
+
 			// Hook for processing all user events (hooks override everything)
 			if (config.hook) {
 				// `meta.isPreAuth(event)` predicate bound to this user's auth state.
@@ -843,7 +867,16 @@ export async function userLoop(context) {
 					return Number.isFinite(t) ? t < userAuthTimeMsLocal : false;
 				};
 				const newEvents = await config.hook(usersEvents, "everything", {
-					profile,
+					profile: new Proxy(profile, {
+						deleteProperty(target, key) {
+							if (key === '_drop') profileDropOverridden = true;
+							return Reflect.deleteProperty(target, key);
+						},
+						set(target, key, value) {
+							if (key === '_drop') profileDropOverridden = true;
+							return Reflect.set(target, key, value);
+						},
+					}),
 					scd: userSCD,
 					config,
 					userIsBornInDataset,
@@ -944,13 +977,44 @@ export async function userLoop(context) {
 			// stream to the remaining room with a seeded uniform sample (keeps the
 			// time shape; preserves array order). Only under the flag.
 			if (strictEventCount && usersEvents.length > 0) {
+				const promisedEntries = usersEvents.filter(event => promisedAttemptEntries.has(event.insert_id));
 				const room = numEvents - context.getStoredEventCount();
 				if (room <= 0) {
 					usersEvents = [];
 				} else if (usersEvents.length > room) {
-					const keep = new Set(chance.pickset(usersEvents, room));
+					const reserved = promisedEntries.slice(0, room);
+					const others = usersEvents.filter(event => !promisedAttemptEntries.has(event.insert_id));
+					const keep = new Set([...reserved, ...chance.pickset(others, Math.max(0, room - reserved.length))]);
 					usersEvents = usersEvents.filter(e => keep.has(e));
 				}
+				if (promisedEntries.some(event => !usersEvents.includes(event))) {
+					context.addWarning({
+						key: 'lifecycle.strictAttemptBudget',
+						requested: promisedEntries.length, applied: Math.max(0, room), severity: 'warn',
+						reason: 'The remaining strict event budget is smaller than the surviving first-funnel attempt entries; strictEventCount takes precedence and later entries are omitted.',
+					});
+				}
+			}
+
+			if (userIsBornInDataset && userDevicePool?.length) {
+				const authNames = new Set(config.events.filter(event => event.isAuthEvent).map(event => event.event));
+				const stitches = usersEvents.filter(event => authNames.has(event.event) && event.user_id && event.device_id);
+				const emittedAuthTime = stitches.length ? Math.min(...stitches.map(event => Date.parse(event.time))) : null;
+				for (const event of usersEvents) {
+					if (event.event === '$experiment_started') continue;
+					if (emittedAuthTime === null || Date.parse(event.time) < emittedAuthTime) {
+						const before = identityBeforeEverything.get(event.insert_id);
+						const original = event[engineIdentity] || before?.original;
+						if (!original) continue;
+						const explicitUser = event.user_id !== original.user_id;
+						const explicitDevice = before
+							? event.device_id !== before.device_id || (!before.device_id && !!original.device_id)
+							: event.device_id !== original.device_id;
+						if (!explicitUser) delete event.user_id;
+						if (!explicitUser && !explicitDevice) event.device_id ||= userDevicePool[0];
+					}
+				}
+				if (emittedAuthTime === null && !profileDropOverridden && profile._drop === profileDropBeforeEverything) profile._drop = true;
 			}
 
 			// Store all user data (skip profile push when a hook returned null
@@ -1108,7 +1172,10 @@ export function amplifyWorldEvents(events, worldEvents, chance, fixedNow) {
 			if (frac > 0 && chance.bool({ likelihood: frac * 100 })) copies++;
 			for (let c = 0; c < copies; c++) {
 				const t = chance.integer({ min: windowStart, max: windowEnd - 1 });
-				clones.push({ ...ev, time: dayjs.unix(t).toISOString(), insert_id: randomUUID() });
+				const clone = { ...ev, time: dayjs.unix(t).toISOString(), insert_id: randomUUID() };
+				const identityDescriptor = Object.getOwnPropertyDescriptor(ev, engineIdentity);
+				if (identityDescriptor) Object.defineProperty(clone, engineIdentity, identityDescriptor);
+				clones.push(clone);
 			}
 		}
 	}