@murphai/murph 1.2.0 → 1.2.3

package/node_modules/@murphai/device-syncd/dist/providers/junction.js

@@ -1,16 +1,24 @@
 import { createHmac, createHash, timingSafeEqual } from "node:crypto";
 import { HistoricalPullCompleted as JunctionHistoricalPullCompletedSchema } from "@junction-api/sdk/serialization";
+import { COMPANION_HRV_RMSSD_RESOURCE, parseCompanionHrvRmssdAdmissionId, parseSerializedCompanionHrvRmssdObservation, serializeCompanionHrvRmssdObservation, } from "@murphai/contracts";
+import { canNormalizeJunctionSleepCycleRecordToCompactStages, classifyJunctionSummaryNormalizationEvidence, } from "@murphai/importers";
 import { resolveJunctionOrigin } from "@murphai/importers/device-providers/junction-origin";
-import { JUNCTION_ALLOWED_SUMMARY_RESOURCES, JUNCTION_ALLOWED_TIMESERIES_RESOURCES, JUNCTION_DEFAULT_SUMMARY_RESOURCES, JUNCTION_DEFAULT_TIMESERIES_RESOURCES, JUNCTION_KNOWN_TIMESERIES_RESOURCES, JUNCTION_SLEEP_END_TIMESTAMP_PATHS, JUNCTION_SLEEP_STAGE_ARRAY_PATHS, JUNCTION_SLEEP_STAGE_COUNT_PATHS, JUNCTION_SLEEP_STAGE_DURATION_PATHS, JUNCTION_SLEEP_STAGE_VALUE_PATHS, JUNCTION_SLEEP_START_TIMESTAMP_PATHS, JUNCTION_SLEEP_SUMMARY_NUMBER_PATHS, isJunctionRawDirectIdentityContainerKey, isJunctionRawDirectIdentityKey, normalizeJunctionSleepStageValue, normalizeJunctionResourceName, } from "@murphai/importers/device-providers/junction-resources";
+import { JUNCTION_ALLOWED_SUMMARY_RESOURCES, JUNCTION_ALLOWED_TIMESERIES_RESOURCES, JUNCTION_DEFAULT_SUMMARY_RESOURCES, JUNCTION_DEFAULT_TIMESERIES_RESOURCES, JUNCTION_KNOWN_TIMESERIES_RESOURCES, isJunctionRawDirectIdentityContainerKey, isJunctionRawDirectIdentityKey, normalizeJunctionResourceName, } from "@murphai/importers/device-providers/junction-resources";
 import { JUNCTION_DEVICE_PROVIDER_DESCRIPTOR } from "@murphai/importers/device-providers/provider-descriptors";
 import { deviceSyncError, isDeviceSyncError } from "../errors.js";
-import { sanitizeHostedRuntimeDiagnosticText } from "../hosted-runtime.js";
+import { isHostedRuntimeIdShapedDiagnosticToken, sanitizeHostedRuntimeDiagnosticText, } from "../hosted-runtime.js";
+import { addJunctionHistoricalBackfillEvidence, canCurrentRuntimeMutateJunctionHistoricalBackfillProgress, encodeJunctionHistoricalBackfillStatus, hasJunctionHistoricalBackfillEvidence, JUNCTION_HISTORICAL_BACKFILL_COVERAGE_VERSION, JUNCTION_HISTORICAL_BACKFILL_METADATA_KEYS, readJunctionHistoricalBackfillEvidence, readJunctionHistoricalBackfillStatus, } from "../junction-historical-backfill-progress.js";
+import { DEVICE_SYNC_METADATA_MAX_STRING_LENGTH } from "../metadata.js";
+import { DEVICE_SYNC_HISTORICAL_DATA_RECONNECT_REQUIRED_ERROR_CODE, isJunctionHistoricalResetProviderSlug, requiresHistoricalResetDeviceSyncSource, } from "../public-account.js";
+import { assertValidJunctionClientUserIdSecret, normalizeJunctionDeviceSyncRuntimeConfig, } from "../configured-provider-runtime-descriptors.js";
 import { addMilliseconds, normalizeString, sha256Text, subtractDays, } from "../shared.js";
+import { JUNCTION_COMPANION_HRV_OBSERVATION_INVALID_CODE, JUNCTION_COMPANION_HEALTH_METADATA_EVENT_TYPE, JUNCTION_COMPANION_HEALTH_METADATA_MAX_BATCH_BYTES, JUNCTION_COMPANION_HEALTH_METADATA_RESOURCE, JUNCTION_COMPANION_HEALTH_METADATA_SOURCE_PROVIDER, JUNCTION_COMPANION_HEALTH_METADATA_SOURCE_TYPE, JunctionCompanionHealthMetadataParseError, parseJunctionCompanionHealthMetadataBatch, } from "../junction-resources.js";
 import { JunctionClient, } from "./junction-client.js";
-import { buildJunctionProviderSourceInstanceKey, JUNCTION_DEFAULT_PROVIDER_FILTER, normalizeJunctionProviderFilter, } from "./junction-connect-sources.js";
+import { resolveJunctionDeviceConnectRouteByProviderSlug } from "../config/connect-routes.js";
+import { buildJunctionProviderSourceInstanceKey, JUNCTION_DEFAULT_PROVIDER_FILTER, normalizeJunctionProviderFilter, } from "../config/junction-connect-sources.js";
 import { classifyDeviceSyncWebhookAcceptanceMode } from "../types.js";
 export { JUNCTION_DEVICE_PROVIDER_DESCRIPTOR };
-export { JUNCTION_CONNECT_SOURCE_TARGETS, JUNCTION_DEFAULT_PROVIDER_FILTER, JUNCTION_LINK_PROVIDER_SLUGS, normalizeJunctionProviderFilter, resolveJunctionConnectSourceLabel, resolveJunctionConnectTargetForSourceId, } from "./junction-connect-sources.js";
+export { JUNCTION_CONNECT_SOURCE_TARGETS, JUNCTION_DEFAULT_PROVIDER_FILTER, JUNCTION_LINK_PROVIDER_SLUGS, normalizeJunctionProviderFilter, resolveJunctionConnectSourceLabel, resolveJunctionConnectTargetForSourceId, } from "../config/junction-connect-sources.js";
 export const JUNCTION_PROVIDER_CONFIG_KEY = "junction";
 export { JUNCTION_DEFAULT_SUMMARY_RESOURCES, JUNCTION_DEFAULT_TIMESERIES_RESOURCES, };
 const JUNCTION_WEBHOOK_ROOT_FIELDS = Object.freeze({
@@ -36,235 +44,22 @@ const JUNCTION_HISTORICAL_BACKFILL_COMPLETION_SUMMARY_RESOURCES = Object.freeze(
     "electrocardiogram",
 ]);
 const JUNCTION_HISTORICAL_BACKFILL_COMPLETION_SUMMARY_RESOURCE_SET = new Set(JUNCTION_HISTORICAL_BACKFILL_COMPLETION_SUMMARY_RESOURCES);
-const JUNCTION_HISTORICAL_SUMMARY_METRIC_PATHS = Object.freeze({
-    activity: [
-        "steps",
-        "step_count",
-        "daily_steps",
-        "activeCalories",
-        "active_calories",
-        "calories",
-        "totalCalories",
-        "total_calories",
-        "distanceKm",
-        "distance_km",
-        "floors",
-        "floorsClimbed",
-        "floors_climbed",
-        "floorsAscended",
-        "floors_ascended",
-        "activityScore",
-        "activity_score",
-        "score",
-    ],
-    body: [
-        "weightKg",
-        "weight_kg",
-        "weight",
-        "bmi",
-        "body_mass_index",
-        "bodyFatPercentage",
-        "body_fat_percentage",
-        "body_fat_percent",
-        "leanBodyMassKg",
-        "lean_body_mass_kg",
-        "leanBodyMassKilogram",
-        "lean_body_mass_kilogram",
-        "leanMassKg",
-        "lean_mass_kg",
-        "waistCircumference",
-        "waist_circumference",
-        "waistCircumferenceCentimeter",
-        "waist_circumference_centimeter",
-        "waistCircumferenceCm",
-        "waist_circumference_cm",
-    ],
-    sleep: JUNCTION_SLEEP_SUMMARY_NUMBER_PATHS,
-    sleep_cycle: [],
-    workouts: [
-        "calories",
-        "totalCalories",
-        "total_calories",
-        "averageHeartRate",
-        "average_heart_rate",
-        "average_hr",
-        "avg_hr",
-        "maxHeartRate",
-        "max_heart_rate",
-        "max_hr",
-    ],
-    meal: [],
-    menstrual_cycle: [],
-    electrocardiogram: [],
-});
-const JUNCTION_RAW_ONLY_COMPLETION_PATHS = Object.freeze({
-    meal: {
-        strings: [
-            "timestamp",
-            "recordedAt",
-            "recorded_at",
-            "loggedAt",
-            "logged_at",
-            "date",
-            "day",
-            "calendarDate",
-            "calendar_date",
-            "name",
-            "mealName",
-            "meal_name",
-            "mealType",
-            "meal_type",
-            "description",
-            "notes",
-        ],
-        numbers: [
-            "calories",
-            "caloriesKcal",
-            "calories_kcal",
-            "energyKcal",
-            "energy_kcal",
-            "kcal",
-            "protein",
-            "proteinGrams",
-            "protein_grams",
-            "protein_g",
-            "carbs",
-            "carbohydrates",
-            "carbohydrateGrams",
-            "carbohydrate_grams",
-            "carbohydrate_g",
-            "fat",
-            "fatGrams",
-            "fat_grams",
-            "fat_g",
-            "fiber",
-            "fibre",
-            "water",
-            "macros.water",
-            "macros.fibre",
-            "macros.fiber",
-            "energy.value",
-        ],
-        arrays: [
-            "foods",
-            "foodItems",
-            "food_items",
-            "items",
-            "ingredients",
-            "nutrients",
-        ],
-    },
-    menstrual_cycle: {
-        strings: [
-            "timestamp",
-            "recordedAt",
-            "recorded_at",
-            "createdAt",
-            "created_at",
-            "date",
-            "day",
-            "cycleStart",
-            "cycle_start",
-            "cycleEnd",
-            "cycle_end",
-            "periodStart",
-            "period_start",
-            "periodEnd",
-            "period_end",
-            "flow",
-            "menstrualFlow",
-            "menstrual_flow",
-            "cyclePhase",
-            "cycle_phase",
-            "menstrualPhase",
-            "menstrual_phase",
-        ],
-        numbers: [
-            "cycleDay",
-            "cycle_day",
-            "menstrualCycleDay",
-            "menstrual_cycle_day",
-            "cycleLengthDays",
-            "cycle_length_days",
-            "periodLengthDays",
-            "period_length_days",
-        ],
-        arrays: [
-            "menstrualFlow",
-            "menstrual_flow",
-            "symptoms",
-            "sexualActivity",
-            "sexual_activity",
-            // Facet arrays the importer normalizes; a window containing only
-            // these must not be classified as an empty backfill.
-            "ovulationTest",
-            "ovulation_test",
-            "homePregnancyTest",
-            "home_pregnancy_test",
-            "detectedDeviations",
-            "detected_deviations",
-            "basalBodyTemperature",
-            "basal_body_temperature",
-        ],
-    },
-    electrocardiogram: {
-        strings: [
-            "sessionStart",
-            "session_start",
-            "classification",
-            "inconclusiveCause",
-            "inconclusive_cause",
-        ],
-        numbers: [
-            "heartRateMean",
-            "heart_rate_mean",
-            "voltageSampleCount",
-            "voltage_sample_count",
-        ],
-        arrays: [],
-    },
-});
+// Resource availability describes permission/capability, not whether the
+// member should have a row. Limit connect-window obligations to high-signal
+// daily families; sparse sessions such as workouts and body measurements still
+// count as useful data, but their absence is not evidence of a failed export.
+const JUNCTION_HISTORICAL_BACKFILL_REQUIRED_SUMMARY_RESOURCES = Object.freeze([
+    "activity",
+    "sleep",
+    "sleep_cycle",
+]);
+const JUNCTION_HISTORICAL_BACKFILL_REQUIRED_SUMMARY_RESOURCE_SET = new Set(JUNCTION_HISTORICAL_BACKFILL_REQUIRED_SUMMARY_RESOURCES);
 const JUNCTION_WEBHOOK_NESTED_RECORD_KEYS = Object.freeze([
     "data",
     "results",
     "items",
     "records",
 ]);
-const JUNCTION_WORKOUT_START_TIMESTAMP_PATHS = Object.freeze([
-    "startAt",
-    "start_at",
-    "start",
-    "timeStart",
-    "time_start",
-]);
-const JUNCTION_WORKOUT_END_TIMESTAMP_PATHS = Object.freeze([
-    "endAt",
-    "end_at",
-    "end",
-    "timeEnd",
-    "time_end",
-]);
-const JUNCTION_WORKOUT_DURATION_MINUTE_PATHS = Object.freeze([
-    "durationMinutes",
-    "duration_minutes",
-    "movingTimeMinutes",
-    "moving_time_minutes",
-]);
-const JUNCTION_WORKOUT_DURATION_SECOND_PATHS = Object.freeze([
-    "durationSeconds",
-    "duration_seconds",
-    "movingTime",
-    "moving_time",
-    "duration",
-]);
-const JUNCTION_WORKOUT_DURATION_MILLISECOND_PATHS = Object.freeze([
-    "durationMillis",
-    "duration_millis",
-]);
-const JUNCTION_FLOATING_TIMESTAMP_SOURCE_PROVIDER_SLUGS = new Set([
-    "abbott_libreview",
-    "freestyle_libre",
-]);
 const JUNCTION_TIMESERIES_RESOURCE_NAMES = new Set([
     ...JUNCTION_KNOWN_TIMESERIES_RESOURCES,
 ]);
@@ -290,22 +85,13 @@ const EMPTY_HISTORICAL_BACKFILL_RETRY_DELAYS_MS = Object.freeze([
     6 * 60 * 60_000,
     24 * 60 * 60_000,
 ]);
-const JUNCTION_HISTORICAL_BACKFILL_METADATA_KEYS = Object.freeze({
-    status: "junctionHistoricalBackfillStatus",
-    emptyAttempts: "junctionHistoricalBackfillEmptyAttempts",
-    lastEmptyAt: "junctionHistoricalBackfillLastEmptyAt",
-    windowStart: "junctionHistoricalBackfillWindowStart",
-    windowEnd: "junctionHistoricalBackfillWindowEnd",
-});
+const JUNCTION_SCHEDULED_RECONCILE_PRIORITY = 40;
+const JUNCTION_HISTORICAL_BACKFILL_PRIORITY = 30;
+const JUNCTION_HISTORICAL_BACKFILL_RETRY_PRIORITY = 50;
 export function createJunctionDeviceSyncProvider(config) {
-    assertValidJunctionClientUserIdSecret(config.clientUserIdSecret);
+    const runtimeConfig = normalizeJunctionDeviceSyncRuntimeConfig(config);
     const client = new JunctionClient(toClientConfig(config));
-    const summaryResources = normalizeRequiredResourceList(config.summaryResources, JUNCTION_DEFAULT_SUMMARY_RESOURCES, JUNCTION_ALLOWED_SUMMARY_RESOURCES, "summary");
-    const timeseriesResources = normalizeOptionalResourceList(config.timeseriesResources, JUNCTION_DEFAULT_TIMESERIES_RESOURCES, JUNCTION_ALLOWED_TIMESERIES_RESOURCES, JUNCTION_KNOWN_TIMESERIES_RESOURCES, "timeseries");
-    const providerFilter = normalizeJunctionProviderFilter(config.providerFilter);
-    if (providerFilter.length === 0) {
-        throw new TypeError("Junction provider filter must include at least one hosted Link provider.");
-    }
+    const { providerFilter, summaryResources, timeseriesResources } = runtimeConfig;
     const summaryBackfillDays = config.summaryBackfillDays ?? DEFAULT_SUMMARY_BACKFILL_DAYS;
     const timeseriesBackfillDays = config.timeseriesBackfillDays ?? DEFAULT_TIMESERIES_BACKFILL_DAYS;
     const reconcileDays = config.reconcileDays ?? DEFAULT_RECONCILE_DAYS;
@@ -442,7 +228,7 @@ export function createJunctionDeviceSyncProvider(config) {
         const providers = await client.listUserProviders(userId);
         const providerSlugs = [
             ...new Set(providers
-                .filter((provider) => mapJunctionSourceStatus(provider.status) === "connected")
+                .filter((provider) => mapJunctionSourceStatus(provider.status) !== "disconnected")
                 .map((provider) => normalizeProviderSlug(provider.origin.sourceProviderSlug)
                 ?? normalizeProviderSlug(provider.slug))
                 .filter((providerSlug) => providerSlug !== null)),
@@ -462,7 +248,7 @@ export function createJunctionDeviceSyncProvider(config) {
         if (failedProviderSlugs.length > 0) {
             throw deviceSyncError({
                 code: "JUNCTION_PROVIDER_DEREGISTER_FAILED",
-                message: "Junction provider deregistration failed for one or more connected sources.",
+                message: "Junction provider deregistration failed for one or more sources.",
                 retryable: true,
                 httpStatus: 503,
                 details: {
@@ -471,25 +257,119 @@ export function createJunctionDeviceSyncProvider(config) {
             });
         }
     }
-    function createScheduledJobs(_account, now) {
+    function createScheduledJobs(account, now) {
+        const scheduledHistoricalBackfillJobs = buildScheduledHistoricalBackfillJobs(account, now);
+        const nextReconcileAt = resolveJunctionNextReconcileAt(account, now, addMilliseconds(now, reconcileIntervalMs));
         return {
             jobs: [
                 buildWindowJob({
                     kind: "reconcile",
                     now,
                     windowStart: subtractDays(now, reconcileDays),
-                    priority: 40,
+                    priority: JUNCTION_SCHEDULED_RECONCILE_PRIORITY,
                 }),
+                ...scheduledHistoricalBackfillJobs,
             ],
-            nextReconcileAt: addMilliseconds(now, reconcileIntervalMs),
+            nextReconcileAt,
         };
     }
+    // Connect-time retry state is owned by metadata. The scheduler materializes
+    // one due backfill job from that state instead of storing a second retry
+    // identity in the job queue.
+    function buildScheduledHistoricalBackfillJobs(account, now) {
+        const metadata = account.metadata;
+        if (!canCurrentRuntimeMutateJunctionHistoricalBackfillProgress(metadata)) {
+            return [];
+        }
+        const statusState = readHistoricalBackfillStatus(metadata);
+        const status = statusState?.status ?? null;
+        const connectWindow = buildConnectHistoricalBackfillWindow(account, summaryBackfillDays);
+        const metadataWindowStart = normalizeString(metadata[JUNCTION_HISTORICAL_BACKFILL_METADATA_KEYS.windowStart]);
+        const metadataWindowEnd = normalizeString(metadata[JUNCTION_HISTORICAL_BACKFILL_METADATA_KEYS.windowEnd]);
+        const metadataMatchesConnectWindow = metadataWindowStart === connectWindow.windowStart
+            && metadataWindowEnd === connectWindow.windowEnd;
+        const coverageVersion = statusState?.coverageVersion ?? 0;
+        const hasCurrentCoverageSemantics = coverageVersion >= JUNCTION_HISTORICAL_BACKFILL_COVERAGE_VERSION;
+        if (hasCurrentCoverageSemantics
+            && (status === "complete" || status === "exhausted")
+            && metadataMatchesConnectWindow) {
+            return [];
+        }
+        if (hasCurrentCoverageSemantics && status === "retrying" && metadataMatchesConnectWindow) {
+            const retryAt = readPendingConnectHistoricalBackfillRetryAt(account);
+            const retryAtMs = retryAt ? Date.parse(retryAt) : NaN;
+            if (retryAt && Number.isFinite(retryAtMs) && Date.parse(now) < retryAtMs) {
+                return [];
+            }
+            return [buildExactWindowJob({
+                    kind: "backfill",
+                    windowStart: connectWindow.windowStart,
+                    windowEnd: connectWindow.windowEnd,
+                    availableAt: now,
+                    priority: JUNCTION_HISTORICAL_BACKFILL_RETRY_PRIORITY,
+                })];
+        }
+        // No recorded outcome: the connect-time historical backfill never ran to
+        // completion (or predates this bookkeeping). Re-derive its exact window
+        // from the connection's connect time and run it until a terminal status
+        // lands; imports are idempotent so a redundant pass is safe.
+        return [buildExactWindowJob({
+                kind: "backfill",
+                windowStart: connectWindow.windowStart,
+                windowEnd: connectWindow.windowEnd,
+                availableAt: now,
+                priority: JUNCTION_HISTORICAL_BACKFILL_PRIORITY,
+            })];
+    }
+    function isConnectHistoricalBackfillWindow(account, window) {
+        const connectHistoricalWindow = buildConnectHistoricalBackfillWindow(account, summaryBackfillDays);
+        return (window.windowStart === connectHistoricalWindow.windowStart
+            && window.windowEnd === connectHistoricalWindow.windowEnd);
+    }
+    function readPendingConnectHistoricalBackfillRetryAt(account) {
+        const connectWindow = buildConnectHistoricalBackfillWindow(account, summaryBackfillDays);
+        return readPendingHistoricalBackfillRetryAt(account.metadata, connectWindow.windowStart, connectWindow.windowEnd);
+    }
+    function resolveJunctionNextReconcileAt(account, now, fallbackNextReconcileAt) {
+        const retryAt = readPendingConnectHistoricalBackfillRetryAt(account);
+        if (!retryAt) {
+            return fallbackNextReconcileAt;
+        }
+        const retryAtMs = Date.parse(retryAt);
+        if (!Number.isFinite(retryAtMs) || Date.parse(now) >= retryAtMs) {
+            return fallbackNextReconcileAt;
+        }
+        const fallbackMs = Date.parse(fallbackNextReconcileAt);
+        return Number.isFinite(fallbackMs) && fallbackMs <= retryAtMs
+            ? fallbackNextReconcileAt
+            : retryAt;
+    }
+    async function loadJunctionHistoricalPullSnapshot(context) {
+        try {
+            return await client.introspectHistoricalPull({
+                signal: context.signal ?? null,
+                userId: context.account.externalAccountId,
+                userLimit: 1,
+            });
+        }
+        catch (error) {
+            if (context.signal?.aborted) {
+                throw error;
+            }
+            context.logger.warn?.("Junction historical-pull introspection was unavailable; using canonical import evidence.", {
+                provider: "junction",
+                errorCode: isDeviceSyncError(error) ? error.code : "JUNCTION_HISTORICAL_PULL_INTROSPECTION_FAILED",
+            });
+            return null;
+        }
+    }
     async function executeJob(context, job) {
         const skippedOptionalResources = [];
         if (job.kind === "resource") {
             return executeResourceJob(context, job, skippedOptionalResources);
         }
         const window = resolveJobWindow(job, context.now, job.kind === "backfill" ? summaryBackfillDays : reconcileDays);
+        const isConnectHistoricalBackfill = isConnectHistoricalBackfillWindow(context.account, window);
         const sourceProviders = await client.listUserProviders(context.account.externalAccountId, {
             signal: context.signal ?? null,
         });
@@ -509,11 +389,26 @@ export function createJunctionDeviceSyncProvider(config) {
         if (profileSummaryResult.records.length > 0) {
             summaries[JUNCTION_PROFILE_SUMMARY_RESOURCE] = profileSummaryResult.records;
         }
-        const historicalSummaryHasRecords = hasJunctionHistoricalBackfillSummaryRecords(summaries, sourceProviders);
+        const importConnections = sanitizeJunctionImportConnections(sourceProviders);
+        const importSummaries = sanitizeJunctionImportSnapshots(summaries, sourceProviders);
+        const summaryNormalizationEvidence = classifyJunctionSummaryNormalizationEvidence({
+            connections: importConnections,
+            importedAt: summaryWindow.windowEnd,
+            summaries: importSummaries,
+            windowEnd: summaryWindow.windowEnd,
+            windowStart: summaryWindow.windowStart,
+        });
+        const historicalSummaryHasRecords = hasJunctionHistoricalBackfillSummaryRecords(summaryNormalizationEvidence);
         const summaryHasFetchedRecords = hasJunctionSnapshotRecords(summaries);
-        const timeseriesWindowStart = job.kind === "backfill"
+        const baseTimeseriesWindowStart = job.kind === "backfill"
             ? maxIsoTimestamp(window.windowStart, subtractDays(window.windowEnd, timeseriesBackfillDays))
             : window.windowStart;
+        const timeseriesCursor = job.kind === "backfill"
+            ? readBackfillTimeseriesCursor(job, window)
+            : null;
+        const timeseriesWindowStart = timeseriesCursor
+            ? maxIsoTimestamp(baseTimeseriesWindowStart, timeseriesCursor)
+            : baseTimeseriesWindowStart;
         if (job.kind !== "backfill" || summaryHasFetchedRecords) {
             await context.importSnapshot({
                 provider: "junction",
@@ -522,11 +417,19 @@ export function createJunctionDeviceSyncProvider(config) {
                 importedAt: summaryWindow.windowEnd,
                 windowStart: summaryWindow.windowStart,
                 windowEnd: summaryWindow.windowEnd,
-                connections: sanitizeJunctionImportConnections(sourceProviders),
-                summaries: sanitizeJunctionImportSnapshots(summaries, sourceProviders),
+                connections: importConnections,
+                summaries: importSummaries,
                 timeseries: {},
             });
         }
+        // Current records are durable before the optional historical-status probe.
+        // An unavailable introspection endpoint must not hold fresh ingestion hostage.
+        const historicalPullSnapshot = isConnectHistoricalBackfill && !context.shouldYield?.()
+            ? await loadJunctionHistoricalPullSnapshot(context)
+            : null;
+        const historicalSummaryCoverage = evaluateJunctionHistoricalBackfillCoverage(summaryNormalizationEvidence, sourceProviders, summaryResources, providerFilter, historicalPullSnapshot, isConnectHistoricalBackfill
+            ? readJunctionHistoricalBackfillEvidence(context.account.metadata[JUNCTION_HISTORICAL_BACKFILL_METADATA_KEYS.evidence])
+            : null, window);
         if (job.kind === "backfill"
             || shouldImportClosedTimeseriesForReconcile(context.account.lastSyncCompletedAt, window.windowEnd)) {
             const timeseriesImport = await importTimeseriesDailySnapshots(context, sourceProviders, timeseriesWindowStart, window.windowEnd, skippedOptionalResources);
@@ -535,24 +438,108 @@ export function createJunctionDeviceSyncProvider(config) {
                     context,
                     job,
                     windowEnd: window.windowEnd,
-                    windowStart: timeseriesImport.yieldedAt,
+                    windowStart: job.kind === "backfill" ? window.windowStart : timeseriesImport.yieldedAt,
+                    timeseriesCursor: job.kind === "backfill" ? timeseriesImport.yieldedAt : null,
                 }), profileMetadataPatch), skippedOptionalResources);
             }
         }
         const backfillFollowUp = job.kind === "backfill"
-            ? buildHistoricalBackfillFollowUp({
-                hasRecords: historicalSummaryHasRecords,
-                metadata: context.account.metadata,
-                now: context.now,
-                windowStart: window.windowStart,
-                windowEnd: window.windowEnd,
-            })
+            ? isConnectHistoricalBackfill
+                ? buildHistoricalBackfillFollowUp({
+                    coverageComplete: historicalSummaryCoverage.complete,
+                    terminalFailure: historicalSummaryCoverage.pendingProviderSlugs.length > 0
+                        && historicalSummaryCoverage.pendingProviderSlugs.every((providerSlug) => historicalSummaryCoverage.reconnectProviderSlugs.includes(providerSlug)),
+                    metadata: context.account.metadata,
+                    now: context.now,
+                    windowStart: window.windowStart,
+                    windowEnd: window.windowEnd,
+                })
+                : buildNonConnectHistoricalBackfillFollowUp({
+                    hasRecords: historicalSummaryHasRecords,
+                    job,
+                    now: context.now,
+                    windowStart: window.windowStart,
+                    windowEnd: window.windowEnd,
+                })
             : {};
+        const historicalStatusAfterJob = readJunctionHistoricalBackfillStatus(backfillFollowUp.metadataPatch?.[JUNCTION_HISTORICAL_BACKFILL_METADATA_KEYS.status]) ?? readHistoricalBackfillStatus(context.account.metadata);
+        const historicalStatusBeforeJob = readHistoricalBackfillStatus(context.account.metadata);
+        const saturatedRetryObserved = backfillFollowUp.metadataPatch !== undefined
+            && historicalStatusBeforeJob?.coverageVersion
+                === JUNCTION_HISTORICAL_BACKFILL_COVERAGE_VERSION
+            && historicalStatusBeforeJob.status === "retrying"
+            && readHistoricalBackfillEmptyAttempts(context.account.metadata, window.windowStart, window.windowEnd) >= EMPTY_HISTORICAL_BACKFILL_RETRY_DELAYS_MS.length;
+        if (isConnectHistoricalBackfill
+            && (!historicalStatusBeforeJob
+                || historicalStatusBeforeJob.coverageVersion
+                    <= JUNCTION_HISTORICAL_BACKFILL_COVERAGE_VERSION)
+            && (historicalStatusAfterJob?.status === "exhausted"
+                || saturatedRetryObserved
+                || (historicalSummaryCoverage.complete
+                    && historicalStatusBeforeJob?.status === "exhausted"))) {
+            const pendingProviderSlugs = new Set(historicalSummaryCoverage.pendingProviderSlugs);
+            const hasCoveredProvider = sourceProviders.some((provider) => {
+                const providerSlug = resolveJunctionHistoricalCoverageProviderSlug(provider.origin.sourceProviderSlug ?? provider.slug, providerFilter);
+                return providerSlug !== null
+                    && mapJunctionSourceStatus(provider.status) !== "disconnected"
+                    && !pendingProviderSlugs.has(providerSlug);
+            });
+            if (historicalSummaryCoverage.complete || hasCoveredProvider) {
+                await projectJunctionSources(context, sourceProviders, {
+                    preserveHistoricalReconnectProviderSlugs: historicalSummaryCoverage.pendingProviderSlugs,
+                });
+            }
+            if (!historicalSummaryCoverage.complete) {
+                await markJunctionHistoricalReconnectRequired(context, historicalSummaryCoverage.reconnectProviderSlugs);
+            }
+        }
+        const nextReconcileAt = backfillFollowUp.nextReconcileAt ?? resolveJunctionNextReconcileAt(context.account, context.now, addMilliseconds(context.now, reconcileIntervalMs));
         return withJunctionSkippedResourceMetadata(context, withJunctionMetadataPatch({
             ...backfillFollowUp,
-            nextReconcileAt: addMilliseconds(context.now, reconcileIntervalMs),
+            nextReconcileAt,
         }, profileMetadataPatch), skippedOptionalResources);
     }
+    async function markJunctionHistoricalReconnectRequired(context, pendingProviderSlugs) {
+        if (!context.upsertConnectionSource) {
+            return;
+        }
+        const existingSources = context.listConnectionSources
+            ? await context.listConnectionSources()
+            : [];
+        const existingByInstanceKey = new Map(existingSources.map((source) => [source.sourceInstanceKey, source]));
+        const recoveryProviderSlugs = new Set(pendingProviderSlugs
+            .map(normalizeProviderSlug)
+            .filter((providerSlug) => providerSlug !== null));
+        for (const providerSlug of recoveryProviderSlugs) {
+            if (!isJunctionHistoricalResetProviderSlug(providerSlug)) {
+                continue;
+            }
+            const projectedSourceInstanceKey = buildJunctionProviderSourceInstanceKey({
+                connectionId: context.account.id,
+                sourceProviderSlug: providerSlug,
+            });
+            if (!projectedSourceInstanceKey) {
+                continue;
+            }
+            const existing = existingByInstanceKey.get(projectedSourceInstanceKey) ?? existingSources.find((source) => normalizeProviderSlug(source.sourceProviderSlug) === providerSlug);
+            if (existing?.status === "error"
+                && existing.lastErrorCode === DEVICE_SYNC_HISTORICAL_DATA_RECONNECT_REQUIRED_ERROR_CODE) {
+                continue;
+            }
+            await context.upsertConnectionSource({
+                sourceInstanceKey: existing?.sourceInstanceKey ?? projectedSourceInstanceKey,
+                sourceProviderSlug: providerSlug,
+                displayName: existing?.displayName ?? null,
+                status: "error",
+                ...(existing
+                    ? { resourceAvailabilitySummary: existing.resourceAvailabilitySummary }
+                    : {}),
+                lastErrorCode: DEVICE_SYNC_HISTORICAL_DATA_RECONNECT_REQUIRED_ERROR_CODE,
+                lastErrorMessage: "Historical data remained incomplete after bounded observation. A member-confirmed connection reset is required to restart its history export.",
+                lastSeenAt: context.now,
+            });
+        }
+    }
     function readJunctionDirectResourceJobInput(job, window) {
         if (job.kind !== "resource") {
             return null;
@@ -584,6 +571,10 @@ export function createJunctionDeviceSyncProvider(config) {
         if (!sourceProviderSlug) {
             return null;
         }
+        if (resource === "sleep_cycle"
+            && !canNormalizeJunctionSleepCycleRecordToCompactStages(record, sourceProviderSlug)) {
+            return null;
+        }
         return {
             record,
             resource,
@@ -593,6 +584,10 @@ export function createJunctionDeviceSyncProvider(config) {
             windowStart: window.windowStart,
         };
     }
+    function shouldLoadJunctionDirectResourceSourceProviders(input) {
+        return (input.resource === "sleep_cycle" || input.resource === "sleep") &&
+            hasJunctionSourceReferenceIdentity(input.record);
+    }
     async function diagnoseBackfill(context) {
         const window = resolveDiagnosticBackfillWindow(context, summaryBackfillDays);
         const timeseriesProbeDays = normalizeDiagnosticTimeseriesProbeDays(context.timeseriesProbeDays);
@@ -634,6 +629,15 @@ export function createJunctionDeviceSyncProvider(config) {
                 });
             }
         }
+        const summaryNormalizationEvidence = providerSnapshot.ok
+            ? classifyJunctionSummaryNormalizationEvidence({
+                connections: sanitizeJunctionImportConnections(sourceProviders),
+                importedAt: window.windowEnd,
+                summaries: sanitizeJunctionImportSnapshots(summaries, sourceProviders),
+                windowEnd: window.windowEnd,
+                windowStart: window.windowStart,
+            })
+            : [];
         return {
             generatedAt: context.now,
             provider: "junction",
@@ -646,9 +650,7 @@ export function createJunctionDeviceSyncProvider(config) {
                 window,
                 sourceProviders: describeJunctionDiagnosticSourceProviders(providerSnapshot),
                 summary: {
-                    hasUsefulHistoricalRecords: providerSnapshot.ok
-                        ? hasJunctionHistoricalBackfillSummaryRecords(summaries, sourceProviders)
-                        : false,
+                    hasUsefulHistoricalRecords: hasJunctionHistoricalBackfillSummaryRecords(summaryNormalizationEvidence),
                     resources: summaryDiagnostics,
                 },
                 timeseriesProbe: {
@@ -688,17 +690,17 @@ export function createJunctionDeviceSyncProvider(config) {
         }
         if (endpoint === "introspect_resources" || endpoint === "historical_pull") {
             const sourceProviderSlug = normalizeProviderSlug(context.sourceProviderSlug);
-            const payloadResult = await runJunctionDiagnosticPayloadCall(() => endpoint === "introspect_resources"
-                ? client.introspectResources({
+            const response = endpoint === "introspect_resources"
+                ? describeJunctionIntrospectionResources(await runJunctionDiagnosticPayloadCall(() => client.introspectResources({
                     sourceProviderSlug,
                     userId: context.account.externalAccountId,
                     userLimit: 1,
-                })
-                : client.introspectHistoricalPull({
+                })), sourceProviderSlug)
+                : describeJunctionIntrospectionHistoricalPull(await runJunctionDiagnosticPayloadCall(() => client.introspectHistoricalPull({
                     sourceProviderSlug,
                     userId: context.account.externalAccountId,
                     userLimit: 1,
-                }));
+                })), sourceProviderSlug);
             return {
                 generatedAt: context.now,
                 provider: "junction",
@@ -715,9 +717,7 @@ export function createJunctionDeviceSyncProvider(config) {
                         }),
                         sourceFiltered: Boolean(sourceProviderSlug),
                     },
-                    response: endpoint === "introspect_resources"
-                        ? describeJunctionIntrospectionResources(payloadResult, sourceProviderSlug)
-                        : describeJunctionIntrospectionHistoricalPull(payloadResult, sourceProviderSlug),
+                    response,
                 },
             };
         }
@@ -821,18 +821,63 @@ export function createJunctionDeviceSyncProvider(config) {
         };
     }
     async function executeResourceJob(context, job, skippedOptionalResources) {
+        if (normalizeString(job.payload.resource) === COMPANION_HRV_RMSSD_RESOURCE) {
+            let observation;
+            let admissionId;
+            try {
+                observation = parseSerializedCompanionHrvRmssdObservation(job.payload.companionObservationJson);
+                admissionId = parseCompanionHrvRmssdAdmissionId(job.payload.companionAdmissionId);
+                const expectedAdmissionId = createHash("sha256")
+                    .update(serializeCompanionHrvRmssdObservation(observation))
+                    .digest("hex");
+                if (admissionId !== expectedAdmissionId) {
+                    throw new TypeError("Companion HRV admission identity did not match its observation.");
+                }
+            }
+            catch {
+                throw deviceSyncError({
+                    code: JUNCTION_COMPANION_HRV_OBSERVATION_INVALID_CODE,
+                    message: "Companion HRV observation payload was invalid.",
+                    retryable: false,
+                });
+            }
+            await context.importSnapshot({
+                provider: "junction",
+                accountId: buildJunctionImportAccountId(context.account.externalAccountId),
+                connectionId: context.account.id,
+                importedAt: context.now,
+                companionHrvRmssd: [{ admissionId, observation }],
+            });
+            return {};
+        }
         const window = resolveJobWindow(job, context.now, reconcileDays);
+        if (normalizeString(job.payload.resource) === JUNCTION_COMPANION_HEALTH_METADATA_RESOURCE) {
+            const records = parseJunctionCompanionHealthMetadataJob(job);
+            await importJunctionCompanionHealthMetadataSnapshot(context, records);
+            return {
+                nextReconcileAt: clampWebhookJobNextReconcileAt(context),
+            };
+        }
         const resource = normalizeJunctionResourceName(job.payload.resource);
         const resourceCategory = normalizeString(job.payload.resourceCategory);
         const sourceProviderSlug = normalizeProviderSlug(job.payload.sourceProviderSlug);
+        let listedSourceProviders = null;
         let projectedSourceProviders = null;
-        const loadAndProjectSourceProviders = async () => {
-            if (projectedSourceProviders) {
-                return projectedSourceProviders;
+        const loadSourceProviders = async () => {
+            if (listedSourceProviders) {
+                return listedSourceProviders;
             }
             const sourceProviders = await client.listUserProviders(context.account.externalAccountId, {
                 signal: context.signal ?? null,
             });
+            listedSourceProviders = sourceProviders;
+            return sourceProviders;
+        };
+        const loadAndProjectSourceProviders = async () => {
+            if (projectedSourceProviders) {
+                return projectedSourceProviders;
+            }
+            const sourceProviders = await loadSourceProviders();
             await projectJunctionSources(context, sourceProviders);
             projectedSourceProviders = sourceProviders;
             return sourceProviders;
@@ -891,10 +936,13 @@ export function createJunctionDeviceSyncProvider(config) {
             }
             const directInput = readJunctionDirectResourceJobInput(job, window);
             if (directInput) {
-                await importJunctionDirectResourceSnapshot(context, [], directInput.windowStart, directInput.windowEnd, directInput.resource, [directInput.record]);
-                return {
-                    nextReconcileAt: clampWebhookJobNextReconcileAt(context),
-                };
+                const sourceProviders = shouldLoadJunctionDirectResourceSourceProviders(directInput)
+                    ? await loadSourceProviders()
+                    : [];
+                const connectHistoricalWindow = buildConnectHistoricalBackfillWindow(context.account, summaryBackfillDays);
+                const importResult = await importJunctionDirectResourceSnapshot(context, sourceProviders, directInput.windowStart, directInput.windowEnd, directInput.resource, [directInput.record], connectHistoricalWindow);
+                const directHistoricalWindow = readJunctionDirectHistoricalEvidenceWindow(directInput, connectHistoricalWindow, importResult.normalizationEvidence, providerFilter);
+                return withJunctionHistoricalCoverageVerification(context, job, directHistoricalWindow, withJunctionDirectHistoricalBackfillEvidence(context, job, directInput, directHistoricalWindow, importResult, { nextReconcileAt: clampWebhookJobNextReconcileAt(context) }));
             }
             if (inferredCategory === "timeseries") {
                 const sourceProviders = await loadAndProjectSourceProviders();
@@ -907,9 +955,9 @@ export function createJunctionDeviceSyncProvider(config) {
                         windowStart: timeseriesImport.yieldedAt,
                     }), skippedOptionalResources);
                 }
-                return withJunctionSkippedResourceMetadata(context, {
+                return withJunctionHistoricalCoverageVerification(context, job, window, withJunctionSkippedResourceMetadata(context, {
                     nextReconcileAt: clampWebhookJobNextReconcileAt(context),
-                }, skippedOptionalResources);
+                }, skippedOptionalResources));
             }
             const dateQueryFormat = isFullUtcDayWindow(window) ? "date" : "datetime";
             summaries[effectiveResource] = await fetchOptionalJunctionResourceRecords(context, "summary", effectiveResource, skippedOptionalResources, () => client.listSummary({
@@ -934,9 +982,9 @@ export function createJunctionDeviceSyncProvider(config) {
             summaries: sanitizeJunctionImportSnapshots(summaries, sourceProviders),
             timeseries: {},
         });
-        return withJunctionSkippedResourceMetadata(context, {
+        return withJunctionHistoricalCoverageVerification(context, job, window, withJunctionSkippedResourceMetadata(context, {
             nextReconcileAt: clampWebhookJobNextReconcileAt(context),
-        }, skippedOptionalResources);
+        }, skippedOptionalResources));
     }
     function isConfiguredJunctionResource(category, resource) {
         return category === "timeseries"
@@ -976,6 +1024,75 @@ export function createJunctionDeviceSyncProvider(config) {
             ? scheduledAt
             : latestAt;
     }
+    function withJunctionHistoricalCoverageVerification(context, job, resourceWindow, result) {
+        const historicalState = readHistoricalBackfillStatus(context.account.metadata);
+        const eventType = normalizeString(job.payload.eventType);
+        if (!historicalState
+            || !resourceWindow
+            || historicalState.coverageVersion > JUNCTION_HISTORICAL_BACKFILL_COVERAGE_VERSION
+            || historicalState.status !== "exhausted"
+            || !eventType
+            || !isJunctionDataEvent(eventType)) {
+            return result;
+        }
+        const connectWindow = buildConnectHistoricalBackfillWindow(context.account, summaryBackfillDays);
+        if (Date.parse(resourceWindow.windowStart) >= Date.parse(connectWindow.windowEnd)
+            || Date.parse(resourceWindow.windowEnd) <= Date.parse(connectWindow.windowStart)) {
+            return result;
+        }
+        return {
+            ...result,
+            scheduledJobs: [
+                ...(result.scheduledJobs ?? []),
+                buildExactWindowJob({
+                    availableAt: context.now,
+                    kind: "backfill",
+                    priority: JUNCTION_HISTORICAL_BACKFILL_RETRY_PRIORITY,
+                    windowEnd: connectWindow.windowEnd,
+                    windowStart: connectWindow.windowStart,
+                }),
+            ],
+        };
+    }
+    function withJunctionDirectHistoricalBackfillEvidence(context, job, directInput, directHistoricalWindow, importResult, result) {
+        const eventType = normalizeString(job.payload.eventType);
+        const providerSlug = resolveJunctionHistoricalCoverageProviderSlug(directInput.sourceProviderSlug, providerFilter);
+        const acceptedCanonicalDelivery = importResult.durableDeliveryAccepted
+            && providerSlug !== null
+            && importResult.normalizationEvidence.some((entry) => entry.resource === directInput.resource
+                && canonicalizeJunctionHistoricalProviderSlug(entry.sourceProviderSlug) === providerSlug);
+        if (!canCurrentRuntimeMutateJunctionHistoricalBackfillProgress(context.account.metadata)
+            || !directHistoricalWindow
+            || !acceptedCanonicalDelivery
+            || !eventType
+            || !isJunctionDataEvent(eventType)
+            || !providerSlug
+            || !isJunctionHistoricalBackfillRequiredSummaryResource(directInput.resource)) {
+            return result;
+        }
+        const connectWindow = buildConnectHistoricalBackfillWindow(context.account, summaryBackfillDays);
+        const evidence = addJunctionHistoricalBackfillEvidence({
+            existingValue: context.account.metadata[JUNCTION_HISTORICAL_BACKFILL_METADATA_KEYS.evidence],
+            providerSlug,
+            resource: directInput.resource,
+            windowEnd: connectWindow.windowEnd,
+            windowStart: connectWindow.windowStart,
+        });
+        if (!evidence) {
+            context.logger.warn?.("Junction historical push evidence exceeded bounded metadata limits.", {
+                provider: "junction",
+                resource: directInput.resource,
+            });
+            return result;
+        }
+        return {
+            ...result,
+            metadataPatch: {
+                ...(result.metadataPatch ?? {}),
+                [JUNCTION_HISTORICAL_BACKFILL_METADATA_KEYS.evidence]: evidence,
+            },
+        };
+    }
     async function verifyAndParseWebhook(context) {
         const webhookSecret = normalizeString(config.webhookSecret);
         if (!webhookSecret) {
@@ -1088,22 +1205,18 @@ export function createJunctionDeviceSyncProvider(config) {
                 records.push(...filterJunctionTimeseriesRecordsToWindow(chunkRecords, chunkWindowStart, chunkWindowEnd));
             }
             catch (error) {
-                const failure = classifyOptionalJunctionResourceFailure(error, "timeseries", resource);
+                const failure = classifyOptionalJunctionResourceFailure(error, "timeseries", resource, context.account.externalAccountId);
                 if (!failure) {
                     throw error;
                 }
-                if (failure.disposition === "ambiguous") {
-                    throw buildAmbiguousOptionalJunctionResourceError(error, "timeseries", resource, failure.responseStatus, context.now);
-                }
                 if (!optionalFailureLogged) {
                     logSkippedOptionalJunctionResource(context, "timeseries", resource, failure);
                     optionalFailureLogged = true;
                 }
                 skippedOptionalResources.push({
-                    reason: failure.reason,
+                    ...failure,
                     resource,
                     resourceCategory: "timeseries",
-                    responseStatus: failure.responseStatus,
                 });
                 break;
             }
@@ -1180,18 +1293,56 @@ export function createJunctionDeviceSyncProvider(config) {
             yieldedAt: null,
         };
     }
-    async function importJunctionDirectResourceSnapshot(context, sourceProviders, windowStart, windowEnd, resource, records) {
-        const redactedRecords = records.map((record) => readPlainObject(sanitizeJunctionImportSnapshotValue(record, new Map(), { blockedStringValues: [context.account.externalAccountId] })) ?? record);
-        const snapshots = { [resource]: redactedRecords };
-        await context.importSnapshot({
+    async function importJunctionDirectResourceSnapshot(context, sourceProviders, windowStart, windowEnd, resource, records, historicalEvidenceWindow) {
+        const snapshots = { [resource]: [...records] };
+        const connections = sanitizeJunctionImportConnections(sourceProviders);
+        const summaries = sanitizeJunctionImportSnapshots(snapshots, sourceProviders, {
+            blockedStringValues: [context.account.externalAccountId],
+        });
+        const normalizationEvidence = classifyJunctionSummaryNormalizationEvidence({
+            connections,
+            importedAt: context.now,
+            summaries,
+            windowEnd,
+            windowStart,
+        }, historicalEvidenceWindow);
+        const receipt = await context.importSnapshot({
             provider: "junction",
             accountId: buildJunctionImportAccountId(context.account.externalAccountId),
             connectionId: context.account.id,
             importedAt: context.now,
             windowStart,
             windowEnd,
-            connections: sanitizeJunctionImportConnections(sourceProviders),
-            summaries: sanitizeJunctionImportSnapshots(snapshots, sourceProviders),
+            connections,
+            summaries,
+            timeseries: {},
+        });
+        return {
+            durableDeliveryAccepted: readProviderSnapshotDurableDeliveryAccepted(receipt),
+            normalizationEvidence,
+        };
+    }
+    async function importJunctionCompanionHealthMetadataSnapshot(context, records) {
+        const summaries = {};
+        const sleep = records
+            .filter((record) => record.kind === "recovery_score")
+            .map(buildJunctionCompanionRecoverySummary);
+        const activity = records
+            .filter((record) => record.kind === "workout_strain")
+            .map(buildJunctionCompanionWorkoutStrainSummary);
+        if (sleep.length > 0) {
+            summaries.sleep = sleep;
+        }
+        if (activity.length > 0) {
+            summaries.activity = activity;
+        }
+        await context.importSnapshot({
+            provider: "junction",
+            accountId: buildJunctionImportAccountId(context.account.externalAccountId),
+            windowStart: records.reduce((earliest, record) => minIsoTimestamp(earliest, record.startAt), records[0].startAt),
+            windowEnd: records.reduce((latest, record) => maxIsoTimestamp(latest, record.endAt), records[0].endAt),
+            connections: [],
+            summaries: sanitizeJunctionImportSnapshots(summaries, []),
             timeseries: {},
         });
     }
@@ -1200,19 +1351,15 @@ export function createJunctionDeviceSyncProvider(config) {
             return await load();
         }
         catch (error) {
-            const failure = classifyOptionalJunctionResourceFailure(error, resourceCategory, resource);
+            const failure = classifyOptionalJunctionResourceFailure(error, resourceCategory, resource, context.account.externalAccountId);
             if (!failure) {
                 throw error;
             }
-            if (failure.disposition === "ambiguous") {
-                throw buildAmbiguousOptionalJunctionResourceError(error, resourceCategory, resource, failure.responseStatus, context.now);
-            }
             logSkippedOptionalJunctionResource(context, resourceCategory, resource, failure);
             skippedOptionalResources.push({
-                reason: failure.reason,
+                ...failure,
                 resource,
                 resourceCategory,
-                responseStatus: failure.responseStatus,
             });
             return [];
         }
@@ -1225,6 +1372,7 @@ export function createJunctionDeviceSyncProvider(config) {
             resource,
             resourceCategory,
             responseStatus: failure.responseStatus,
+            ...(failure.responseDetail ? { responseDetail: failure.responseDetail } : {}),
         });
     }
     function buildYieldedJunctionJobResult(input) {
@@ -1240,7 +1388,28 @@ export function createJunctionDeviceSyncProvider(config) {
         if (Date.parse(input.windowStart) >= Date.parse(input.windowEnd)) {
             return null;
         }
-        if (input.job.kind === "backfill" || input.job.kind === "reconcile") {
+        if (input.job.kind === "backfill") {
+            const cursor = toIsoTimestampIfValid(input.timeseriesCursor);
+            if (!cursor || !isTimestampInHalfOpenWindow(cursor, input)) {
+                return null;
+            }
+            const emptyBackfillAttempts = readHistoricalBackfillJobEmptyAttempts(input.job);
+            const followUp = buildExactWindowJob({
+                kind: "backfill",
+                priority: input.job.priority,
+                windowEnd: input.windowEnd,
+                windowStart: input.windowStart,
+            });
+            return {
+                ...followUp,
+                payload: {
+                    ...followUp.payload,
+                    ...(emptyBackfillAttempts > 0 ? { emptyBackfillAttempts } : {}),
+                    timeseriesCursor: cursor,
+                },
+            };
+        }
+        if (input.job.kind === "reconcile") {
             return buildExactWindowJob({
                 kind: input.job.kind,
                 priority: input.job.priority,
@@ -1364,6 +1533,7 @@ function buildJunctionSkippedResourceMetadataPatch(context, skippedOptionalResou
             last.responseStatus,
             last.reason,
         ].join("."),
+        junctionSkippedResourceLastDetail: last.responseDetail ?? null,
     };
 }
 function readJunctionMetadataCount(value) {
@@ -1376,7 +1546,7 @@ function hasCheckedJunctionProfileSummary(metadata) {
     const checkedAt = normalizeString(metadata[JUNCTION_PROFILE_SUMMARY_CHECKED_AT_METADATA_KEY]);
     return checkedAt !== undefined && Number.isFinite(Date.parse(checkedAt));
 }
-function classifyOptionalJunctionResourceFailure(error, resourceCategory, resource) {
+function classifyOptionalJunctionResourceFailure(error, resourceCategory, resource, accountExternalId) {
     if (!isDeviceSyncError(error) || error.code !== "JUNCTION_API_REQUEST_FAILED") {
         return null;
     }
@@ -1392,7 +1562,6 @@ function classifyOptionalJunctionResourceFailure(error, resourceCategory, resour
     });
     if (reason) {
         return {
-            disposition: "skip",
             reason,
             responseStatus: status,
         };
@@ -1402,118 +1571,45 @@ function classifyOptionalJunctionResourceFailure(error, resourceCategory, resour
         && status === 404
         && isJunctionProfileSummaryNotFoundResponse({ responseErrorCode, responseErrorDescription })) {
         return {
-            disposition: "skip",
             reason: "not_found",
             responseStatus: status,
         };
     }
+    // Unrecognized 404/422 bodies skip only this optional resource. Keep the
+    // provider's own explanation (redacted) so operators can see why it failed
+    // without one broken optional endpoint aborting the whole sync job.
+    const responseDetail = buildJunctionOptionalResourceResponseDetail({
+        accountExternalId,
+        responseErrorCode,
+        responseErrorDescription,
+    });
     return {
-        disposition: "ambiguous",
+        reason: "ambiguous",
         responseStatus: status,
+        ...(responseDetail ? { responseDetail } : {}),
     };
 }
-function buildAmbiguousOptionalJunctionResourceError(error, resourceCategory, resource, responseStatus, now) {
-    const safeApiDetails = copySafeJunctionApiErrorDetails(error);
-    const safeResource = readJunctionDiagnosticToken(resource) ?? "unknown";
-    const responseErrorCode = readJunctionDiagnosticToken(safeApiDetails.responseErrorCode);
-    const responseShapeKind = readJunctionDiagnosticToken(safeApiDetails.responseShapeKind);
-    return deviceSyncError({
-        code: "JUNCTION_OPTIONAL_RESOURCE_RESPONSE_AMBIGUOUS",
-        message: `Junction ${resourceCategory} resource ${resource} returned an ambiguous ${responseStatus} response.`,
-        retryable: true,
-        httpStatus: 502,
-        details: {
-            ...safeApiDetails,
-            failureMetadataPatch: buildJunctionOptionalResourceFailureMetadataPatch({
-                at: now,
-                resource: safeResource,
-                resourceCategory,
-                responseErrorCode,
-                responseShapeKind,
-                responseStatus,
-            }),
-            providerOptionalResourceCategory: resourceCategory,
-            providerOptionalResourceFailureDisposition: "ambiguous",
-            providerOptionalResourceName: safeResource,
-            providerOptionalResourceStatus: responseStatus,
-        },
-        cause: error,
-    });
-}
-const JUNCTION_SAFE_API_DETAIL_TOKEN_KEYS = [
-    "requestAuthKind",
-    "requestAuthPlacement",
-    "requestBodyFieldNames",
-    "requestBodyKind",
-    "requestContentType",
-    "requestEndpointKind",
-    "requestMethod",
-    "requestQueryParameterNames",
-    "responseErrorCode",
-    "responseShapeKind",
-];
-const JUNCTION_SAFE_API_DETAIL_TEXT_KEYS = [
-    "httpStatusText",
-    "responseErrorDescription",
-];
-const JUNCTION_SAFE_API_DETAIL_NUMBER_KEYS = [
-    "requestBodyFieldCount",
-    "requestQueryParameterCount",
-    "status",
-];
-const JUNCTION_SAFE_API_DETAIL_BOOLEAN_KEYS = [
-    "requestCredentialPresent",
-    "responseErrorDescriptionFieldPresent",
-    "responseErrorFieldPresent",
-];
-function copySafeJunctionApiErrorDetails(error) {
-    if (!isDeviceSyncError(error) || !error.details) {
-        return {};
-    }
-    const details = {};
-    for (const key of JUNCTION_SAFE_API_DETAIL_TOKEN_KEYS) {
-        const value = readJunctionDiagnosticToken(error.details[key]);
-        if (value !== null) {
-            details[key] = value;
-        }
-    }
-    for (const key of JUNCTION_SAFE_API_DETAIL_TEXT_KEYS) {
-        const value = readJunctionDiagnosticText(error.details[key]);
-        if (value !== null) {
-            details[key] = value;
-        }
-    }
-    for (const key of JUNCTION_SAFE_API_DETAIL_NUMBER_KEYS) {
-        const value = readJunctionDiagnosticNumber(error.details[key]);
-        if (value !== null) {
-            details[key] = value;
-        }
-    }
-    for (const key of JUNCTION_SAFE_API_DETAIL_BOOLEAN_KEYS) {
-        if (typeof error.details[key] === "boolean") {
-            details[key] = error.details[key];
-        }
-    }
-    return details;
-}
-function buildJunctionOptionalResourceFailureMetadataPatch(input) {
-    const metadataPatch = {
-        junctionResourceDiagnostic: [
-            input.resourceCategory,
-            input.resource,
-            input.responseStatus,
-            "ambiguous",
-        ].join("."),
-        junctionResourceDiagnosticAt: input.at,
-        junctionResourceDiagnosticHttpStatus: input.responseStatus,
-    };
-    if (input.responseErrorCode) {
-        metadataPatch.junctionResourceDiagnosticCode = input.responseErrorCode;
-    }
-    if (input.responseShapeKind) {
-        metadataPatch.junctionResourceDiagnosticShape = input.responseShapeKind;
-    }
-    return metadataPatch;
+function buildJunctionOptionalResourceResponseDetail(input) {
+    // The generic redactor does not know the current Junction user id; strip it
+    // explicitly before the shared sanitizer so provider prose that embeds the
+    // account id can never reach logs or connection metadata. Case-insensitive
+    // because the provider-diagnostics parser lowercases error codes.
+    const accountIdPattern = input.accountExternalId
+        ? new RegExp(input.accountExternalId.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&"), "giu")
+        : null;
+    const redactAccountId = (value) => value === null || accountIdPattern === null
+        ? value
+        : value.replace(accountIdPattern, "<redacted-account>");
+    const code = readJunctionDiagnosticToken(redactAccountId(input.responseErrorCode));
+    const description = readJunctionDiagnosticText(redactAccountId(input.responseErrorDescription));
+    // Clamp to the stored-metadata string cap so the persisted
+    // junctionSkippedResourceLastDetail is truncated instead of silently dropped.
+    const detail = [code, description]
+        .filter(Boolean)
+        .join(": ")
+        .slice(0, DEVICE_SYNC_METADATA_MAX_STRING_LENGTH)
+        .trimEnd();
+    return detail || null;
 }
 function classifyClearOptionalJunctionResourceFailureReason(input) {
     const rawDescription = input.responseErrorDescription?.trim() ?? "";
@@ -1603,10 +1699,9 @@ function readJunctionDiagnosticToken(value) {
         return null;
     }
     const token = value.trim();
-    return /^[A-Za-z0-9_.:-]{1,128}$/u.test(token) ? token : null;
-}
-function readJunctionDiagnosticNumber(value) {
-    return typeof value === "number" && Number.isFinite(value) ? value : null;
+    return /^[A-Za-z0-9_.:-]{1,128}$/u.test(token) && !isHostedRuntimeIdShapedDiagnosticToken(token)
+        ? token
+        : null;
 }
 async function runJunctionDiagnosticCall(load) {
     try {
@@ -1997,40 +2092,27 @@ function describeJunctionIntrospectionHistoricalPull(result, requestedSourceProv
     if (!result.ok) {
         return describeJunctionDiagnosticPayloadFailure(result, "JUNCTION_INTROSPECT_HISTORICAL_PULL_FAILED");
     }
-    const sourceProviders = extractJunctionIntrospectionSourceProviders(result.payload, requestedSourceProviderSlug);
+    const sourceProviders = (result.payload?.sources ?? []).filter((source) => !requestedSourceProviderSlug
+        || normalizeProviderSlug(source.sourceProviderSlug) === requestedSourceProviderSlug);
     const sourceKeyMap = buildJunctionDiagnosticSourceKeyMap(sourceProviders);
     const pulled = [];
     const notPulled = [];
     for (const sourceProvider of sourceProviders) {
-        const notPulledResources = Array.isArray(sourceProvider.details.not_pulled)
-            ? sourceProvider.details.not_pulled
-                .map(normalizeProviderSlug)
-                .filter((entry) => Boolean(entry))
-            : [];
-        for (const resource of notPulledResources) {
+        for (const resource of sourceProvider.notPulledResources) {
             notPulled.push({
                 resource,
                 sourceKey: readJunctionDiagnosticSourceKey(sourceKeyMap, sourceProvider.sourceProviderSlug),
             });
         }
-        const pulledByResource = readPlainObject(sourceProvider.details.pulled);
-        if (!pulledByResource) {
-            continue;
-        }
-        for (const [resource, rawDetails] of Object.entries(pulledByResource)) {
-            const details = readPlainObject(rawDetails) ?? {};
-            const timeline = readPlainObject(details.timeline);
+        for (const historicalResource of sourceProvider.pulledResources) {
             pulled.push({
-                resource,
+                resource: historicalResource.resource,
                 sourceKey: readJunctionDiagnosticSourceKey(sourceKeyMap, sourceProvider.sourceProviderSlug),
-                status: normalizeString(details.status) ?? null,
-                daysWithData: readSafeInteger(details.days_with_data ?? details.daysWithData),
-                rangeStart: normalizeString(details.range_start ?? details.rangeStart) ?? null,
-                rangeEnd: normalizeString(details.range_end ?? details.rangeEnd) ?? null,
-                scheduledAt: normalizeString(timeline?.scheduled_at ?? timeline?.scheduledAt) ?? null,
-                startedAt: normalizeString(timeline?.started_at ?? timeline?.startedAt) ?? null,
-                endedAt: normalizeString(timeline?.ended_at ?? timeline?.endedAt) ?? null,
-                hasErrorDetails: Boolean(normalizeString(details.error_details ?? details.errorDetails)),
+                status: historicalResource.status,
+                daysWithData: historicalResource.daysWithData,
+                rangeStart: historicalResource.rangeStart,
+                rangeEnd: historicalResource.rangeEnd,
+                hasErrorDetails: historicalResource.errorDetails !== null,
             });
         }
     }
@@ -2039,6 +2121,7 @@ function describeJunctionIntrospectionHistoricalPull(result, requestedSourceProv
     return {
         ok: true,
         responseStatus: result.responseStatus ?? 200,
+        matchedUser: result.payload?.matchedUser ?? false,
         sourceProviderCount: sourceProviders.length,
         pulledCount: pulled.length,
         notPulledCount: notPulled.length,
@@ -2282,7 +2365,7 @@ function listJunctionDiagnosticAvailableResourcesForSlug(providers, slug) {
             continue;
         }
         for (const [key, value] of Object.entries(provider.resourceAvailability)) {
-            if (normalizeProviderSlug(key) && value !== false && value !== null && value !== undefined) {
+            if (normalizeProviderSlug(key) && isJunctionResourceAdvertisedAvailable(value)) {
                 resourceNames.add(key);
             }
         }
@@ -2292,8 +2375,10 @@ function listJunctionDiagnosticAvailableResourcesForSlug(providers, slug) {
         .slice(0, JUNCTION_DIAGNOSTIC_RESOURCE_NAME_LIMIT);
 }
 function readJunctionHistoricalBackfillMetadata(metadata) {
+    const statusState = readHistoricalBackfillStatus(metadata);
     return {
-        status: normalizeString(metadata[JUNCTION_HISTORICAL_BACKFILL_METADATA_KEYS.status]) ?? null,
+        coverageVersion: statusState?.coverageVersion ?? 0,
+        status: statusState?.status ?? null,
         emptyAttempts: typeof metadata[JUNCTION_HISTORICAL_BACKFILL_METADATA_KEYS.emptyAttempts] === "number"
             ? metadata[JUNCTION_HISTORICAL_BACKFILL_METADATA_KEYS.emptyAttempts]
             : null,
@@ -2383,32 +2468,6 @@ function toClientConfig(config) {
         fetchImpl: config.fetchImpl,
     };
 }
-function normalizeRequiredResourceList(value, defaults, allowedResources, label) {
-    const normalized = (value && value.length > 0 ? value : defaults)
-        .map(normalizeJunctionResourceName)
-        .filter((entry) => entry !== null);
-    const allowedResourceSet = new Set(allowedResources);
-    const unsupportedResources = normalized.filter((entry) => !allowedResourceSet.has(entry));
-    if (unsupportedResources.length > 0) {
-        throw new TypeError(`Junction ${label} resources include unsupported resource(s): ${[...new Set(unsupportedResources)].join(", ")}.`);
-    }
-    if (normalized.length === 0) {
-        throw new TypeError(`Junction ${label} resources must include at least one supported resource.`);
-    }
-    return [...new Set(normalized)];
-}
-function normalizeOptionalResourceList(value, defaults, allowedResources, knownResources, label) {
-    const normalized = (value === undefined ? defaults : value)
-        .map(normalizeJunctionResourceName)
-        .filter((entry) => entry !== null);
-    const allowedResourceSet = new Set(allowedResources);
-    const knownResourceSet = new Set([...allowedResources, ...knownResources]);
-    const unsupportedResources = normalized.filter((entry) => !knownResourceSet.has(entry));
-    if (unsupportedResources.length > 0) {
-        throw new TypeError(`Junction ${label} resources include unsupported resource(s): ${[...new Set(unsupportedResources)].join(", ")}.`);
-    }
-    return [...new Set(normalized.filter((entry) => allowedResourceSet.has(entry)))];
-}
 function normalizeProviderSlug(value) {
     const normalized = normalizeString(value)?.toLowerCase().replace(/[^a-z0-9_]+/gu, "_").replace(/^_+|_+$/gu, "");
     return normalized || null;
@@ -2422,11 +2481,11 @@ function sanitizeJunctionImportConnections(providers) {
         sourceInstanceId: provider.origin.sourceInstanceId,
     }));
 }
-function sanitizeJunctionImportSnapshots(snapshots, providers) {
+function sanitizeJunctionImportSnapshots(snapshots, providers, options = {}) {
     const sourceReferences = buildJunctionSourceReferenceMap(providers);
     return Object.fromEntries(Object.entries(snapshots).map(([resource, records]) => [
         resource,
-        records.map((record) => sanitizeJunctionImportSnapshotValue(record, sourceReferences)),
+        records.map((record) => sanitizeJunctionImportSnapshotValue(record, sourceReferences, options)),
     ]));
 }
 function buildJunctionSourceReferenceMap(providers) {
@@ -2463,11 +2522,17 @@ function sanitizeJunctionImportSnapshotValue(value, sourceReferences, options =
     const fallback = readJunctionSourceReference(record, sourceReferences);
     const origin = resolveJunctionOrigin(record, fallback);
     const sanitized = stripJunctionRawSourceIdentityFields(record, sourceReferences, options);
+    const fallbackSourceInstanceId = normalizeString(fallback.sourceInstanceId);
+    const unresolvedPreservedSourceReference = options.preserveSourceReferenceKeys === true &&
+        !fallbackSourceInstanceId &&
+        hasJunctionSourceReferenceIdentity(record);
+    const sourceInstanceId = fallbackSourceInstanceId ??
+        (unresolvedPreservedSourceReference ? undefined : origin.sourceInstanceId);
     return stripUndefined({
         ...sanitized,
         sourceProviderSlug: normalizeProviderSlug(origin.sourceProviderSlug) ?? sanitized.sourceProviderSlug,
         sourceType: origin.sourceType ?? sanitized.sourceType,
-        sourceInstanceId: origin.sourceInstanceId ?? sanitized.sourceInstanceId,
+        sourceInstanceId: sourceInstanceId ?? sanitized.sourceInstanceId,
     });
 }
 function readJunctionSourceReference(record, sourceReferences) {
@@ -2491,7 +2556,8 @@ function readJunctionSourceReference(record, sourceReferences) {
 function stripJunctionRawSourceIdentityFields(record, sourceReferences, options) {
     const sanitized = {};
     for (const [key, value] of Object.entries(record)) {
-        if (isBlockedJunctionImportSourceIdentityKey(key)
+        if ((isBlockedJunctionImportSourceIdentityKey(key)
+            && !(options.preserveSourceReferenceKeys && isJunctionSourceReferenceIdentityKey(key)))
             || isBlockedJunctionImportSourceIdentityContainerKey(key)) {
             continue;
         }
@@ -2533,6 +2599,24 @@ function isBlockedJunctionImportSourceIdentityKey(key) {
         || normalized.includes("devicename")
         || normalized.includes("appname");
 }
+function isJunctionSourceReferenceIdentityKey(key) {
+    const normalized = normalizeJunctionImportSourceIdentityKey(key);
+    return normalized === "connectionid"
+        || normalized === "providerconnectionid"
+        || normalized === "sourceid";
+}
+function hasJunctionSourceReferenceIdentity(value, seen = new Set()) {
+    if (Array.isArray(value)) {
+        return value.some((entry) => hasJunctionSourceReferenceIdentity(entry, seen));
+    }
+    const record = readPlainObject(value);
+    if (!record || seen.has(record)) {
+        return false;
+    }
+    seen.add(record);
+    return Object.entries(record).some(([key, nested]) => (isJunctionSourceReferenceIdentityKey(key) && normalizeString(nested) !== undefined) ||
+        hasJunctionSourceReferenceIdentity(nested, seen));
+}
 function isBlockedJunctionImportSourceIdentityContainerKey(key) {
     const normalized = normalizeJunctionImportSourceIdentityKey(key);
     return isJunctionRawDirectIdentityContainerKey(key)
@@ -2724,6 +2808,22 @@ function resolveJobWindow(job, now, fallbackDays) {
         windowEnd,
     };
 }
+function readBackfillTimeseriesCursor(job, ownerWindow) {
+    const cursor = toIsoTimestampIfValid(job.payload.timeseriesCursor);
+    return cursor && isTimestampInHalfOpenWindow(cursor, ownerWindow)
+        ? cursor
+        : null;
+}
+function isTimestampInHalfOpenWindow(timestamp, window) {
+    const timestampMs = Date.parse(timestamp);
+    const windowStartMs = Date.parse(window.windowStart);
+    const windowEndMs = Date.parse(window.windowEnd);
+    return Number.isFinite(timestampMs)
+        && Number.isFinite(windowStartMs)
+        && Number.isFinite(windowEndMs)
+        && timestampMs >= windowStartMs
+        && timestampMs < windowEndMs;
+}
 function resolveCurrentSummaryWindow(now, fallbackDays) {
     const windowEnd = new Date(now).toISOString();
     return {
@@ -2810,239 +2910,172 @@ function floorUtcDayTimestamp(timestamp) {
 function hasJunctionSnapshotRecords(snapshot) {
     return Object.values(snapshot).some((records) => records.length > 0);
 }
-function hasJunctionHistoricalBackfillSummaryRecords(snapshot, sourceProviders) {
-    const sourceReferences = buildJunctionSourceReferenceMap(sourceProviders);
-    return Object.entries(snapshot).some(([resource, records]) => isJunctionHistoricalBackfillCompletionSummaryResource(resource)
-        && records.some((record) => expandJunctionHistoricalBackfillSummaryRecord(record).some(({ entry, originFallback }) => hasUsefulJunctionHistoricalBackfillSummaryRecord(resource, entry, resolveJunctionSummarySourceProviderSlug(entry, originFallback, sourceReferences)))));
-}
-function isJunctionHistoricalBackfillCompletionSummaryResource(resource) {
-    return JUNCTION_HISTORICAL_BACKFILL_COMPLETION_SUMMARY_RESOURCE_SET.has(resource);
-}
-function hasUsefulJunctionHistoricalBackfillSummaryRecord(resource, entry, sourceProviderSlug, options = {}) {
-    if (!sourceProviderSlug) {
-        return false;
-    }
-    if (resource !== "sleep_cycle"
-        && !isJunctionSourceSpecificFloatingTimestampProvider(sourceProviderSlug)
-        && hasFiniteNumberFromJunctionRecordPaths(entry, JUNCTION_HISTORICAL_SUMMARY_METRIC_PATHS[resource])) {
-        return true;
-    }
-    if (resource === "sleep") {
-        return hasPositiveJunctionTimestampRange(entry, JUNCTION_SLEEP_START_TIMESTAMP_PATHS, JUNCTION_SLEEP_END_TIMESTAMP_PATHS, sourceProviderSlug);
-    }
-    if (resource === "sleep_cycle") {
-        return ((options.acceptSleepCycleStageCount ?? true)
-            && hasPositiveFiniteNumberFromJunctionRecordPaths(entry, JUNCTION_SLEEP_STAGE_COUNT_PATHS))
-            || hasUsefulJunctionSleepCycleStageRecord(entry, sourceProviderSlug);
-    }
-    if (resource === "workouts") {
-        return hasUsefulJunctionWorkoutSessionRecord(entry, sourceProviderSlug);
-    }
-    if (resource === "meal" || resource === "menstrual_cycle" || resource === "electrocardiogram") {
-        return hasUsefulJunctionRawOnlyHistoricalBackfillSummaryRecord(resource, entry);
-    }
-    return false;
-}
-function hasUsefulJunctionRawOnlyHistoricalBackfillSummaryRecord(resource, entry) {
-    // Mirrors the importer invariant: predicted cycles are forecasts, not
-    // facts — they emit no normalized events, so forecast-only windows must
-    // not complete the historical backfill.
-    if (resource === "menstrual_cycle"
-        && (entry.isPredicted === true || entry.is_predicted === true)) {
-        return false;
-    }
-    const paths = JUNCTION_RAW_ONLY_COMPLETION_PATHS[resource];
-    return hasStringFromJunctionRecordPaths(entry, paths.strings)
-        || hasFiniteNumberFromJunctionRecordPaths(entry, paths.numbers)
-        || hasNonEmptyJunctionRecordArrayFromPaths(entry, paths.arrays);
-}
-function hasUsefulJunctionSleepCycleStageRecord(entry, sourceProviderSlug) {
-    return collectJunctionSleepCycleStageRecords(entry).some((stage) => hasUsefulJunctionSleepCycleStageInterval(stage, sourceProviderSlug));
-}
-function hasJunctionSleepStageValue(entry) {
-    return JUNCTION_SLEEP_STAGE_VALUE_PATHS.some((path) => normalizeJunctionSleepStageValue(readJunctionRecordPath(entry, path)) !== null);
-}
-function collectJunctionSleepCycleStageRecords(value) {
-    if (Array.isArray(value)) {
-        return value.flatMap((entry) => collectJunctionSleepCycleStageRecords(entry));
-    }
-    const entry = readPlainObject(value);
-    if (!entry) {
-        return [];
-    }
-    if (hasJunctionSleepStageValue(entry)) {
-        return [entry];
-    }
-    return JUNCTION_SLEEP_STAGE_ARRAY_PATHS.flatMap((path) => {
-        const nested = readJunctionRecordPath(entry, path);
-        return nested === value ? [] : collectJunctionSleepCycleStageRecords(nested);
-    });
-}
-function hasUsefulJunctionSleepCycleStageInterval(entry, sourceProviderSlug) {
-    return hasPositiveFiniteNumberFromJunctionRecordPaths(entry, JUNCTION_SLEEP_STAGE_DURATION_PATHS)
-        || hasPositiveJunctionTimestampRange(entry, JUNCTION_SLEEP_START_TIMESTAMP_PATHS, JUNCTION_SLEEP_END_TIMESTAMP_PATHS, sourceProviderSlug);
-}
-function expandJunctionHistoricalBackfillSummaryRecord(value) {
-    const record = readPlainObject(value);
-    if (!record) {
-        return [];
-    }
-    const nestedEntries = readNestedJunctionHistoricalBackfillSummaryEntries(record);
-    if (!nestedEntries) {
-        return [{ entry: record }];
+function hasJunctionHistoricalBackfillSummaryRecords(evidence) {
+    return evidence.some(({ resource }) => isJunctionHistoricalBackfillCompletionSummaryResource(resource));
+}
+function evaluateJunctionHistoricalBackfillCoverage(summaryEvidence, sourceProviders, configuredSummaryResources, providerFilter, historicalPullSnapshot, historicalPushEvidence, window) {
+    const configuredResources = new Set(configuredSummaryResources.filter((resource) => JUNCTION_HISTORICAL_BACKFILL_REQUIRED_SUMMARY_RESOURCE_SET.has(resource)));
+    const advertisedResourcesByProvider = new Map();
+    const connectedProviderSlugs = new Set();
+    const pendingProviderSlugs = new Set();
+    const reconnectProviderSlugs = new Set();
+    const providerStatusBySlug = new Map();
+    for (const provider of sourceProviders) {
+        const providerSlug = resolveJunctionHistoricalCoverageProviderSlug(provider.origin.sourceProviderSlug ?? provider.slug, providerFilter);
+        if (!providerSlug) {
+            continue;
+        }
+        const status = mapJunctionSourceStatus(provider.status);
+        const existingStatus = providerStatusBySlug.get(providerSlug);
+        providerStatusBySlug.set(providerSlug, existingStatus ? mergeJunctionSourceStatus(existingStatus, status) : status);
+        for (const [rawResource, availability] of Object.entries(provider.resourceAvailability)) {
+            const resource = normalizeJunctionResourceName(rawResource);
+            if (!resource
+                || !configuredResources.has(resource)
+                || !isJunctionResourceAdvertisedAvailable(availability)) {
+                continue;
+            }
+            const advertisedResources = advertisedResourcesByProvider.get(providerSlug) ?? new Set();
+            advertisedResources.add(resource);
+            advertisedResourcesByProvider.set(providerSlug, advertisedResources);
+        }
     }
-    return nestedEntries.map((entry) => ({
-        entry,
-        originFallback: record,
-    }));
-}
-function readNestedJunctionHistoricalBackfillSummaryEntries(record) {
-    for (const key of ["data", "results", "items", "records"]) {
-        const directEntry = readPlainObject(record[key]);
-        const entries = directEntry
-            ? [directEntry]
-            : readJunctionRecordArray(record[key]).flatMap((entry) => {
-                const normalized = readPlainObject(entry);
-                return normalized ? [normalized] : [];
-            });
-        if (entries.length > 0) {
-            return entries;
+    const historicalSourcesByProvider = new Map(historicalPullSnapshot?.matchedUser
+        ? historicalPullSnapshot.sources.flatMap((source) => {
+            const providerSlug = resolveJunctionHistoricalCoverageProviderSlug(source.sourceProviderSlug, providerFilter);
+            return providerSlug ? [[providerSlug, source]] : [];
+        })
+        : []);
+    for (const [providerSlug, status] of providerStatusBySlug.entries()) {
+        if (status === "disconnected") {
+            continue;
+        }
+        const historicalSource = historicalSourcesByProvider.get(providerSlug);
+        const notPulledResources = new Set(historicalSource?.notPulledResources.flatMap((value) => {
+            const resource = normalizeJunctionResourceName(value);
+            return resource ? [resource] : [];
+        }) ?? []);
+        const historicalResources = new Map(historicalSource?.pulledResources.flatMap((entry) => {
+            const resource = normalizeJunctionResourceName(entry.resource);
+            return resource && configuredResources.has(resource)
+                ? [[resource, entry]]
+                : [];
+        }) ?? []);
+        const requiredResources = new Set([
+            ...(advertisedResourcesByProvider.get(providerSlug) ?? []),
+            ...historicalResources.keys(),
+        ].filter((resource) => !notPulledResources.has(resource) || historicalResources.has(resource)));
+        if (status === "connected") {
+            connectedProviderSlugs.add(providerSlug);
+        }
+        if (requiredResources.size === 0) {
+            continue;
+        }
+        if (status !== "connected") {
+            pendingProviderSlugs.add(providerSlug);
+            continue;
+        }
+        let hasPendingResource = false;
+        let everyPendingResourceFailed = true;
+        for (const resource of requiredResources) {
+            if (!isJunctionHistoricalBackfillRequiredSummaryResource(resource)) {
+                continue;
+            }
+            const historicalResource = historicalResources.get(resource);
+            if (historicalSource) {
+                if (historicalResource?.status === "success") {
+                    continue;
+                }
+                hasPendingResource = true;
+                if (historicalResource?.status !== "failure") {
+                    everyPendingResourceFailed = false;
+                }
+                continue;
+            }
+            const coveredBySummary = summaryEvidence.some((entry) => entry.resource === resource
+                && canonicalizeJunctionHistoricalProviderSlug(entry.sourceProviderSlug) === providerSlug);
+            const coveredByPush = hasJunctionHistoricalBackfillEvidence(historicalPushEvidence, providerSlug, resource, window.windowStart, window.windowEnd);
+            if (!coveredBySummary && !coveredByPush) {
+                hasPendingResource = true;
+                everyPendingResourceFailed = false;
+            }
+        }
+        if (hasPendingResource) {
+            pendingProviderSlugs.add(providerSlug);
+            if (everyPendingResourceFailed
+                && isJunctionHistoricalResetProviderSlug(providerSlug)) {
+                reconnectProviderSlugs.add(providerSlug);
+            }
         }
     }
-    return null;
-}
-function resolveJunctionSummarySourceProviderSlug(entry, originFallback, sourceReferences) {
-    const resolvedOrigin = resolveJunctionOrigin(entry, buildJunctionSummarySourceFallback(entry, originFallback, sourceReferences));
-    return resolvedOrigin.sourceProviderSlug ?? null;
-}
-function buildJunctionSummarySourceFallback(entry, originFallback, sourceReferences) {
-    const entryReference = readJunctionSourceReference(entry, sourceReferences);
-    const fallbackReference = originFallback
-        ? readJunctionSourceReference(originFallback, sourceReferences)
-        : {};
+    const sortedPendingProviderSlugs = [...pendingProviderSlugs]
+        .sort((left, right) => left.localeCompare(right));
     return {
-        ...(originFallback ?? {}),
-        ...fallbackReference,
-        ...entryReference,
+        complete: connectedProviderSlugs.size > 0 && sortedPendingProviderSlugs.length === 0,
+        pendingProviderSlugs: sortedPendingProviderSlugs,
+        reconnectProviderSlugs: [...reconnectProviderSlugs]
+            .sort((left, right) => left.localeCompare(right)),
     };
 }
-function hasUsefulJunctionWorkoutSessionRecord(entry, sourceProviderSlug) {
-    const hasDuration = hasPositiveFiniteNumberFromJunctionRecordPaths(entry, JUNCTION_WORKOUT_DURATION_MINUTE_PATHS)
-        || hasPositiveFiniteNumberFromJunctionRecordPaths(entry, JUNCTION_WORKOUT_DURATION_SECOND_PATHS)
-        || hasPositiveFiniteNumberFromJunctionRecordPaths(entry, JUNCTION_WORKOUT_DURATION_MILLISECOND_PATHS)
-        || hasPositiveJunctionTimestampRange(entry, JUNCTION_WORKOUT_START_TIMESTAMP_PATHS, JUNCTION_WORKOUT_END_TIMESTAMP_PATHS, sourceProviderSlug);
-    if (!hasDuration) {
-        return false;
+function canonicalizeJunctionHistoricalProviderSlug(value) {
+    const providerSlug = normalizeProviderSlug(value);
+    if (!providerSlug) {
+        return null;
     }
-    const startAt = firstJunctionTimestampMillisFromPaths(entry, JUNCTION_WORKOUT_START_TIMESTAMP_PATHS, sourceProviderSlug);
-    const endAt = firstJunctionTimestampMillisFromPaths(entry, JUNCTION_WORKOUT_END_TIMESTAMP_PATHS, sourceProviderSlug);
-    return startAt !== null || (endAt === null && !isJunctionSourceSpecificFloatingTimestampProvider(sourceProviderSlug));
+    return resolveJunctionDeviceConnectRouteByProviderSlug(providerSlug)?.route.sourceProviderSlug
+        ?? null;
 }
-function hasFiniteNumberFromJunctionRecordPaths(entry, paths) {
-    return paths.some((path) => finiteJunctionNumber(readJunctionRecordPath(entry, path)) !== undefined);
-}
-function hasStringFromJunctionRecordPaths(entry, paths) {
-    return paths.some((path) => normalizeString(readJunctionRecordPath(entry, path)) !== undefined);
-}
-function hasPositiveFiniteNumberFromJunctionRecordPaths(entry, paths) {
-    return paths.some((path) => {
-        const numeric = finiteJunctionNumber(readJunctionRecordPath(entry, path));
-        return numeric !== undefined && numeric > 0;
-    });
-}
-function hasNonEmptyJunctionRecordArrayFromPaths(entry, paths) {
-    return paths.some((path) => readJunctionRecordArray(readJunctionRecordPath(entry, path)).some(isUsefulJunctionRawOnlyArrayEntry));
-}
-function isUsefulJunctionRawOnlyArrayEntry(value) {
-    if (value === undefined || value === null) {
-        return false;
+function resolveJunctionHistoricalCoverageProviderSlug(value, providerFilter) {
+    const providerSlug = canonicalizeJunctionHistoricalProviderSlug(value);
+    if (!providerSlug) {
+        return null;
     }
-    if (typeof value === "string") {
-        return normalizeString(value) !== undefined;
+    const route = resolveJunctionDeviceConnectRouteByProviderSlug(providerSlug)?.route;
+    if (!route) {
+        return null;
     }
-    if (typeof value === "number") {
-        return Number.isFinite(value);
+    return route.kind === "junction_sdk" || providerFilter.includes(providerSlug)
+        ? providerSlug
+        : null;
+}
+function isJunctionHistoricalBackfillRequiredSummaryResource(resource) {
+    return JUNCTION_HISTORICAL_BACKFILL_REQUIRED_SUMMARY_RESOURCE_SET.has(resource);
+}
+function readJunctionDirectHistoricalEvidenceWindow(input, connectWindow, evidence, providerFilter) {
+    const providerSlug = resolveJunctionHistoricalCoverageProviderSlug(input.sourceProviderSlug, providerFilter);
+    if (!providerSlug
+        || !isJunctionHistoricalBackfillRequiredSummaryResource(input.resource)
+        || !evidence.some((entry) => entry.resource === input.resource
+            && canonicalizeJunctionHistoricalProviderSlug(entry.sourceProviderSlug) === providerSlug)) {
+        return null;
     }
-    if (typeof value === "boolean") {
+    return connectWindow;
+}
+function isJunctionResourceAdvertisedAvailable(value) {
+    if (value === true) {
         return true;
     }
-    if (Array.isArray(value)) {
-        return value.some(isUsefulJunctionRawOnlyArrayEntry);
+    if (typeof value === "string") {
+        return value.trim().toLowerCase() === "available";
     }
     const record = readPlainObject(value);
     if (!record) {
         return false;
     }
-    return Object.entries(record).some(([key, nested]) => !isBlockedJunctionImportSourceIdentityKey(key)
-        && !isBlockedJunctionImportSourceIdentityContainerKey(key)
-        && isUsefulJunctionRawOnlyArrayEntry(nested));
-}
-function hasPositiveJunctionTimestampRange(entry, startPaths, endPaths, sourceProviderSlug) {
-    const startAt = firstJunctionTimestampMillisFromPaths(entry, startPaths, sourceProviderSlug);
-    const endAt = firstJunctionTimestampMillisFromPaths(entry, endPaths, sourceProviderSlug);
-    return startAt !== null && endAt !== null && endAt > startAt;
+    return record.available === true
+        || normalizeString(record.status)?.toLowerCase() === "available";
 }
-function firstJunctionTimestampMillisFromPaths(entry, paths, sourceProviderSlug) {
-    for (const path of paths) {
-        const timestamp = junctionTimestampMillis(readJunctionRecordPath(entry, path), sourceProviderSlug);
-        if (timestamp !== null) {
-            return timestamp;
-        }
-    }
-    return null;
-}
-function readJunctionRecordPath(entry, path) {
-    return path.split(".").reduce((current, key) => {
-        const record = readPlainObject(current);
-        return record ? record[key] : undefined;
-    }, entry);
+function isJunctionHistoricalBackfillCompletionSummaryResource(resource) {
+    return JUNCTION_HISTORICAL_BACKFILL_COMPLETION_SUMMARY_RESOURCE_SET.has(resource);
 }
 function readJunctionRecordArray(value) {
     return Array.isArray(value) ? value : [];
 }
-function finiteJunctionNumber(value) {
-    if (typeof value === "number" && Number.isFinite(value)) {
-        return value;
-    }
-    if (typeof value === "string" && value.trim()) {
-        const numeric = Number(value);
-        return Number.isFinite(numeric) ? numeric : undefined;
-    }
-    return undefined;
-}
-function junctionTimestampMillis(value, sourceProviderSlug) {
-    if (value instanceof Date && Number.isFinite(value.getTime())) {
-        return value.getTime();
-    }
-    if (typeof value === "number" && Number.isFinite(value)) {
-        return value;
-    }
-    if (typeof value !== "string" || !value.trim()) {
-        return null;
-    }
-    const trimmed = value.trim();
-    if (isRejectedJunctionSafeTimestampString(trimmed, sourceProviderSlug)) {
-        return null;
-    }
-    const parsed = Date.parse(trimmed);
-    return Number.isFinite(parsed) ? parsed : null;
-}
-function isRejectedJunctionSafeTimestampString(value, sourceProviderSlug) {
-    if (isJunctionSourceSpecificFloatingTimestampProvider(sourceProviderSlug)) {
-        return true;
-    }
-    return /^\d{4}-\d{2}-\d{2}(?:$|[ t]\d{2}:\d{2})/iu.test(value)
-        && !/z$/iu.test(value)
-        && !/[+-]\d{2}:?\d{2}$/u.test(value);
-}
-function isJunctionSourceSpecificFloatingTimestampProvider(sourceProviderSlug) {
-    const normalizedSourceProviderSlug = normalizeProviderSlug(sourceProviderSlug);
-    return normalizedSourceProviderSlug
-        ? JUNCTION_FLOATING_TIMESTAMP_SOURCE_PROVIDER_SLUGS.has(normalizedSourceProviderSlug)
-        : false;
-}
 function buildHistoricalBackfillFollowUp(input) {
-    if (input.hasRecords) {
+    if (!canCurrentRuntimeMutateJunctionHistoricalBackfillProgress(input.metadata)) {
+        return {};
+    }
+    if (input.coverageComplete) {
         return {
             metadataPatch: buildHistoricalBackfillMetadataPatch({
                 status: "complete",
@@ -3057,8 +3090,18 @@ function buildHistoricalBackfillFollowUp(input) {
         || hasHistoricalBackfillWindowStatus(input.metadata, "exhausted", input.windowStart, input.windowEnd)) {
         return {};
     }
-    const emptyAttempts = readHistoricalBackfillEmptyAttempts(input.metadata, input.windowStart, input.windowEnd) + 1;
-    const retryDelayMs = EMPTY_HISTORICAL_BACKFILL_RETRY_DELAYS_MS[emptyAttempts - 1] ?? null;
+    const pendingRetryAt = readPendingHistoricalBackfillRetryAt(input.metadata, input.windowStart, input.windowEnd);
+    const pendingRetryAtMs = pendingRetryAt ? Date.parse(pendingRetryAt) : NaN;
+    if (pendingRetryAt && Number.isFinite(pendingRetryAtMs) && Date.parse(input.now) < pendingRetryAtMs) {
+        return { nextReconcileAt: pendingRetryAt };
+    }
+    const previousEmptyAttempts = readHistoricalBackfillEmptyAttempts(input.metadata, input.windowStart, input.windowEnd);
+    let emptyAttempts = previousEmptyAttempts + 1;
+    let retryDelayMs = EMPTY_HISTORICAL_BACKFILL_RETRY_DELAYS_MS[emptyAttempts - 1] ?? null;
+    if (retryDelayMs === null && !input.terminalFailure) {
+        emptyAttempts = EMPTY_HISTORICAL_BACKFILL_RETRY_DELAYS_MS.length;
+        retryDelayMs = EMPTY_HISTORICAL_BACKFILL_RETRY_DELAYS_MS[emptyAttempts - 1] ?? null;
+    }
     const status = retryDelayMs === null ? "exhausted" : "retrying";
     const metadataPatch = buildHistoricalBackfillMetadataPatch({
         status,
@@ -3070,23 +3113,66 @@ function buildHistoricalBackfillFollowUp(input) {
     if (retryDelayMs === null) {
         return { metadataPatch };
     }
+    const retryAt = addMilliseconds(input.now, retryDelayMs);
+    return {
+        metadataPatch,
+        nextReconcileAt: retryAt,
+    };
+}
+function readPendingHistoricalBackfillRetryAt(metadata, windowStart, windowEnd) {
+    if (readHistoricalBackfillCoverageVersion(metadata)
+        !== JUNCTION_HISTORICAL_BACKFILL_COVERAGE_VERSION) {
+        return null;
+    }
+    const status = readHistoricalBackfillStatus(metadata)?.status ?? null;
+    if (status !== "retrying") {
+        return null;
+    }
+    const metadataWindowStart = normalizeString(metadata[JUNCTION_HISTORICAL_BACKFILL_METADATA_KEYS.windowStart]);
+    const metadataWindowEnd = normalizeString(metadata[JUNCTION_HISTORICAL_BACKFILL_METADATA_KEYS.windowEnd]);
+    if (metadataWindowStart !== windowStart || metadataWindowEnd !== windowEnd) {
+        return null;
+    }
+    const emptyAttempts = Math.max(1, readHistoricalBackfillEmptyAttempts(metadata, windowStart, windowEnd));
+    const retryDelayMs = EMPTY_HISTORICAL_BACKFILL_RETRY_DELAYS_MS[emptyAttempts - 1] ?? null;
+    const lastEmptyAt = normalizeString(metadata[JUNCTION_HISTORICAL_BACKFILL_METADATA_KEYS.lastEmptyAt]);
+    if (retryDelayMs === null || !lastEmptyAt || !Number.isFinite(Date.parse(lastEmptyAt))) {
+        return null;
+    }
+    return addMilliseconds(lastEmptyAt, retryDelayMs);
+}
+function buildNonConnectHistoricalBackfillFollowUp(input) {
+    if (input.hasRecords) {
+        return {};
+    }
+    const emptyAttempts = readHistoricalBackfillJobEmptyAttempts(input.job) + 1;
+    const retryDelayMs = EMPTY_HISTORICAL_BACKFILL_RETRY_DELAYS_MS[emptyAttempts - 1] ?? null;
+    if (retryDelayMs === null) {
+        return {};
+    }
+    const retryAt = addMilliseconds(input.now, retryDelayMs);
     const retryJob = buildExactWindowJob({
         kind: "backfill",
+        priority: Math.max(input.job.priority, JUNCTION_HISTORICAL_BACKFILL_RETRY_PRIORITY),
         windowStart: input.windowStart,
         windowEnd: input.windowEnd,
-        priority: 30,
     });
     return {
-        metadataPatch,
-        scheduledJobs: [{
+        scheduledJobs: [
+            {
                 ...retryJob,
-                availableAt: addMilliseconds(input.now, retryDelayMs),
-            }],
+                availableAt: retryAt,
+                payload: {
+                    ...(retryJob.payload ?? {}),
+                    emptyBackfillAttempts: emptyAttempts,
+                },
+            },
+        ],
     };
 }
 function buildHistoricalBackfillMetadataPatch(input) {
     return {
-        [JUNCTION_HISTORICAL_BACKFILL_METADATA_KEYS.status]: input.status,
+        [JUNCTION_HISTORICAL_BACKFILL_METADATA_KEYS.status]: encodeJunctionHistoricalBackfillStatus(input.status),
         [JUNCTION_HISTORICAL_BACKFILL_METADATA_KEYS.emptyAttempts]: input.emptyAttempts,
         [JUNCTION_HISTORICAL_BACKFILL_METADATA_KEYS.lastEmptyAt]: input.lastEmptyAt,
         [JUNCTION_HISTORICAL_BACKFILL_METADATA_KEYS.windowStart]: input.windowStart,
@@ -3094,12 +3180,16 @@ function buildHistoricalBackfillMetadataPatch(input) {
     };
 }
 function hasHistoricalBackfillWindowStatus(metadata, status, windowStart, windowEnd) {
-    return normalizeString(metadata[JUNCTION_HISTORICAL_BACKFILL_METADATA_KEYS.status]) === status
+    return readHistoricalBackfillCoverageVersion(metadata)
+        === JUNCTION_HISTORICAL_BACKFILL_COVERAGE_VERSION
+        && readHistoricalBackfillStatus(metadata)?.status === status
         && normalizeString(metadata[JUNCTION_HISTORICAL_BACKFILL_METADATA_KEYS.windowStart]) === windowStart
         && normalizeString(metadata[JUNCTION_HISTORICAL_BACKFILL_METADATA_KEYS.windowEnd]) === windowEnd;
 }
 function readHistoricalBackfillEmptyAttempts(metadata, windowStart, windowEnd) {
-    if (normalizeString(metadata[JUNCTION_HISTORICAL_BACKFILL_METADATA_KEYS.windowStart]) !== windowStart
+    if (readHistoricalBackfillCoverageVersion(metadata)
+        !== JUNCTION_HISTORICAL_BACKFILL_COVERAGE_VERSION
+        || normalizeString(metadata[JUNCTION_HISTORICAL_BACKFILL_METADATA_KEYS.windowStart]) !== windowStart
         || normalizeString(metadata[JUNCTION_HISTORICAL_BACKFILL_METADATA_KEYS.windowEnd]) !== windowEnd) {
         return 0;
     }
@@ -3108,6 +3198,22 @@ function readHistoricalBackfillEmptyAttempts(metadata, windowStart, windowEnd) {
         ? rawAttempts
         : 0;
 }
+function readHistoricalBackfillStatus(metadata) {
+    return readJunctionHistoricalBackfillStatus(metadata[JUNCTION_HISTORICAL_BACKFILL_METADATA_KEYS.status]);
+}
+function readHistoricalBackfillCoverageVersion(metadata) {
+    return readHistoricalBackfillStatus(metadata)?.coverageVersion ?? 0;
+}
+function readHistoricalBackfillJobEmptyAttempts(job) {
+    const rawAttempts = job.payload.emptyBackfillAttempts;
+    return typeof rawAttempts === "number" && Number.isInteger(rawAttempts) && rawAttempts > 0 ? rawAttempts : 0;
+}
+function buildConnectHistoricalBackfillWindow(account, summaryBackfillDays) {
+    return {
+        windowStart: floorUtcDayTimestamp(subtractDays(account.connectedAt, summaryBackfillDays)),
+        windowEnd: floorUtcDayTimestamp(account.connectedAt),
+    };
+}
 function buildWindowJob(input) {
     const windowEnd = floorUtcDayTimestamp(input.now);
     const windowStart = floorUtcDayTimestamp(input.windowStart);
@@ -3115,6 +3221,7 @@ function buildWindowJob(input) {
         kind: input.kind,
         windowStart,
         windowEnd,
+        availableAt: input.now,
         priority: input.priority,
     });
 }
@@ -3124,8 +3231,10 @@ function buildExactWindowJob(input) {
         payload: {
             windowStart: input.windowStart,
             windowEnd: input.windowEnd,
+            ...(input.payload ?? {}),
         },
         priority: input.priority,
+        ...(input.availableAt ? { availableAt: input.availableAt } : {}),
         dedupeKey: sha256Text(JSON.stringify(["junction", input.kind, input.windowStart, input.windowEnd])),
     };
 }
@@ -3133,20 +3242,12 @@ function buildJunctionWebhookJobs(input) {
     if (isJunctionProviderConnectionEvent(input.eventType)) {
         const backfillWindowStart = subtractDays(input.window.windowEnd, input.summaryBackfillDays);
         return [
-            {
+            buildExactWindowJob({
                 kind: "backfill",
-                payload: {
-                    windowStart: backfillWindowStart,
-                    windowEnd: input.window.windowEnd,
-                },
+                windowStart: backfillWindowStart,
+                windowEnd: input.window.windowEnd,
                 priority: 35,
-                dedupeKey: sha256Text(JSON.stringify([
-                    "junction-webhook",
-                    "connection-backfill",
-                    backfillWindowStart,
-                    input.window.windowEnd,
-                ])),
-            },
+            }),
             {
                 kind: "reconcile",
                 payload: {
@@ -3302,7 +3403,10 @@ function buildJunctionWebhookDataJobJsons(input) {
         && isJunctionHistoricalPullCompletedWebhookData(input.data, input.externalAccountId)) {
         return [];
     }
-    const sanitized = sanitizeJunctionImportSnapshotValue(input.data, new Map(), { blockedStringValues: [input.externalAccountId] });
+    const sanitized = sanitizeJunctionImportSnapshotValue(input.data, new Map(), {
+        blockedStringValues: [input.externalAccountId],
+        preserveSourceReferenceKeys: true,
+    });
     const record = readPlainObject(sanitized);
     if (!record) {
         return [];
@@ -3328,6 +3432,92 @@ function parseJunctionWebhookDataJobRecord(value) {
         return null;
     }
 }
+const JUNCTION_COMPANION_HEALTH_METADATA_TIMESTAMP_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,9})?(?:Z|[+-]\d{2}:\d{2})$/u;
+function parseJunctionCompanionHealthMetadataJob(job) {
+    if (job.payload.resource !== JUNCTION_COMPANION_HEALTH_METADATA_RESOURCE) {
+        throw invalidJunctionCompanionHealthMetadataJob("resource is invalid");
+    }
+    if (job.payload.eventType !== JUNCTION_COMPANION_HEALTH_METADATA_EVENT_TYPE) {
+        throw invalidJunctionCompanionHealthMetadataJob("eventType is invalid");
+    }
+    if (job.payload.resourceCategory !== "summary") {
+        throw invalidJunctionCompanionHealthMetadataJob("resourceCategory is invalid");
+    }
+    if (job.payload.sourceProviderSlug !== JUNCTION_COMPANION_HEALTH_METADATA_SOURCE_PROVIDER) {
+        throw invalidJunctionCompanionHealthMetadataJob("sourceProviderSlug is invalid");
+    }
+    const receivedAt = toJunctionCompanionHealthMetadataIsoTimestamp(job.payload.occurredAt);
+    if (!receivedAt) {
+        throw invalidJunctionCompanionHealthMetadataJob("occurredAt is invalid");
+    }
+    const receivedAtMs = Date.parse(receivedAt);
+    const json = typeof job.payload.webhookDataJson === "string"
+        ? job.payload.webhookDataJson
+        : null;
+    if (!json || Buffer.byteLength(json, "utf8") > JUNCTION_COMPANION_HEALTH_METADATA_MAX_BATCH_BYTES) {
+        throw invalidJunctionCompanionHealthMetadataJob("batch JSON is missing or too large");
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(json);
+    }
+    catch {
+        throw invalidJunctionCompanionHealthMetadataJob("batch JSON is invalid");
+    }
+    try {
+        return parseJunctionCompanionHealthMetadataBatch(parsed, receivedAtMs).records;
+    }
+    catch (error) {
+        if (error instanceof JunctionCompanionHealthMetadataParseError) {
+            throw invalidJunctionCompanionHealthMetadataJob(error.message);
+        }
+        throw error;
+    }
+}
+function invalidJunctionCompanionHealthMetadataJob(reason) {
+    return deviceSyncError({
+        code: "DEVICE_SYNC_JOB_PAYLOAD_INVALID",
+        message: `Junction companion health metadata ${reason}.`,
+        retryable: false,
+    });
+}
+function buildJunctionCompanionRecoverySummary(record) {
+    return stripUndefined({
+        id: record.recordId,
+        date: record.endAt,
+        companionStartAt: record.startAt,
+        companionEndAt: record.endAt,
+        companionSyncVersion: record.syncVersion,
+        recovery_readiness_score: record.value,
+        source: {
+            provider: JUNCTION_COMPANION_HEALTH_METADATA_SOURCE_PROVIDER,
+            type: JUNCTION_COMPANION_HEALTH_METADATA_SOURCE_TYPE,
+        },
+    });
+}
+function buildJunctionCompanionWorkoutStrainSummary(record) {
+    return stripUndefined({
+        id: record.recordId,
+        date: record.endAt,
+        companionStartAt: record.startAt,
+        companionEndAt: record.endAt,
+        companionSyncVersion: record.syncVersion,
+        workout_strain: record.value,
+        source: {
+            provider: JUNCTION_COMPANION_HEALTH_METADATA_SOURCE_PROVIDER,
+            type: JUNCTION_COMPANION_HEALTH_METADATA_SOURCE_TYPE,
+        },
+    });
+}
+function toJunctionCompanionHealthMetadataIsoTimestamp(value) {
+    if (typeof value !== "string"
+        || value.length > 64
+        || !JUNCTION_COMPANION_HEALTH_METADATA_TIMESTAMP_PATTERN.test(value)) {
+        return null;
+    }
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) ? new Date(parsed).toISOString() : null;
+}
 function resolveJunctionWebhookDataRecordSourceProviderSlug(record) {
     const slugs = new Set();
     const addSlug = (value) => {
@@ -3428,15 +3618,7 @@ function inferJunctionWebhookResource(eventType, data) {
         category: inferJunctionResourceCategory(explicitCategory, resource),
     };
 }
-export { normalizeJunctionResourceName } from "@murphai/importers/device-providers/junction-resources";
-/**
- * Resolves the normalized Junction resource name carried by a webhook event
- * type such as `daily.data.sleep.created`. Lifecycle events (for example
- * `provider.connection.created`) carry no data resource and resolve to null.
- */
-export function readJunctionWebhookResourceName(eventType) {
-    return normalizeJunctionResourceName(readJunctionWebhookResourceFromEventType(eventType));
-}
+export { normalizeJunctionResourceName, readJunctionWebhookResourceName } from "../junction-resources.js";
 function readJunctionWebhookResourceFromEventType(eventType) {
     const parts = eventType.split(".").map((part) => part.trim()).filter(Boolean);
     const dataIndex = parts.indexOf("data");
@@ -3874,26 +4056,56 @@ function describeJunctionWebhookIdentityCandidateDiagnostics(candidates, selecti
     }
     return diagnosticCandidates;
 }
-async function projectJunctionSources(context, providers) {
+async function projectJunctionSources(context, providers, options = {}) {
     if (!context.upsertConnectionSource) {
         context.logger.warn?.("Junction source projection skipped because the job context does not expose source storage.", {
             provider: "junction",
         });
         return;
     }
+    const historicalState = readHistoricalBackfillStatus(context.account.metadata);
+    const preserveOpaqueHistoricalReconnect = !canCurrentRuntimeMutateJunctionHistoricalBackfillProgress(context.account.metadata);
+    const preserveHistoricalReconnect = options.preserveHistoricalReconnect ?? (options.preserveHistoricalReconnectProviderSlugs !== undefined
+        || preserveOpaqueHistoricalReconnect
+        || (historicalState !== null
+            && historicalState.coverageVersion >= JUNCTION_HISTORICAL_BACKFILL_COVERAGE_VERSION
+            && historicalState.status !== "complete"));
+    const preserveHistoricalReconnectProviderSlugs = options.preserveHistoricalReconnectProviderSlugs === undefined
+        ? null
+        : new Set(options.preserveHistoricalReconnectProviderSlugs);
+    const existingSources = context.listConnectionSources
+        ? await context.listConnectionSources()
+        : [];
+    const existingByInstanceKey = new Map(existingSources.map((source) => [source.sourceInstanceKey, source]));
     for (const source of projectJunctionSourcesByProviderSlug(context.account.id, providers)) {
+        const existing = existingByInstanceKey.get(source.sourceInstanceKey) ?? existingSources.find((candidate) => normalizeProviderSlug(candidate.sourceProviderSlug) === source.sourceProviderSlug);
+        const keepHistoricalReconnect = preserveHistoricalReconnect
+            && (preserveHistoricalReconnectProviderSlugs === null
+                || preserveHistoricalReconnectProviderSlugs.has(source.sourceProviderSlug))
+            && source.status !== "disconnected"
+            && existing !== undefined
+            && (preserveOpaqueHistoricalReconnect
+                ? existing.status === "error"
+                    && existing.lastErrorCode === DEVICE_SYNC_HISTORICAL_DATA_RECONNECT_REQUIRED_ERROR_CODE
+                : requiresHistoricalResetDeviceSyncSource(existing));
+        const historicalReconnectError = keepHistoricalReconnect ? existing : null;
         await context.upsertConnectionSource({
-            sourceInstanceKey: source.sourceInstanceKey,
+            sourceInstanceKey: existing?.sourceInstanceKey ?? source.sourceInstanceKey,
             sourceProviderSlug: source.sourceProviderSlug,
-            displayName: null,
-            status: source.status,
+            displayName: existing?.displayName ?? null,
+            status: keepHistoricalReconnect ? "error" : source.status,
             resourceAvailabilitySummary: source.resourceAvailabilitySummary,
             // Only assert error fields when this projection saw an errored entry;
             // omitting the keys lets the store preserve existing detail while the
             // status stays "error" and auto-clear it once the status recovers.
-            ...(source.lastErrorCode !== null || source.lastErrorMessage !== null
-                ? { lastErrorCode: source.lastErrorCode, lastErrorMessage: source.lastErrorMessage }
-                : {}),
+            ...(historicalReconnectError
+                ? {
+                    lastErrorCode: historicalReconnectError.lastErrorCode,
+                    lastErrorMessage: historicalReconnectError.lastErrorMessage,
+                }
+                : source.lastErrorCode !== null || source.lastErrorMessage !== null
+                    ? { lastErrorCode: source.lastErrorCode, lastErrorMessage: source.lastErrorMessage }
+                    : {}),
             lastSeenAt: context.now,
         });
     }
@@ -4099,12 +4311,8 @@ function readPlainObject(value) {
         ? value
         : null;
 }
-function assertValidJunctionClientUserIdSecret(secret) {
-    const normalizedSecret = normalizeString(secret);
-    if (!normalizedSecret || normalizedSecret.length < 16) {
-        throw new TypeError("JUNCTION_CLIENT_USER_ID_SECRET must be at least 16 characters.");
-    }
-    return normalizedSecret;
+function readProviderSnapshotDurableDeliveryAccepted(value) {
+    return readPlainObject(value)?.durableDeliveryAccepted === true;
 }
 function base32UrlEncode(input) {
     const alphabet = "abcdefghijklmnopqrstuvwxyz234567";